"use strict";
/* jshint ignore:start */

/* jshint ignore:end */

define('dummy/app', ['exports', 'ember', 'ember/resolver', 'ember/load-initializers', 'dummy/config/environment'], function (exports, Ember, Resolver, loadInitializers, config) {

  'use strict';

  var App;

  Ember['default'].MODEL_FACTORY_INJECTIONS = true;

  App = Ember['default'].Application.extend({
    modulePrefix: config['default'].modulePrefix,
    podModulePrefix: config['default'].podModulePrefix,
    Resolver: Resolver['default']
  });

  loadInitializers['default'](App, config['default'].modulePrefix);

  exports['default'] = App;

});
define('dummy/components/app-version', ['exports', 'ember-cli-app-version/components/app-version', 'dummy/config/environment'], function (exports, AppVersionComponent, config) {

  'use strict';

  var _config$APP = config['default'].APP;
  var name = _config$APP.name;
  var version = _config$APP.version;

  exports['default'] = AppVersionComponent['default'].extend({
    version: version,
    name: name
  });

});
define('dummy/controllers/array', ['exports', 'ember'], function (exports, Ember) {

	'use strict';

	exports['default'] = Ember['default'].Controller;

});
define('dummy/controllers/object', ['exports', 'ember'], function (exports, Ember) {

	'use strict';

	exports['default'] = Ember['default'].Controller;

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/index', ['exports', 'ember', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/builder', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/validators/id', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/reduce', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/compose'], function (exports, Ember, buildValidator, vid, reduce, validatorComposition) {

  'use strict';

  var FunctionalValidation;

  FunctionalValidation = (function () {
    function FunctionalValidation() {}

    FunctionalValidation.create = function (instructions) {
      var attribute, validations, validatorName, validatorOptions, validators;
      validators = Ember['default'].A();
      for (attribute in instructions) {
        validations = instructions[attribute];
        for (validatorName in validations) {
          validatorOptions = validations[validatorName];
          validators.pushObject(buildValidator['default']({
            attribute: attribute,
            validatorName: validatorName,
            validatorOptions: validatorOptions
          }));
        }
      }
      return reduce['default'](validators, validatorComposition['default'], vid['default']);
    };

    return FunctionalValidation;
  })();

  exports['default'] = FunctionalValidation;

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/builder', ['exports', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/validators/presence', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/validators/absence', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/validators/custom', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/validators/less-than', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/curry'], function (exports, presence, absence, custom, numeric, curry) {

  'use strict';

  var build;

  build = function (arg) {
    var attribute, validatorName, validatorOptions;
    attribute = arg.attribute, validatorName = arg.validatorName, validatorOptions = arg.validatorOptions;
    switch (validatorName) {
      case "presence":
        return function (model) {
          return presence['default'](attribute, validatorOptions, model);
        };
      case "absence":
        return function (model) {
          return absence['default'](attribute, validatorOptions, model);
        };
      case "custom":
      case "inline":
        return function (model) {
          return custom['default'](attribute, validatorOptions, model);
        };
      case "lessThan":
        return function (model) {
          return numeric['default'].lessThan(attribute, validatorOptions, model);
        };
      case "lessThanEqualTo":
        return function (model) {
          return numeric['default'].lessThan(attribute, validatorOptions, model);
        };
      case "greaterThan":
        return function (model) {
          return numeric['default'].greaterThan(attribute, validatorOptions, model);
        };
      case "greaterThanEqualTo":
        return function (model) {
          return numeric['default'].greaterThanEqualTo(attribute, validatorOptions, model);
        };
      case "equal":
        return numeric['default'].equal(attribute, validatorOptions, model);
      default:
        throw new Error("I don't know what it means to validate the " + attribute + " attribute with the " + validatorName + " validator");
    }
  };

  exports['default'] = build;

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/comparions.jshint', function () {

  'use strict';

  QUnit.module('JSHint - modules/ember-functional-validation/utils');
  QUnit.test('modules/ember-functional-validation/utils/comparions.js should pass jshint', function (assert) {
    assert.ok(true, 'modules/ember-functional-validation/utils/comparions.js should pass jshint.');
  });

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/compose', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var compose, merge;

  Ember['default'].RSVP.on('error', function (reason) {
    return console.assert(false, reason);
  });

  compose = function (vf, vg) {
    return function (model) {
      var promiseF, promiseG;
      promiseF = vf(model);
      promiseG = vg(model);
      return Ember['default'].RSVP.allSettled([promiseF, promiseG]).then(function (arg) {
        var resultF, resultG;
        resultF = arg[0], resultG = arg[1];
        return new Ember['default'].RSVP.Promise(function (resolve, reject) {
          if (resultF.state === "fulfilled" && resultG.state === "fulfilled") {
            return resolve(model);
          } else {
            return reject(merge(resultF.reason, resultG.reason));
          }
        });
      });
    };
  };

  merge = function (errorsA, errorsB) {
    if (Ember['default'].isBlank(errorsB)) {
      return errorsA;
    }
    if (Ember['default'].isBlank(errorsA)) {
      return errorsB;
    }
    if (!(errorsA.has != null && errorsA.get != null)) {
      throw new Error("expected some sort of an observable enumerable object but instead got a " + errorsA);
    }
    if (errorsB.forEach == null) {
      throw new Error("expected some sort of an observable enumerable object but instead got a " + errorsB);
    }
    errorsB.forEach(function (messages, attributeName) {
      if (errorsA.has(attributeName)) {
        messages = errorsA.get(attributeName).concat(messages);
      }
      return errorsA.set(attributeName, messages);
    });
    return errorsA;
  };

  exports['default'] = compose;

  exports.merge = merge;
  exports.compose = compose;

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/curry', ['exports'], function (exports) {

  'use strict';

  var curry,
      slice = [].slice;

  curry = function () {
    var f, params;
    f = arguments[0], params = 2 <= arguments.length ? slice.call(arguments, 1) : [];
    return function () {
      var xs;
      xs = 1 <= arguments.length ? slice.call(arguments, 0) : [];
      return f.apply(null, slice.call(params).concat(slice.call(xs)));
    };
  };

  exports['default'] = curry;

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/error-map', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var ErrorMap;

  ErrorMap = Ember['default'].Object.extend({
    init: function init() {
      this._super.apply(this, arguments);
      this.core = {};
      this.length = 0;
      return this.size = 0;
    },
    set: function set(key, value) {
      if (!this.has(key)) {
        this.incrementProperty("length");
        this.incrementProperty("size");
      }
      this.core[key] = value;
      return this._super.apply(this, arguments);
    },
    has: function has(key) {
      return this.core.hasOwnProperty(key);
    },
    forEach: function forEach(cb) {
      return this.map(cb);
    },
    map: function map(cb) {
      var key, output, ref, value;
      output = Ember['default'].A();
      ref = this.core;
      for (key in ref) {
        value = ref[key];
        output.push(cb(value, key));
      }
      return output;
    }
  });

  exports['default'] = ErrorMap;

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/lifts', ['exports', 'ember', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/error-map'], function (exports, Ember, ErrorMap) {

  'use strict';

  var errorLift, rejectLift, resolveLift;

  errorLift = function (attribute, error) {
    var errorsMap, messages;
    errorsMap = new ErrorMap['default']();
    if (error != null && error.message != null) {
      messages = Ember['default'].A([error.message]);
    } else {
      messages = Ember['default'].A([error]);
    }
    errorsMap.set(attribute, messages);
    return errorsMap;
  };

  resolveLift = function (maybePromise) {
    if (maybePromise != null && maybePromise.then != null && typeof maybePromise.then === 'function') {
      return Ember['default'].RSVP.allSettled([maybePromise]).then(function (arg) {
        var result, value;
        result = arg[0];
        value = result.state === "fulfilled" ? result.value : result.reason;
        return new Ember['default'].RSVP.Promise(function (resolve) {
          return resolve(value);
        });
      });
    } else {
      return new Ember['default'].RSVP.Promise(function (resolve) {
        return resolve(maybePromise);
      });
    }
  };

  rejectLift = function (maybePromise) {
    if (maybePromise != null && maybePromise.then != null && typeof maybePromise.then === 'function') {
      return Ember['default'].RSVP.allSettled([maybePromise]).then(function (arg) {
        var result, value;
        result = arg[0];
        value = result.state === "fulfilled" ? result.value : result.reason;
        return new Ember['default'].RSVP.Promise(function (_, reject) {
          return reject(value);
        });
      });
    } else {
      return new Ember['default'].RSVP.Promise(function (_, reject) {
        return reject(maybePromise);
      });
    }
  };

  exports['default'] = errorLift;

  exports.resolveLift = resolveLift;
  exports.rejectLift = rejectLift;
  exports.errorLift = errorLift;

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/numericality-core', ['exports', 'ember', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/lifts', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/comparions'], function (exports, Ember, lifts, Comparisons) {

  'use strict';

  var errorMsg, getCompFun, numericalityCore;

  numericalityCore = function (op, attribute, valuePromise, model) {
    var comp, value;
    comp = getCompFun(op);
    value = Ember['default'].get(model, attribute);
    return valuePromise.then(function (refValue) {
      return new Ember['default'].RSVP.Promise(function (resolve, reject) {
        if (comp(value, refValue)) {
          return resolve(model);
        } else {
          return reject(lifts.errorLift(attribute, "must be " + comp.name + " " + refValue));
        }
      });
    });
  };

  errorMsg = function (op) {
    return "`" + op + "` is not a known comparison operator. \nThe known comparison operators are:\n\n`<`, `>`, `=`, `<=`, and `>=`";
  };

  getCompFun = function (op) {
    switch (op) {
      case "<":
        return Comparisons['default'].lessThan;
      case ">":
        return Comparisons['default'].greaterThan;
      case "=":
        return Comparisons['default'].equal;
      case "<=":
        return Comparisons['default'].lessThanEqualTo;
      case ">=":
        return Comparisons['default'].greaterThanEqualTo;
      default:
        throw new Error(errorMsg(op));
    }
  };

  exports['default'] = numericalityCore;

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/reduce.jshint', function () {

  'use strict';

  QUnit.module('JSHint - modules/ember-functional-validation/utils');
  QUnit.test('modules/ember-functional-validation/utils/reduce.js should pass jshint', function (assert) {
    assert.ok(true, 'modules/ember-functional-validation/utils/reduce.js should pass jshint.');
  });

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/validators/absence', ['exports', 'ember', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/lifts'], function (exports, Ember, errorLift) {

  'use strict';

  var absence;

  absence = function (attribute, options, model) {
    var message;
    if (model == null) {
      model = {};
    }
    if (Ember['default'].isBlank(attribute)) {
      throw new Error("You must specify an attribute for me to validate on your " + model + " object");
    }
    message = Ember['default'].getWithDefault(options, "message", "cannot be present");
    return new Ember['default'].RSVP.Promise(function (resolve, reject) {
      if (Ember['default'].isBlank(Ember['default'].get(model, attribute))) {
        return resolve(model);
      } else {
        return reject(errorLift['default'](attribute, message));
      }
    });
  };

  exports['default'] = absence;

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/validators/custom', ['exports', 'ember', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/lifts'], function (exports, Ember, lifts) {

  'use strict';

  var custom;

  custom = function (attribute, errorCheck, model) {
    return lifts.resolveLift(errorCheck(model, attribute)).then(function (errorMsg) {
      return new Ember['default'].RSVP.Promise(function (resolve, reject) {
        if (Ember['default'].isBlank(errorMsg)) {
          return resolve(model);
        } else {
          return reject(lifts.errorLift(attribute, errorMsg));
        }
      });
    });
  };

  exports['default'] = custom;

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/validators/id', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var id;

  id = function (model) {
    return new Ember['default'].RSVP.Promise(function (resolve, reject) {
      return resolve(model);
    });
  };

  exports['default'] = id;

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/validators/less-than', ['exports', 'ember', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/lifts', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/numericality-core'], function (exports, Ember, lifts, numericalityCore) {

  'use strict';

  var compCore, equal, errorMsg, greaterThan, greaterThanEqualTo, lessThan, lessThanEqualTo;

  errorMsg = "You must pass in either a function that returns a value, a promise to the value, \nor a value so the validator can properly make comparisons.";

  lessThan = function (attribute, errorCheck, model) {
    return compCore("<", attribute, errorCheck, model);
  };

  greaterThan = function (attribute, errorCheck, model) {
    return compCore(">", attribute, errorCheck, model);
  };

  equal = function (attribute, errorCheck, model) {
    return compCore("=", attribute, errorCheck, model);
  };

  greaterThanEqualTo = function (attribute, errorCheck, model) {
    return compCore(">=", attribute, errorCheck, model);
  };

  lessThanEqualTo = function (attribute, errorCheck, model) {
    return compCore("<=", attribute, errorCheck, model);
  };

  compCore = function (op, attribute, errorCheck, model) {
    switch (false) {
      case typeof errorCheck !== "function":
        return numericalityCore['default'](op, attribute, lifts.resolveLift(errorCheck(model)), model);
      case typeof errorCheck !== "number":
        return numericalityCore['default'](op, attribute, lifts.resolveLift(errorCheck), model);
      case typeof (errorCheck != null ? errorCheck.then : void 0) !== "function":
        return numericalityCore['default'](op, attribute, errorCheck, model);
      default:
        throw new Error(errorMsg);
    }
  };

  exports['default'] = {
    lessThan: lessThan,
    greaterThan: greaterThan,
    equal: equal,
    greaterThanEqualTo: greaterThanEqualTo,
    lessThanEqualTo: lessThanEqualTo
  };

});
define('dummy/ember-functional-validation/tests/modules/ember-functional-validation/validators/presence', ['exports', 'ember', 'dummy/ember-functional-validation/tests/modules/ember-functional-validation/utils/lifts'], function (exports, Ember, errorLift) {

  'use strict';

  var presence;

  presence = function (attribute, options, model) {
    var message;
    if (model == null) {
      model = {};
    }
    if (Ember['default'].isBlank(attribute)) {
      throw new Error("You must specify an attribute for me to validate on your " + model + " object");
    }
    message = Ember['default'].getWithDefault(options, "message", "cannot be blank");
    return new Ember['default'].RSVP.Promise(function (resolve, reject) {
      var errors;
      if (Ember['default'].isBlank(Ember['default'].get(model, attribute))) {
        errors = errorLift['default'](attribute, message);
        return reject(errors);
      } else {
        return resolve(model);
      }
    });
  };

  exports['default'] = presence;

});
define('dummy/initializers/app-version', ['exports', 'ember-cli-app-version/initializer-factory', 'dummy/config/environment'], function (exports, initializerFactory, config) {

  'use strict';

  var _config$APP = config['default'].APP;
  var name = _config$APP.name;
  var version = _config$APP.version;

  exports['default'] = {
    name: 'App Version',
    initialize: initializerFactory['default'](name, version)
  };

});
define('dummy/initializers/export-application-global', ['exports', 'ember', 'dummy/config/environment'], function (exports, Ember, config) {

  'use strict';

  exports.initialize = initialize;

  function initialize() {
    var application = arguments[1] || arguments[0];
    if (config['default'].exportApplicationGlobal !== false) {
      var value = config['default'].exportApplicationGlobal;
      var globalName;

      if (typeof value === 'string') {
        globalName = value;
      } else {
        globalName = Ember['default'].String.classify(config['default'].modulePrefix);
      }

      if (!window[globalName]) {
        window[globalName] = application;

        application.reopen({
          willDestroy: function willDestroy() {
            this._super.apply(this, arguments);
            delete window[globalName];
          }
        });
      }
    }
  }

  ;

  exports['default'] = {
    name: 'export-application-global',

    initialize: initialize
  };

});
define('dummy/router', ['exports', 'ember', 'dummy/config/environment'], function (exports, Ember, config) {

  'use strict';

  var Router = Ember['default'].Router.extend({
    location: config['default'].locationType
  });

  exports['default'] = Router.map(function () {});

});
define('dummy/templates/application', ['exports'], function (exports) {

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      meta: {
        "revision": "Ember@1.13.7",
        "loc": {
          "source": null,
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 4,
            "column": 0
          }
        },
        "moduleName": "dummy/templates/application.hbs"
      },
      arity: 0,
      cachedFragment: null,
      hasRendered: false,
      buildFragment: function buildFragment(dom) {
        var el0 = dom.createDocumentFragment();
        var el1 = dom.createElement("h2");
        dom.setAttribute(el1,"id","title");
        var el2 = dom.createTextNode("Welcome to Ember.js");
        dom.appendChild(el1, el2);
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n\n");
        dom.appendChild(el0, el1);
        var el1 = dom.createComment("");
        dom.appendChild(el0, el1);
        var el1 = dom.createTextNode("\n");
        dom.appendChild(el0, el1);
        return el0;
      },
      buildRenderNodes: function buildRenderNodes(dom, fragment, contextualElement) {
        var morphs = new Array(1);
        morphs[0] = dom.createMorphAt(fragment,2,2,contextualElement);
        return morphs;
      },
      statements: [
        ["content","outlet",["loc",[null,[3,0],[3,10]]]]
      ],
      locals: [],
      templates: []
    };
  }()));

});
define('dummy/tests/acceptance/numericality-validation-test', ['ember', 'qunit', 'ember-functional-validation'], function (Ember, qunit, FunctionalValidation) {

  'use strict';

  qunit.module('Acceptance: NumericalityValidation', {
    beforeEach: function beforeEach() {
      this.validFun = FunctionalValidation['default'].create({
        username: {
          presence: true
        },
        girls: {
          lessThan: 3
        },
        docks: {
          lessThan: 5
        },
        users: {
          lessThan: function lessThan(x) {
            return x.get("allowedUsers");
          }
        },
        cats: {
          lessThan: new Ember['default'].RSVP.Promise(function (resolve) {
            return resolve(5);
          })
        }
      });

      /*
      Don't return anything, because QUnit looks for a .then
      that is present on Ember.Application, but is deprecated.
       */
    }
  });

  qunit.test('it should have the proper errors', function (assert) {
    var account;
    account = Ember['default'].Object.create({
      username: "Edward II",
      docks: 6,
      users: 4,
      allowedUsers: 3,
      cats: 6
    });
    return this.validFun(account)["catch"](function (errors) {
      assert.deepEqual(errors.docks, ["must be lessThan 5"]);
      assert.deepEqual(errors.girls, ["must be lessThan 3"]);
      assert.deepEqual(errors.users, ["must be lessThan 3"]);
      return assert.deepEqual(errors.cats, ["must be lessThan 5"]);
    });
  });

  qunit.test("it should pass proper objects", function (assert) {
    var account;
    account = Ember['default'].Object.create({
      username: "Edward III",
      docks: 4,
      users: 4,
      allowedUsers: 6,
      cats: 4,
      girls: 2
    });
    return this.validFun(account).then(function (a) {
      return assert.equal(a, account);
    });
  });

});
define('dummy/tests/acceptance/object-validation-test', ['ember', 'qunit', 'ember-functional-validation'], function (Ember, qunit, FunctionalValidation) {

  'use strict';

  qunit.module('Acceptance: FunctionalValidation');

  qunit.test('it exists', function (assert) {
    assert.ok(FunctionalValidation['default']);
    return assert.ok(FunctionalValidation['default'].create);
  });

  qunit.test('it should create a validating function', function (assert) {
    var validFun;
    validFun = FunctionalValidation['default'].create({
      email: {
        presence: true
      },
      username: {
        presence: true
      }
    });
    assert.ok(validFun);
    return assert.equal(typeof validFun, "function");
  });

  qunit.test('it should validate objects', function (assert) {
    var validFun;
    validFun = FunctionalValidation['default'].create({
      email: {
        presence: true
      },
      username: {
        presence: true
      },
      topic: {
        presence: true,
        custom: function custom(model) {
          return new Ember['default'].RSVP.Promise(function (resolve) {
            return Ember['default'].run.later(this, function () {
              return resolve("death to juice");
            }, 10);
          });
        }
      }
    });
    return validFun().then(function () {
      return assert.ok(false, "validation should not pass");
    })["catch"](function (errors) {
      assert.ok(errors);
      assert.equal(errors.size, 3);
      assert.deepEqual(errors.get("email"), ["cannot be blank"]);
      assert.deepEqual(errors.get("username"), ["cannot be blank"]);
      return assert.deepEqual(errors.get("topic"), ["cannot be blank", "death to juice"]);
    });
  });

  qunit.test('it should pass objects which are good', function (assert) {
    var model, validFun;
    validFun = FunctionalValidation['default'].create({
      email: {
        presence: true
      },
      username: {
        presence: true
      },
      topic: {
        presence: true,
        custom: function custom(model) {
          return new Ember['default'].RSVP.Promise(function (resolve) {
            return Ember['default'].run.later(this, resolve, 10);
          });
        }
      }
    });
    model = {
      email: "foxnewsnetwork@gmail.com",
      username: "foxnewsnetwork",
      topic: "some topic"
    };
    return validFun(model).then(function (checkedModel) {
      return assert.equal(model, checkedModel);
    })["catch"](function (errors) {
      return assert.ok(false, "validation should not fail");
    });
  });

  qunit.test('custom validation should have the attribute passed in', function (assert) {
    var model, validFun;
    validFun = FunctionalValidation['default'].create({
      email: {
        presence: true,
        custom: function custom(model, attribute) {
          assert.equal(attribute, "email");
          return null;
        }
      }
    });
    model = {
      email: "e@mail.co"
    };
    return validFun(model).then(function (checkedModel) {
      return assert.equal(model, checkedModel);
    })["catch"](function (errors) {
      return assert.ok(false, "validation should not fail");
    });
  });

});
define('dummy/tests/app.jshint', function () {

  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('app.js should pass jshint', function(assert) { 
    assert.ok(true, 'app.js should pass jshint.'); 
  });

});
define('dummy/tests/helpers/resolver', ['exports', 'ember/resolver', 'dummy/config/environment'], function (exports, Resolver, config) {

  'use strict';

  var resolver = Resolver['default'].create();

  resolver.namespace = {
    modulePrefix: config['default'].modulePrefix,
    podModulePrefix: config['default'].podModulePrefix
  };

  exports['default'] = resolver;

});
define('dummy/tests/helpers/resolver.jshint', function () {

  'use strict';

  QUnit.module('JSHint - helpers');
  QUnit.test('helpers/resolver.js should pass jshint', function(assert) { 
    assert.ok(true, 'helpers/resolver.js should pass jshint.'); 
  });

});
define('dummy/tests/helpers/start-app', ['exports', 'ember', 'dummy/app', 'dummy/router', 'dummy/config/environment'], function (exports, Ember, Application, Router, config) {

  'use strict';



  exports['default'] = startApp;
  function startApp(attrs) {
    var application;

    var attributes = Ember['default'].merge({}, config['default'].APP);
    attributes = Ember['default'].merge(attributes, attrs); // use defaults, but you can override;

    Ember['default'].run(function () {
      application = Application['default'].create(attributes);
      application.setupForTesting();
      application.injectTestHelpers();
    });

    return application;
  }

});
define('dummy/tests/helpers/start-app.jshint', function () {

  'use strict';

  QUnit.module('JSHint - helpers');
  QUnit.test('helpers/start-app.js should pass jshint', function(assert) { 
    assert.ok(true, 'helpers/start-app.js should pass jshint.'); 
  });

});
define('dummy/tests/router.jshint', function () {

  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('router.js should pass jshint', function(assert) { 
    assert.ok(true, 'router.js should pass jshint.'); 
  });

});
define('dummy/tests/test-helper', ['dummy/tests/helpers/resolver', 'ember-qunit'], function (resolver, ember_qunit) {

	'use strict';

	ember_qunit.setResolver(resolver['default']);

});
define('dummy/tests/test-helper.jshint', function () {

  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('test-helper.js should pass jshint', function(assert) { 
    assert.ok(true, 'test-helper.js should pass jshint.'); 
  });

});
define('dummy/tests/unit/utils/compose-test', ['ember', 'qunit', 'ember-functional-validation/utils/compose', 'ember-functional-validation/validators/presence', 'ember-functional-validation/utils/curry'], function (Ember, qunit, compose, presence, curry) {

  'use strict';

  qunit.module("Util: compose");

  qunit.test('it exist', function (assert) {
    assert.ok(compose['default']);
    return assert.equal(typeof compose['default'], 'function');
  });

  qunit.test('it should properly merge error maps', function (assert) {
    var actual, m1, m2;
    m1 = new Ember['default'].Map();
    m1.set("dog", Ember['default'].A(["rover"]));
    m1.set("cat", Ember['default'].A(["mr. mittens"]));
    m2 = new Ember['default'].Map();
    m2.set("dog", Ember['default'].A(["buddy"]));
    m2.set("anime", Ember['default'].A(["4losers"]));
    actual = compose.merge(m1, m2);
    assert.equal(actual.size, 3);
    assert.deepEqual(actual.get("dog"), Ember['default'].A(["rover", "buddy"]));
    assert.deepEqual(actual.get("cat"), Ember['default'].A(["mr. mittens"]));
    return assert.deepEqual(actual.get("anime"), Ember['default'].A(["4losers"]));
  });

  qunit.test('currying should work', function (assert) {
    var v1;
    v1 = curry['default'](presence['default'], "email", true);
    return v1().then(function () {
      return assert.ok(false, "it should not resolve a bad object");
    })["catch"](function (errors) {
      assert.equal(errors.size, 1);
      return assert.deepEqual(errors.get("email"), ["cannot be blank"]);
    });
  });

  qunit.test('currying should work successfully', function (assert) {
    var v1;
    v1 = curry['default'](presence['default'], "email", true);
    return v1({
      email: "dogs@us.gov"
    }).then(function (model) {
      return assert.deepEqual(model, {
        email: "dogs@us.gov"
      });
    })["catch"](function (errors) {
      return assert.ok(false, "it should not reject a good object");
    });
  });

  qunit.test('it should properly compose two validators together', function (assert) {
    var v1, v2, v3;
    v1 = curry['default'](presence['default'], "email", true);
    v2 = curry['default'](presence['default'], "password", true);
    v3 = compose['default'](v1, v2);
    assert.ok(v3);
    assert.equal(typeof v3, 'function');
    return v3().then(function () {
      return assert.ok(false, "it should not have resolved a bad object");
    })["catch"](function (errors) {
      assert.equal(errors.size, 2);
      assert.deepEqual(errors.get("email"), ["cannot be blank"]);
      return assert.deepEqual(errors.get("password"), ["cannot be blank"]);
    });
  });

  qunit.test('composed validators should pass good data', function (assert) {
    var v1, v2, v3;
    v1 = curry['default'](presence['default'], "email", true);
    v2 = curry['default'](presence['default'], "password", true);
    v3 = compose['default'](v1, v2);
    return v3({
      email: "rover@dog.gov",
      password: "woofwoof"
    }).then(function (model) {
      return assert.deepEqual(model, {
        email: "rover@dog.gov",
        password: "woofwoof"
      });
    })["catch"](function (errors) {
      return assert.ok(false, "it should not have rejected a good object");
    });
  });

  qunit.test('nested composition', function (assert) {
    var v1, v2, v3, v4, v5;
    v1 = curry['default'](presence['default'], "email", true);
    v2 = curry['default'](presence['default'], "password", true);
    v3 = compose['default'](v1, v2);
    v4 = curry['default'](presence['default'], "username", true);
    v5 = compose['default'](v3, v4);
    assert.ok(v5);
    assert.equal(typeof v5, 'function');
    return v5().then(function () {
      return assert.ok(false, "it should not have resolved a bad object");
    })["catch"](function (errors) {
      assert.equal(errors.size, 3);
      assert.deepEqual(errors.get("email"), ["cannot be blank"]);
      assert.deepEqual(errors.get("password"), ["cannot be blank"]);
      return assert.deepEqual(errors.get("username"), ["cannot be blank"]);
    });
  });

});
define('dummy/tests/unit/utils/error-map-test', ['ember', 'qunit', 'ember-functional-validation/utils/error-map'], function (Ember, qunit, ErrorMap) {

  'use strict';

  var m;

  m = null;

  qunit.module("Util: ErrorMap", {
    beforeEach: function beforeEach() {
      return m = ErrorMap['default'].create();
    }
  });

  qunit.test('it should all exist', function (assert) {
    return assert.ok(ErrorMap['default']);
  });

  qunit.test('it should set and get correctly', function (assert) {
    var actual, wanted;
    m.set("dog", "rover");
    actual = m.get("dog");
    wanted = "rover";
    return assert.equal(actual, wanted);
  });

  qunit.test('it should has property after setting', function (assert) {
    assert.equal(m.has("dog"), false);
    m.set("dog", "carl");
    return assert.equal(m.has("dog"), true);
  });

  qunit.test('it should be possible to have computed properties properly tied', function (assert) {
    var Dog, rover;
    Dog = Ember['default'].Object.extend({
      name: Ember['default'].computed.alias("errors.name")
    });
    rover = Dog.create({
      errors: m
    });
    assert.ok(!rover.get("name"));
    m.set("name", "Rover");
    assert.equal(m.get("name"), "Rover");
    return assert.equal(rover.get("name"), "Rover");
  });

  qunit.test('for each should iterate properly', function (assert) {
    var actual, wanted;
    m.set("name", "James T. Kirk");
    m.set("rank", "Captain");
    m.set("assignment", "USS Enterprise");
    m.set("fucksAliens", true);
    actual = [];
    m.forEach(function (value, key) {
      return actual.push([key, value]);
    });
    wanted = [["name", "James T. Kirk"], ["rank", "Captain"], ["assignment", "USS Enterprise"], ["fucksAliens", true]];
    return assert.deepEqual(actual, wanted);
  });

  qunit.test('it should have a size and length property', function (assert) {
    assert.equal(m.length, 0);
    m.set("dog", "harold");
    assert.equal(m.length, 1);
    m.set("dog", "rover");
    assert.equal(m.length, 1);
    m.set("cat", "fiffy");
    return assert.equal(m.length, 2);
  });

});
define('dummy/tests/unit/utils/lifts-test', ['ember', 'qunit', 'ember-functional-validation/utils/lifts'], function (Ember, qunit, lifts) {

  'use strict';

  qunit.module("Util: Lifts");

  qunit.test('it should all exist', function (assert) {
    assert.ok(lifts.errorLift);
    assert.ok(lifts.resolveLift);
    return assert.ok(lifts.rejectLift);
  });

  qunit.test('errorLift should always return a map', function (assert) {
    var map;
    map = lifts.errorLift("dog", new Error("are nice"));
    assert.ok(map.has);
    assert.ok(map.get);
    assert.ok(map.set);
    assert.ok(map.forEach);
    assert.ok(map.map);
    assert.equal(map.size, 1);
    return assert.deepEqual(map.get("dog"), ["are nice"]);
  });

  qunit.test('resolveLift should resolve', function (assert) {
    var promise;
    promise = new Ember['default'].RSVP.Promise(function (resolve) {
      return Ember['default'].run.later(this, function () {
        return resolve("nekomimi mode");
      }, 50);
    });
    return lifts.resolveLift(promise).then(function (msg) {
      return assert.equal(msg, "nekomimi mode");
    })["catch"](function () {
      return assert.ok(false, "resolve lift should never reject");
    });
  });

  qunit.test('resolveLift should coerce a promise to always resolve even if it rejects', function (assert) {
    var promise;
    promise = new Ember['default'].RSVP.Promise(function (_, reject) {
      return Ember['default'].run.later(this, function () {
        return reject("nekomimi mode");
      }, 50);
    });
    return lifts.resolveLift(promise).then(function (msg) {
      return assert.equal(msg, "nekomimi mode");
    })["catch"](function () {
      return assert.ok(false, "resolve lift should never reject");
    });
  });

  qunit.test('it should properly lift pure values to promise', function (assert) {
    var value;
    value = 8;
    return lifts.resolveLift(value).then(function (v) {
      return assert.equal(v, value);
    })["catch"](function () {
      return assert.ok(false, "resolve lift should never reject");
    });
  });

  qunit.test('rejectLift should always reject', function (assert) {
    var promise;
    promise = new Ember['default'].RSVP.Promise(function (_, reject) {
      return Ember['default'].run.later(this, function () {
        return reject("nekomimi mode");
      }, 50);
    });
    return lifts.rejectLift(promise).then(function () {
      return assert.ok(false, "resolve lift should never reject");
    })["catch"](function (msg) {
      return assert.equal(msg, "nekomimi mode");
    });
  });

  qunit.test('rejectLift should coerce a promise to always reject even if it resolves', function (assert) {
    var promise;
    promise = new Ember['default'].RSVP.Promise(function (resolve) {
      return Ember['default'].run.later(this, function () {
        return resolve("nekomimi mode");
      }, 50);
    });
    return lifts.rejectLift(promise).then(function () {
      return assert.ok(false, "resolve lift should never reject");
    })["catch"](function (msg) {
      return assert.equal(msg, "nekomimi mode");
    });
  });

  qunit.test('it should properly lift pure values to rejection', function (assert) {
    var value;
    value = 7;
    return lifts.rejectLift(value).then(function () {
      return assert.ok(false, "resolve lift should never reject");
    })["catch"](function (v) {
      return assert.equal(v, value);
    });
  });

});
define('dummy/tests/unit/validators/absence-test', ['ember', 'qunit', 'ember-functional-validation/validators/absence'], function (Ember, qunit, absence) {

  'use strict';

  qunit.module('Validators: Absence');

  qunit.test('it should exist', function (assert) {
    assert.ok(absence['default']);
    return assert.equal(typeof absence['default'], 'function');
  });

  qunit.test('it should reject present junk', function (assert) {
    var model;
    model = {
      email: "foxnewsnetwork@gmail.com",
      username: "foxnewsnetwork"
    };
    return absence['default']("email", true, model).then(function (checkedModel) {
      return assert.ok(false, "it should not get here");
    })["catch"](function (errors) {
      assert.equal(errors.size, 1);
      return assert.deepEqual(errors.get("email"), ["cannot be present"]);
    });
  });

  qunit.test('it should resolve absent junk', function (assert) {
    var model;
    model = null;
    return absence['default']("email", true, model).then(function (model) {
      return assert.deepEqual(model, {});
    })["catch"](function (error) {
      return assert.ok(false, "it should not reject a good object");
    });
  });

});
define('dummy/tests/unit/validators/custom-test', ['ember', 'qunit', 'ember-functional-validation/validators/custom'], function (Ember, qunit, custom) {

  'use strict';

  qunit.module('Validators: Custom');

  qunit.test('it should exist', function (assert) {
    assert.ok(custom['default']);
    return assert.equal(typeof custom['default'], 'function');
  });

  qunit.test('it should error out if the checker returns an error msg', function (assert) {
    var checker, model;
    model = {
      email: "foxnewsnetwork@gmail.com",
      username: "foxnewsnetwork"
    };
    checker = function (model) {
      return "bad model is bad";
    };
    return custom['default']("email", checker, model).then(function () {
      return assert.ok(false, "it should not resolve a bad check");
    })["catch"](function (errors) {
      assert.equal(errors.size, 1);
      return assert.deepEqual(errors.get("email"), ["bad model is bad"]);
    });
  });

  qunit.test('it should properly have the attribute passed in', function (assert) {
    var checker, model;
    model = {
      donkey: "animal"
    };
    checker = function (model, attribute) {
      assert.equal(attribute, "donkey");
      return "animal should be donkey";
    };
    return custom['default']("donkey", checker, model)["catch"](function (errors) {
      return assert.deepEqual(errors.get("donkey"), ["animal should be donkey"]);
    });
  });

  qunit.test('it should resolve promise checkers as well', function (assert) {
    var checker, model;
    model = {
      email: "foxnewsnetwork@gmail.com",
      username: "foxnewsnetwork"
    };
    checker = function (model) {
      return new Ember['default'].RSVP.Promise(function (resolve) {
        return Ember['default'].run.later(this, function () {
          return resolve("some error message");
        }, 75);
      });
    };
    return custom['default']("email", checker, model).then(function () {
      return assert.ok(false, "it should not resolve a bad check");
    })["catch"](function (errors) {
      assert.equal(errors.size, 1);
      return assert.deepEqual(errors.get("email"), ["some error message"]);
    });
  });

  qunit.test('it should properly handle rejected strings also', function (assert) {
    var checker, model;
    model = {
      email: "foxnewsnetwork@gmail.com",
      username: "foxnewsnetwork"
    };
    checker = function (model) {
      return new Ember['default'].RSVP.Promise(function (_, reject) {
        return Ember['default'].run.later(this, function () {
          return reject("some error message");
        }, 75);
      });
    };
    return custom['default']("email", checker, model).then(function () {
      return assert.ok(false, "it should not resolve a bad check");
    })["catch"](function (errors) {
      assert.equal(errors.size, 1);
      return assert.deepEqual(errors.get("email"), ["some error message"]);
    });
  });

  qunit.test('it should properly capture errors', function (assert) {
    var checker, model;
    model = {
      email: "foxnewsnetwork@gmail.com",
      username: "foxnewsnetwork"
    };
    checker = function (model) {
      return new Ember['default'].RSVP.Promise(function () {
        throw new Error("dog food is tasty");
      });
    };
    return custom['default']("email", checker, model).then(function () {
      return assert.ok(false, "it should not resolve a bad check");
    })["catch"](function (errors) {
      assert.equal(errors.size, 1);
      return assert.deepEqual(errors.get("email"), ["dog food is tasty"]);
    });
  });

  qunit.test('things that pass validation should be fine', function (assert) {
    var checker, model;
    model = {
      email: "foxnewsnetwork@gmail.com"
    };
    checker = function (model) {
      return null;
    };
    return custom['default']("email", checker, model).then(function (checkedModel) {
      return assert.equal(model, checkedModel);
    })["catch"](function () {
      return assert.ok(false, "it should not have rejected good models");
    });
  });

  qunit.test('things that pass validation should be fine even as a promise', function (assert) {
    var checker, model;
    model = {
      email: "foxnewsnetwork@gmail.com"
    };
    checker = function (model) {
      return new Ember['default'].RSVP.Promise(function (resolve) {
        return Ember['default'].run.later(this, resolve, 15);
      });
    };
    return custom['default']("email", checker, model).then(function (checkedModel) {
      return assert.equal(model, checkedModel);
    })["catch"](function () {
      return assert.ok(false, "it should not have rejected good models");
    });
  });

});
define('dummy/tests/unit/validators/presence-test', ['ember', 'qunit', 'ember-functional-validation/validators/presence'], function (Ember, qunit, presence) {

  'use strict';

  qunit.module('Validators: Presence');

  qunit.test('it should exist', function (assert) {
    assert.ok(presence['default']);
    return assert.equal(typeof presence['default'], 'function');
  });

  qunit.test('it should resolve to a good promise on a good object', function (assert) {
    var model;
    model = {
      email: "foxnewsnetwork@gmail.com",
      username: "foxnewsnetwork"
    };
    return presence['default']("email", true, model).then(function (checkedModel) {
      return assert.equal(checkedModel, model);
    })["catch"](function () {
      return assert.ok(false, "it should not get here");
    });
  });

  qunit.test('it should properly reject a bad object', function (assert) {
    var model;
    model = null;
    return presence['default']("email", true, model).then(function () {
      return assert.ok(false, "it should not resolve a bad object");
    })["catch"](function (error) {
      assert.equal(error.size, 1);
      return assert.equal(error.get("email"), "cannot be blank");
    });
  });

  qunit.test('it should properly error when missing an attribute', function (assert) {
    return assert.throws(presence['default'], /must specify an attribute/);
  });

  qunit.test('it should be able to display a custom message', function (assert) {
    return presence['default']("email", {
      message: ">tfw no gf"
    }, null).then(function () {
      return assert.ok(false, "it should not resolve a bad object");
    })["catch"](function (error) {
      assert.equal(error.size, 1);
      return assert.equal(error.get("email"), ">tfw no gf");
    });
  });

});
/* jshint ignore:start */

/* jshint ignore:end */

/* jshint ignore:start */

define('dummy/config/environment', ['ember'], function(Ember) {
  var prefix = 'dummy';
/* jshint ignore:start */

try {
  var metaName = prefix + '/config/environment';
  var rawConfig = Ember['default'].$('meta[name="' + metaName + '"]').attr('content');
  var config = JSON.parse(unescape(rawConfig));

  return { 'default': config };
}
catch(err) {
  throw new Error('Could not read config from meta tag with name "' + metaName + '".');
}

/* jshint ignore:end */

});

if (runningTests) {
  require("dummy/tests/test-helper");
} else {
  require("dummy/app")["default"].create({"name":"ember-functional-validation","version":"v0.1.0"});
}

/* jshint ignore:end */
//# sourceMappingURL=dummy.map