/* jshint ignore:start */

/* jshint ignore:end */

define('dummy/adapters/truck', ['exports', 'ember', 'ember-data'], function (exports, Ember, DS) {

  'use strict';

  var Core, Fixture, Fixtures, TruckAdapter;

  Core = {
    id: 2,
    bravoId: 'bravo-666',
    charlieId: 'charlie-420'
  };

  Fixture = {
    truck: Core
  };

  Fixtures = {
    trucks: [Core]
  };

  TruckAdapter = DS['default'].RESTAdapter.extend({
    find: function find() {
      return new Ember['default'].RSVP.Promise(function (resolve) {
        return resolve(Fixture);
      });
    },
    findAll: function findAll() {
      return new Ember['default'].RSVP.Promise(function (resolve) {
        return resolve(Fixtures);
      });
    }
  });

  exports['default'] = TruckAdapter;

});
define('dummy/adapters/trucks/bravo', ['exports', 'ember', 'ember-data'], function (exports, Ember, DS) {

  'use strict';

  var Core, Fixture, Fixtures, TrucksBravoAdapter;

  Core = {
    id: 'bravo-666',
    location: 'applebees'
  };

  Fixture = {
    truck: Core
  };

  Fixtures = {
    trucks: [Core]
  };

  TrucksBravoAdapter = DS['default'].RESTAdapter.extend({
    find: function find() {
      return new Ember['default'].RSVP.Promise(function (resolve) {
        return resolve(Fixture);
      });
    },
    findAll: function findAll() {
      return new Ember['default'].RSVP.Promise(function (resolve) {
        return resolve(Fixtures);
      });
    }
  });

  exports['default'] = TrucksBravoAdapter;

});
define('dummy/adapters/trucks/charlie', ['exports', 'ember', 'ember-data'], function (exports, Ember, DS) {

  'use strict';

  var Core,
      Fixture,
      Fixtures,
      TrucksCharlieAdapter,
      slice = [].slice;

  Core = {
    id: 'charlie-420',
    licensePlate: 'hype-4231',
    createdAt: new Date('Feb 23, 2044')
  };

  Fixture = {
    truck: Core
  };

  Fixtures = {
    trucks: [Core]
  };

  TrucksCharlieAdapter = DS['default'].RESTAdapter.extend({
    pathForType: function pathForType(type) {
      var _, i, ref, types;
      ref = type.split('/'), types = 2 <= ref.length ? slice.call(ref, 0, i = ref.length - 1) : (i = 0, []), _ = ref[i++];
      return this._super(types.join('/'));
    },
    find: function find() {
      return new Ember['default'].RSVP.Promise(function (resolve) {
        return resolve(Fixture);
      });
    },
    findAll: function findAll() {
      return new Ember['default'].RSVP.Promise(function (resolve) {
        return resolve(Fixtures);
      });
    }
  });

  exports['default'] = TrucksCharlieAdapter;

});
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/ember-data-complex/tests/modules/ember-data-complex/extensions/find', ['exports'], function (exports) {

  'use strict';

  var find;

  find = function (type, id, preload) {
    var output, strategy;
    output = this._super.apply(this, arguments);
    if (strategy = this.strategyFor(type)) {
      return strategy.onFind(output);
    }
    return output;
  };

  exports['default'] = find;

});
define('dummy/ember-data-complex/tests/modules/ember-data-complex/extensions/strategy-for', ['exports'], function (exports) {

  'use strict';

  var strategyFor;

  strategyFor = function (key) {
    var strategy;
    if (typeof key === "string") {
      strategy = this.container.lookupFactory("strategie:" + key);
    } else {
      strategy = key;
    }
    if (strategy != null) {
      if (strategy.store == null) {
        strategy.store = this;
      }
      if (strategy.container == null) {
        strategy.container = this.container;
      }
    }
    return strategy;
  };

  exports['default'] = strategyFor;

});
define('dummy/ember-data-complex/tests/modules/ember-data-complex/index', ['exports', 'dummy/ember-data-complex/tests/modules/ember-data-complex/models/strategy', 'dummy/ember-data-complex/tests/modules/ember-data-complex/utils/macros', 'dummy/ember-data-complex/tests/modules/ember-data-complex/utils/get-attributes', 'dummy/ember-data-complex/tests/modules/ember-data-complex/utils/arrows', 'dummy/ember-data-complex/tests/modules/ember-data-complex/models/base', 'dummy/ember-data-complex/tests/modules/ember-data-complex/utils/async'], function (exports, Strategy, Macros, getAttributes, Arrows, Base, async) {

  'use strict';

  var DSC;

  DSC = (function () {
    function DSC() {}

    DSC.ModelComplex = Base['default'];

    DSC.Strategy = Strategy['default'];

    DSC.Macros = Macros['default'];

    DSC.Arrows = Arrows['default'];

    DSC.truthy = Arrows['default'].truthy;

    DSC.getAttributes = getAttributes['default'];

    DSC.async = async['default'];

    DSC.ifA = Arrows['default'].ifA;

    return DSC;
  })();

  exports['default'] = DSC;

});
define('dummy/ember-data-complex/tests/modules/ember-data-complex/initializers/data-complex', ['exports', 'ember', 'ember-data', 'dummy/ember-data-complex/tests/modules/ember-data-complex/extensions/find', 'dummy/ember-data-complex/tests/modules/ember-data-complex/extensions/strategy-for'], function (exports, Ember, DS, find, strategyFor) {

  'use strict';

  var DataComplexInitializer, initialize;

  initialize = function (ctn, app) {
    if (DS['default'].Store.prototype._emberDataComplexPatched !== true) {
      return DS['default'].Store.reopen({
        _emberDataComplexPatched: true,
        find: find['default'],
        strategyFor: strategyFor['default']
      });
    }
  };

  DataComplexInitializer = {
    name: 'data-complex',
    before: 'store',
    initialize: initialize
  };

  exports['default'] = DataComplexInitializer;

  exports.initialize = initialize;

});
define('dummy/ember-data-complex/tests/modules/ember-data-complex/models/base', ['exports', 'ember-data'], function (exports, DS) {

	'use strict';

	var Base;

	Base = DS['default'].Model.extend();

	exports['default'] = Base;

});
define('dummy/ember-data-complex/tests/modules/ember-data-complex/models/strategy', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Strategy;

  Strategy = Ember['default'].Object.extend({
    evalProc: function evalProc() {
      return function () {};
    },
    onFind: function onFind(model) {
      return lift(model).dobind(this.evalProc()).run();
    }
  });

  exports['default'] = Strategy;

});
define('dummy/ember-data-complex/tests/modules/ember-data-complex/utils/arrows', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Arrows, Either, arrowLike, compose, composeReject, composeResolve, debugLog, dobind, dobindReject, dobindResolve, fork, id, ifA, isfun, lift, liftA, polarize, promiseLift, promiseLike, truthy;

  promiseLift = function (x) {
    if (promiseLike(x)) {
      return x;
    }
    return new Ember['default'].RSVP.Promise(function (resolve) {
      return resolve(x);
    });
  };

  promiseLike = function (x) {
    return x != null && isfun(x.then);
  };

  lift = liftA = function (x) {
    if (arrowLike(x)) {
      return x;
    }
    return new Arrows(x);
  };

  arrowLike = function (x) {
    return x != null && isfun(x.compose) && isfun(x.dobind) && isfun(x.fork);
  };

  isfun = function (f) {
    return f != null && typeof f === 'function';
  };

  compose = function (f, g) {
    return new Arrows(function (x) {
      return lift(f).run(x).then(function (x) {
        return lift(g).run(x);
      });
    });
  };

  composeResolve = function (f, g) {
    return compose(f, lift(g).fork(id));
  };

  composeReject = function (f, g) {
    return compose(f, id.fork(g));
  };

  dobind = function (f, g) {
    return new Arrows(function (x) {
      return lift(f).run(x).then(function (x1) {
        return lift(g).run(x1).then(function (_) {
          return promiseLift(x1);
        });
      });
    });
  };

  dobindResolve = function (f, g) {
    return dobind(f, lift(g).fork(id));
  };

  dobindReject = function (f, g) {
    return dobind(f, id.fork(g));
  };

  fork = function (f, g) {
    return new Arrows(function (either) {
      if (either.isGood) {
        return lift(f).run(either.payload);
      } else {
        return lift(g).run(either.payload);
      }
    });
  };

  truthy = function (x) {
    if (Ember['default'].isBlank(x)) {
      return false;
    }
    if (x === false) {
      return false;
    }
    if (x instanceof Error) {
      return false;
    }
    return true;
  };

  ifA = function (f) {
    return lift(f).compose(polarize(f));
  };

  polarize = function (f) {
    return new Arrows(function (x) {
      return lift(f).run(x).then(function (successful) {
        if (truthy(successful)) {
          return Either.resolve(x);
        } else {
          return Either.reject(x);
        }
      })['catch'](function () {
        return Either.reject(x);
      });
    });
  };

  debugLog = function (x) {
    console.log(x);
    return x;
  };

  Either = (function () {
    Either.resolve = function (x) {
      if (x != null && x.payload != null && x.isGood != null) {
        return x;
      }
      return new Either(true, x);
    };

    Either.reject = function (x) {
      if (x != null && x.payload != null && x.isGood != null) {
        return x;
      }
      return new Either(false, x);
    };

    function Either(isGood, payload) {
      this.isGood = isGood;
      this.payload = payload;
    }

    Either.prototype.isResolved = function () {
      return this.isGood;
    };

    Either.prototype.isRejected = function () {
      return !this.isGood;
    };

    return Either;
  })();

  Arrows = (function () {
    Arrows.resolve = Either.resolve;

    Arrows.reject = Either.reject;

    Arrows.isfun = isfun;

    Arrows.arrowLike = arrowLike;

    Arrows.promiseLike = promiseLike;

    Arrows.ifA = ifA;

    Arrows.lift = lift;

    Arrows.liftA = lift;

    Arrows.promiseLift = promiseLift;

    Arrows.polarize = polarize;

    Arrows.truthy = truthy;

    function Arrows(x) {
      if (isfun(x)) {
        this.core = x;
      } else {
        this.core = function () {
          return x;
        };
      }
    }

    Arrows.prototype.run = function () {
      return promiseLift(this.core.apply(this, arguments));
    };

    Arrows.prototype.end = function () {
      return this.run.apply(this, arguments);
    };

    Arrows.prototype.compose = function (f) {
      return compose(this, f);
    };

    Arrows.prototype.composeResolve = function (f) {
      return composeResolve(this, f);
    };

    Arrows.prototype.composeReject = function (f) {
      return composeReject(this, f);
    };

    Arrows.prototype.fork = function (f) {
      return fork(this, f);
    };

    Arrows.prototype.thenA = function (f) {
      return dobindResolve(this, f);
    };

    Arrows.prototype.elseA = function (f) {
      return dobindReject(this, f);
    };

    Arrows.prototype.dobind = function (f) {
      return dobind(this, f);
    };

    Arrows.prototype.await = function (f) {
      return dobind(this, f);
    };

    Arrows.prototype.dobindResolve = function (f) {
      return dobindResolve(this, f);
    };

    Arrows.prototype.dobindReject = function (f) {
      return dobindReject(this, f);
    };

    return Arrows;
  })();

  id = lift(function (x) {
    return x;
  });

  Arrows.id = id;

  exports['default'] = Arrows;

  exports.lift = lift;
  exports.liftA = liftA;
  exports.polarize = polarize;
  exports.ifA = ifA;
  exports.id = id;
  exports.Either = Either;
  exports.debugLog = debugLog;
  exports.arrowLike = arrowLike;
  exports.promiseLike = promiseLike;
  exports.promiseLift = promiseLift;
  exports.isfun = isfun;
  exports.truthy = truthy;

});
define('dummy/ember-data-complex/tests/modules/ember-data-complex/utils/async', ['exports', 'ember', 'dummy/ember-data-complex/tests/modules/ember-data-complex/utils/arrows'], function (exports, Ember, arrows) {

  'use strict';

  var assertIterator, async, asyncCore, errormsg, makeError;

  errormsg = 'async expects a generator function, but you passed in something that wasn\'t a generator.\nThis could be because you\'re using CoffeeScript and you forgot to include a yield.\nOr it could be you just neglected to include a * in your vanilla pleb-tier javascript.\nOr you just passed an object or something weird like that.';

  assertIterator = function (maybeGen) {
    if (!(maybeGen != null && arrows.isfun(maybeGen.next) && arrows.isfun(maybeGen['return']))) {
      window.maybeGen = maybeGen;
      throw new Error(errormsg);
    }
  };

  makeError = function (reason) {
    var e;
    e = new Error('Your promise has been rejected because ' + JSON.stringify(reason));
    e.reason = reason;
    return e;
  };

  asyncCore = function (iterator, fulfillment) {
    var done, promise, ref;
    assertIterator(iterator);
    ref = iterator.next(fulfillment), promise = ref.value, done = ref.done;
    if (done === true) {
      return arrows.promiseLift(promise);
    }
    return arrows.promiseLift(promise).then(function (value) {
      return asyncCore(iterator, value);
    })['catch'](function (reason) {
      return asyncCore(iterator, makeError(reason));
    });
  };

  async = function (generator) {
    return asyncCore(generator());
  };

  exports['default'] = async;

});
define('dummy/ember-data-complex/tests/modules/ember-data-complex/utils/get-attributes', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var getAttributes;

  getAttributes = function (model) {
    var output;
    output = {};
    model.eachAttribute(function (name, meta) {
      if (name === "id") {
        return;
      }
      return output[name] = Ember['default'].get(model, name);
    });
    return output;
  };

  exports['default'] = getAttributes;

});
define('dummy/ember-data-complex/tests/modules/ember-data-complex/utils/macros', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Macros, noStoreMsg;

  noStoreMsg = "You tried to declare a model-through computed macro on an object that didn't have a 'store' property.\nThe intended usage of the DSC.Macros.through macro is to provide a non-relational alternative to DS.belongsTo.\nAs such, I expect to use it in a DS.Model-like class as in the following example:\n\n  Dog = DS.Model.extend\n    ownerId: DS.attr 'string'\n    owner: DSC.Macros.through 'user', 'ownerId'";

  Macros = (function () {
    function Macros() {}

    Macros.through = function (modelName, idField) {
      var f;
      f = function (_, model) {
        var id;
        if (arguments.length > 1) {
          this.set(idField, Ember['default'].get(model, "id"));
        }
        id = this.get(idField);
        if (Ember['default'].isBlank(id)) {
          return;
        }
        Ember['default'].assert(noStoreMsg, this.store != null);
        return this.store.find(modelName, id);
      };
      return Ember['default'].computed(idField, f);
    };

    return Macros;
  })();

  exports['default'] = Macros;

});
define('dummy/ember-data-complex/tests/modules/ember-data-complex/utils/representative', ['exports'], function (exports) {

  'use strict';

  var Representative;

  Representative = (function () {
    function Representative() {}

    Representative.find = function (typeKey) {};

    return Representative;
  })();

  exports['default'] = Representative;

});
define('dummy/horses/public-defender', ['exports'], function (exports) {

  'use strict';

  var PublicDefender;

  PublicDefender = Ember.Object.extend({
    animalType: "horse",
    use: "testing resolver"
  });

  exports['default'] = PublicDefender;

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

  'use strict';

  var classify = Ember['default'].String.classify;
  var registered = false;

  exports['default'] = {
    name: 'App Version',
    initialize: function initialize(container, application) {
      if (!registered) {
        var appName = classify(application.toString());
        Ember['default'].libraries.register(appName, config['default'].APP.version);
        registered = true;
      }
    }
  };

});
define('dummy/initializers/data-complex', ['exports', 'ember-data-complex/initializers/data-complex'], function (exports, DataComplexInitializer) {

	'use strict';

	exports['default'] = DataComplexInitializer['default'];

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

  'use strict';

  exports.initialize = initialize;

  function initialize(container, application) {
    var classifiedName = Ember['default'].String.classify(config['default'].modulePrefix);

    if (config['default'].exportApplicationGlobal && !window[classifiedName]) {
      window[classifiedName] = application;
    }
  }

  ;

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

    initialize: initialize
  };

});
define('dummy/models/truck', ['exports', 'ember', 'ember-data', 'ember-data-complex'], function (exports, Ember, DS, DSC) {

  'use strict';

  var Truck;

  Truck = DS['default'].Model.extend({
    bravoId: DS['default'].attr('string'),
    charlieId: DS['default'].attr('string'),
    bravo: DSC['default'].Macros.through('trucks/bravo', 'bravoId'),
    charlie: DSC['default'].Macros.through('trucks/charlie', 'charlieId')
  });

  exports['default'] = Truck;

});
define('dummy/models/trucks/bravo', ['exports', 'ember-data'], function (exports, DS) {

  'use strict';

  var TrucksBravo;

  TrucksBravo = DS['default'].Model.extend({
    location: DS['default'].attr("string")
  });

  exports['default'] = TrucksBravo;

});
define('dummy/models/trucks/charlie', ['exports', 'ember-data'], function (exports, DS) {

  'use strict';

  var TrucksCharlie;

  TrucksCharlie = DS['default'].Model.extend({
    licensePlate: DS['default'].attr("string"),
    createdAt: DS['default'].attr("date")
  });

  exports['default'] = TrucksCharlie;

});
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/serializers/trucks/bravo', ['exports', 'ember-data'], function (exports, DS) {

  'use strict';

  var BravoSerializer;

  BravoSerializer = DS['default'].ActiveModelSerializer.extend({
    normalizePayload: function normalizePayload(payload) {
      var key, value;
      for (key in payload) {
        value = payload[key];
        payload["trucks/bravo"] = value;
        delete payload[key];
      }
      return payload;
    }
  });

  exports['default'] = BravoSerializer;

});
define('dummy/serializers/trucks/charlie', ['exports', 'ember-data'], function (exports, DS) {

  'use strict';

  var CharlieSerializer;

  CharlieSerializer = DS['default'].ActiveModelSerializer.extend({
    normalizePayload: function normalizePayload(payload) {
      var key, value;
      for (key in payload) {
        value = payload[key];
        payload["trucks/charlie"] = value;
        delete payload[key];
      }
      return payload;
    }
  });

  exports['default'] = CharlieSerializer;

});
define('dummy/strategies/truck', ['exports', 'ember-data-complex', 'ember-data-complex/utils/arrows'], function (exports, DSC, arrows) {

  'use strict';

  var TruckStrategy;

  TruckStrategy = DSC['default'].Strategy.create({
    attemptBravoTruck: function attemptBravoTruck() {
      return (function (_this) {
        return function (masterTruck) {
          return _this.store.find('trucks/bravo', masterTruck.get('bravoId'));
        };
      })(this);
    },
    attemptCharlieTruck: function attemptCharlieTruck() {
      return (function (_this) {
        return function (masterTruck) {
          return _this.store.find('trucks/charlie', masterTruck.get('charlieId'));
        };
      })(this);
    },
    createBravoFromCharlie: function createBravoFromCharlie() {
      return (function (_this) {
        return function (charlie) {
          return _this.store.createRecord('trucks/bravo', DSC['default'].getAttributes(charlie)).save();
        };
      })(this);
    },
    fallbackToCharlieTruck: function fallbackToCharlieTruck() {
      return arrows.polarize(this.attemptCharlieTruck()).composeResolve(this.createBravoFromCharlie());
    },
    evalProc: function evalProc() {
      return arrows.polarize(this.attemptBravoTruck()).dobindReject(this.fallbackToCharlieTruck());
    },
    onFind: function onFind(truck) {
      return arrows.lift(truck).dobind(this.evalProc()).run();
    }
  });

  exports['default'] = TruckStrategy;

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

  'use strict';

  exports['default'] = Ember.HTMLBars.template((function() {
    return {
      isHTMLBars: true,
      revision: "Ember@1.11.1",
      blockParams: 0,
      cachedFragment: null,
      hasRendered: false,
      build: function build(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;
      },
      render: function render(context, env, contextualElement) {
        var dom = env.dom;
        var hooks = env.hooks, content = hooks.content;
        dom.detectNamespace(contextualElement);
        var fragment;
        if (env.useFragmentCache && dom.canClone) {
          if (this.cachedFragment === null) {
            fragment = this.build(dom);
            if (this.hasRendered) {
              this.cachedFragment = fragment;
            } else {
              this.hasRendered = true;
            }
          }
          if (this.cachedFragment) {
            fragment = dom.cloneNode(this.cachedFragment, true);
          }
        } else {
          fragment = this.build(dom);
        }
        var morph0 = dom.createMorphAt(fragment,2,2,contextualElement);
        content(env, morph0, context, "outlet");
        return fragment;
      }
    };
  }()));

});
define('dummy/tests/acceptance/model-complex-test', ['ember', 'qunit', 'dummy/tests/helpers/start-app', 'ember-data-complex/initializers/data-complex'], function (Ember, qunit, startApp, data_complex) {

  'use strict';

  var application, container;

  application = null;

  container = null;

  qunit.module('Acceptance: ModelComplex', {
    beforeEach: function beforeEach() {
      Ember['default'].run(function () {
        application = startApp['default']();
        return container = application.__container__;
      });

      /*
      Don't return as Ember.Application.then is deprecated.
      Newer version of QUnit uses the return value's .then
      function to wait for promises if it exists.
       */
    },
    afterEach: function afterEach() {
      return Ember['default'].run(application, 'destroy');
    }
  });

  qunit.test('it should be able to find a truck', function (assert) {
    return Ember['default'].run(function () {
      var store, truckPromise;
      assert.ok(container, 'the container should be present');
      assert.ok(container.lookup, 'the container should be properly initialized');
      store = container.lookup('store:main');
      assert.ok(store, 'the store should be there');
      assert.ok(store.find, 'the store should support finding');
      truckPromise = store.find('truck', 2);
      assert.ok(truckPromise, 'the store should find a truck');
      assert.ok(truckPromise.then, 'the found truck should properly be a promise');
      return truckPromise.then(function (truck) {
        assert.ok(truck, 'the promise should resolve to a truck');
        assert.equal(truck.get('id'), 2, 'the truck should have a proper master id');
        assert.equal(truck.get('bravoId'), 'bravo-666', 'the truck should have a bravo id');
        assert.equal(truck.get('charlieId'), 'charlie-420', 'the truck should have a charlie id');
        assert.ok(truck.get('bravo'), 'the truck should be able to get bravo');
        assert.ok(truck.get('charlie'), 'the truck should be able to get charlie');
        truck.get('bravo').then(function () {
          return assert.equal(truck.get('bravo.location'), 'applebees', 'bravo should store location');
        });
        return truck.get('charlie').then(function () {
          return assert.equal(truck.get('charlie.licensePlate'), 'hype-4231', 'charlie should store license plate');
        });
      });
    });
  });

  qunit.test('it should support a strategyFor feature which follows a model strategy', function (assert) {
    return Ember['default'].run(function () {
      var store, strategy;
      store = container.lookup('store:main');
      assert.ok(store.strategyFor, 'should have a strategyFor method');
      assert.equal(typeof store.strategyFor, 'function', 'strategyFor should be a proper function');
      strategy = store.strategyFor('truck');
      assert.ok(strategy, 'a strategy should be found for truck');
      assert.ok(strategy.onFind, 'a strategy should have a onFind property');
      return assert.equal(typeof strategy.onFind, 'function', 'onFind should be a proper function');
    });
  });

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

  'use strict';

  module('JSHint - .');
  test('app.js should pass jshint', function() { 
    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';

  module('JSHint - helpers');
  test('helpers/resolver.js should pass jshint', function() { 
    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';

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

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

  'use strict';

  module('JSHint - .');
  test('router.js should pass jshint', function() { 
    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';

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

});
define('dummy/tests/unit/initializers/data-complex-test', ['ember', 'ember-data-complex/initializers/data-complex', 'qunit'], function (Ember, data_complex, qunit) {

  'use strict';

  var application, container;

  container = null;

  application = null;

  qunit.module('DataComplexInitializer', {
    beforeEach: function beforeEach() {
      return Ember['default'].run(function () {
        application = Ember['default'].Application.create();
        container = application.__container__;
        return application.deferReadiness();
      });
    }
  });

  qunit.test('it works', function (assert) {
    data_complex.initialize(container, application);
    return assert.ok(true);
  });

});
define('dummy/tests/unit/utils/arrows-test', ['ember-data-complex/utils/arrows', 'ember', 'qunit'], function (Arrows, Ember, qunit) {

  'use strict';

  var delay;

  qunit.module('Arrows');

  delay = function (t, f) {
    return new Ember['default'].RSVP.Promise(function (resolve) {
      return Ember['default'].run.later(null, function () {
        return resolve(f());
      }, t);
    });
  };

  qunit.test('it exists', function (assert) {
    var result;
    result = Arrows['default'];
    return assert.ok(result);
  });

  qunit.test('vanilla lift', function (assert) {
    var five;
    five = Arrows['default'].lift(5);
    assert.ok(five);
    assert.ok(five.run);
    assert.ok(Arrows['default'].arrowLike(five));
    assert.equal(typeof five.run, 'function');
    return five.run().then(function (result) {
      return assert.equal(result, 5);
    });
  });

  qunit.test('function lift', function (assert) {
    var five;
    five = Arrows['default'].lift(function () {
      return 5;
    });
    assert.ok(Arrows['default'].arrowLike(five));
    return five.run().then(function (result) {
      return assert.equal(result, 5);
    });
  });

  qunit.test('function promise lift', function (assert) {
    var five;
    five = Arrows['default'].lift(function () {
      return new Ember['default'].RSVP.Promise(function (resolve) {
        return resolve(5);
      });
    });
    assert.ok(Arrows['default'].arrowLike(five));
    return five.run().then(function (result) {
      return assert.equal(result, 5);
    });
  });

  qunit.test('promise lift', function (assert) {
    var five;
    five = Arrows['default'].lift(new Ember['default'].RSVP.Promise(function (resolve) {
      return resolve(5);
    }));
    assert.ok(Arrows['default'].arrowLike(five));
    return five.run().then(function (result) {
      return assert.equal(result, 5);
    });
  });

  qunit.test('arity 2 lift', function (assert) {
    var plus3;
    plus3 = Arrows['default'].lift(function (x) {
      return x + 3;
    });
    assert.ok(Arrows['default'].arrowLike(plus3));
    return plus3.run(3).then(function (actual) {
      return assert.equal(actual, 6);
    });
  });

  qunit.test('compose', function (assert) {
    var five, fiveplus3, plus3;
    five = Arrows['default'].lift(5);
    plus3 = Arrows['default'].lift(function (x) {
      return x + 3;
    });
    fiveplus3 = five.compose(plus3);
    return fiveplus3.run().then(function (actual) {
      return assert.equal(actual, 8);
    });
  });

  qunit.test('lengthy composition', function (assert) {
    var minus2, plus3, times4, transform;
    plus3 = Arrows['default'].lift(function (x) {
      return x + 3;
    });
    minus2 = Arrows['default'].lift(function (x) {
      return x - 2;
    });
    times4 = Arrows['default'].lift(function (x) {
      return x * 4;
    });
    transform = plus3.compose(minus2).compose(times4);
    return transform.run(10).then(function (actual) {
      return assert.equal(actual, 44);
    });
  });

  qunit.test('dobind', function (assert) {
    var five, plusInfinity, times2, transform;
    five = Arrows['default'].lift(5);
    times2 = Arrows['default'].lift(function (x) {
      return x * 2;
    });
    plusInfinity = Arrows['default'].lift(function (x) {
      return x + Infinity;
    });
    transform = five.dobind(times2).dobind(plusInfinity);
    return transform.run().then(function (actual) {
      return assert.equal(actual, 5);
    });
  });

  qunit.test('promise composition', function (assert) {
    var minus2, plus3, times4, transform;
    plus3 = Arrows['default'].lift(function (x) {
      return delay(15, function () {
        return x + 3;
      });
    });
    minus2 = Arrows['default'].lift(function (x) {
      return delay(25, function () {
        return x - 2;
      });
    });
    times4 = Arrows['default'].lift(function (x) {
      return delay(15, function () {
        return x * 4;
      });
    });
    transform = plus3.compose(minus2).compose(times4);
    return transform.run(10).then(function (actual) {
      return assert.equal(actual, 44);
    });
  });

  qunit.test('promise composition sequence', function (assert) {
    var saydaddy, sayno, saypls, transform;
    saydaddy = Arrows['default'].lift(function (x) {
      return delay(15, function () {
        return x + ' daddy';
      });
    });
    sayno = Arrows['default'].lift(function (x) {
      return delay(45, function () {
        return x + ' no';
      });
    });
    saypls = Arrows['default'].lift(function (x) {
      return delay(15, function () {
        return x + ' please';
      });
    });
    transform = saydaddy.compose(sayno).compose(saypls);
    return transform.run('it\'s grape time!').then(function (actual) {
      return assert.equal(actual, 'it\'s grape time! daddy no please');
    });
  });

  qunit.test('fork', function (assert) {
    var decider, plus4, times2, transform;
    decider = Arrows['default'].lift(function (x) {
      if (x < 5) {
        return Arrows['default'].resolve(x);
      } else {
        return Arrows['default'].reject(x);
      }
    });
    times2 = Arrows['default'].lift(function (x) {
      return x * 2;
    });
    plus4 = Arrows['default'].lift(function (x) {
      return x + 4;
    });
    transform = decider.compose(times2.fork(plus4));
    transform.run(1).then(function (actual) {
      return assert.equal(actual, 2);
    });
    transform.run(2).then(function (actual) {
      return assert.equal(actual, 4);
    });
    transform.run(3).then(function (actual) {
      return assert.equal(actual, 6);
    });
    transform.run(4).then(function (actual) {
      return assert.equal(actual, 8);
    });
    transform.run(5).then(function (actual) {
      return assert.equal(actual, 9);
    });
    transform.run(6).then(function (actual) {
      return assert.equal(actual, 10);
    });
    return transform.run(7).then(function (actual) {
      return assert.equal(actual, 11);
    });
  });

  qunit.test('delayed fork', function (assert) {
    var decider, plus4, times2, transform;
    decider = Arrows['default'].lift(function (x) {
      return delay(44, function () {
        if (x < 5) {
          return Arrows['default'].resolve(x);
        } else {
          return Arrows['default'].reject(x);
        }
      });
    });
    times2 = Arrows['default'].lift(function (x) {
      return x * 2;
    });
    plus4 = Arrows['default'].lift(function (x) {
      return delay(10, function () {
        return x + 4;
      });
    });
    transform = decider.compose(times2.fork(plus4));
    transform.run(1).then(function (actual) {
      return assert.equal(actual, 2);
    });
    transform.run(2).then(function (actual) {
      return assert.equal(actual, 4);
    });
    transform.run(3).then(function (actual) {
      return assert.equal(actual, 6);
    });
    transform.run(4).then(function (actual) {
      return assert.equal(actual, 8);
    });
    transform.run(5).then(function (actual) {
      return assert.equal(actual, 9);
    });
    transform.run(6).then(function (actual) {
      return assert.equal(actual, 10);
    });
    return transform.run(7).then(function (actual) {
      return assert.equal(actual, 11);
    });
  });

  qunit.test('polarize', function (assert) {
    var boring, decider, funny, transform;
    decider = Arrows['default'].polarize(function (x) {
      return x === 'Jimmy Fallon';
    });
    boring = Arrows['default'].lift(function (x) {
      return delay(10, function () {
        return x + ': only popular because women like him';
      });
    });
    funny = Arrows['default'].lift(function (x) {
      return x + ': is actually funny';
    });
    transform = decider.compose(boring.fork(funny));
    transform.run('Conan O\'brien').then(function (actual) {
      return assert.equal(actual, 'Conan O\'brien: is actually funny');
    });
    return transform.run('Jimmy Fallon').then(function (actual) {
      return assert.equal(actual, 'Jimmy Fallon: only popular because women like him');
    });
  });

  qunit.test('delayed polarize', function (assert) {
    var boring, decider, funny, transform;
    decider = Arrows['default'].polarize(function (x) {
      return delay(76, function () {
        return x === 'Jimmy Fallon';
      });
    });
    boring = Arrows['default'].lift(function (x) {
      return delay(10, function () {
        return x + ': only popular because women like him';
      });
    });
    funny = Arrows['default'].lift(function (x) {
      return x + ': is actually funny';
    });
    transform = decider.compose(boring.fork(funny));
    transform.run('Conan O\'brien').then(function (actual) {
      return assert.equal(actual, 'Conan O\'brien: is actually funny');
    });
    return transform.run('Jimmy Fallon').then(function (actual) {
      return assert.equal(actual, 'Jimmy Fallon: only popular because women like him');
    });
  });

  qunit.test('id arrow', function (assert) {
    return Arrows['default'].id.run('dogs').then(function (dogs) {
      return assert.equal(dogs, 'dogs');
    });
  });

  qunit.test('dobind fork', function (assert) {
    var decider, failure, success, transform;
    decider = Arrows['default'].polarize(function (x) {
      return x === 'success';
    });
    success = Arrows['default'].lift(function (x) {
      return assert.equal(x, 'success');
    });
    failure = Arrows['default'].lift(function (x) {
      return assert.equal(x, 'failure');
    });
    transform = decider.dobind(success.fork(failure));
    Arrows['default'].lift('success').dobind(transform).run().then(function (actual) {
      return assert.equal(actual, 'success');
    });
    return Arrows['default'].lift('failure').dobind(transform).run().then(function (actual) {
      return assert.equal(actual, 'failure');
    });
  });

  qunit.test('dobindReject', function (assert) {
    var decider, fallon, funny, kimmel, transform;
    kimmel = Arrows['default'].lift('Jimmy Kimmel');
    fallon = Arrows['default'].lift('Jimmy Fallon');
    decider = Arrows['default'].polarize(function (x) {
      return delay(76, function () {
        return x === 'Jimmy Fallon';
      });
    });
    funny = Arrows['default'].lift(function (x) {
      return assert.equal(x, 'Jimmy Kimmel');
    });
    transform = decider.dobindReject(funny);
    kimmel.dobind(transform).run().then(function (actual) {
      return assert.equal(actual, 'Jimmy Kimmel');
    });
    return fallon.dobind(transform).run().then(function (actual) {
      return assert.equal(actual, 'Jimmy Fallon');
    });
  });

  qunit.test('dobindResolve', function (assert) {
    var agchemy, alchemy, decider, dostuff, gold, silver, transmute;
    gold = Arrows['default'].lift('au');
    silver = Arrows['default'].lift('ag');
    decider = Arrows['default'].polarize(function (el) {
      return el === 'au';
    });
    dostuff = Arrows['default'].lift(function (x) {
      return assert.equal(x, 'au');
    });
    transmute = Arrows['default'].lift(function (x) {
      return x + 'cl2';
    });
    alchemy = gold.dobind(decider).dobindResolve(dostuff).dobind(transmute).dobind(dostuff);
    agchemy = silver.dobind(decider).dobindResolve(dostuff.dobind(transmute).dobind(dostuff));
    alchemy.run().then(function (actual) {
      return assert.equal(actual, 'au');
    });
    return agchemy.run().then(function (actual) {
      return assert.equal(actual, 'ag');
    });
  });

});
define('dummy/tests/unit/utils/async-test', ['ember-data-complex/utils/async', 'ember-data-complex/utils/arrows', 'ember', 'qunit'], function (async, arrows, Ember, qunit) {

  'use strict';

  var delay, find;

  qunit.module('async');

  delay = function (t, f) {
    return new Ember['default'].RSVP.Promise(function (resolve) {
      return Ember['default'].run.later(null, function () {
        return resolve(f());
      }, t);
    });
  };

  find = function (model, name) {
    return delay(15, function () {
      if (name === 'rover') {
        return Ember['default'].Object.create({
          name: name
        });
      } else {
        return new Error('Unable to find ' + name);
      }
    });
  };

  qunit.test('ifA', function (assert) {
    var decider;
    decider = function () {
      return true;
    };
    return arrows.ifA(decider).thenA(function () {
      return assert.ok(true, 'if should get here');
    }).end();
  });

  qunit.test('ifA promises', function (assert) {
    var decider;
    decider = function () {
      return delay(3, function () {
        return true;
      });
    };
    return arrows.ifA(decider).thenA(function () {
      return assert.ok(true, 'if should get here');
    }).end();
  });

  qunit.test('if-else equivalence', function (assert) {
    var lies, truth;
    assert.expect(2);
    truth = function () {
      return true;
    };
    lies = function () {
      return false;
    };
    arrows.ifA(truth).thenA(function () {
      return assert.ok(true, 'the truth should give one resolution');
    }).elseA(function () {
      return assert.ok(false, 'the truth should not lead one to rejection');
    }).end();
    return arrows.ifA(lies).thenA(function () {
      return assert.ok(false, 'lies should not lead one to resolution');
    }).elseA(function () {
      return assert.ok(true, 'lies should lead one to rejection');
    }).end();
  });

  qunit.test('if else on error', function (assert) {
    var failure, success;
    assert.expect(7);
    failure = function () {
      return delay(15, function () {
        return new Error('death to the enemies of the horde');
      });
    };
    success = function () {
      return delay(20, function () {
        return Ember['default'].Object.create({
          name: 'wc3'
        });
      });
    };
    arrows.ifA(success).thenA(function (thing) {
      assert.ok(thing, 'thenA should unlift the object out of the promise');
      assert.ok(thing instanceof Ember['default'].Object, 'the object should be an instance of Ember Object');
      assert.ok(thing.get, 'the thing should have a get function');
      return assert.equal(thing.get('name'), 'wc3', 'the thing should properly have a name');
    }).elseA(function () {
      return assert.ok(false, 'it should never get here');
    }).end();
    return arrows.ifA(failure).thenA(function () {
      return assert.ok(false, 'it should never get here');
    }).elseA(function (error) {
      assert.ok(error, 'elseA should properly unlift the error out of the promise');
      assert.ok(error.message, 'the error should be a proper error');
      return assert.equal(error.message, 'death to the enemies of the horde', 'the message should be the right one');
    }).end();
  });

  qunit.test('generator async yield', function (assert) {
    return async['default'](regeneratorRuntime.mark(function callee$1$0() {
      var rover;
      return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
        while (1) switch (context$2$0.prev = context$2$0.next) {
          case 0:
            context$2$0.next = 2;
            return find('dog', 'rover');

          case 2:
            rover = context$2$0.sent;

            assert.ok(rover.get);
            return context$2$0.abrupt('return', assert.equal(rover.get('name'), 'rover'));

          case 5:
          case 'end':
            return context$2$0.stop();
        }
      }, callee$1$0, this);
    }));
  });

  qunit.test('async yield usage', function (assert) {
    return async['default'](regeneratorRuntime.mark(function callee$1$0() {
      var bad, rover;
      return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
        while (1) switch (context$2$0.prev = context$2$0.next) {
          case 0:
            context$2$0.next = 2;
            return find('dog', 'rover');

          case 2:
            rover = context$2$0.sent;

            arrows.ifA(rover).thenA(function (doge) {
              return assert.equal(rover, doge, 'all bullshit aside, if and then should handle error cases');
            }).elseA(function () {
              return assert.ok(false, 'should not get here');
            }).end();
            context$2$0.next = 6;
            return find('dog', 'spot');

          case 6:
            bad = context$2$0.sent;
            return context$2$0.abrupt('return', arrows.ifA(bad).thenA(function (doge) {
              return assert.ok(false, 'should not get here');
            }).elseA(function (error) {
              return assert.equal(error.message, 'Unable to find spot');
            }).end());

          case 8:
          case 'end':
            return context$2$0.stop();
        }
      }, callee$1$0, this);
    }));
  });

});
/* 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-data-complex","version":"0.0.2-beta-2.e2535fb5"});
}

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