diff options
Diffstat (limited to 'imdb-lookup/js/libs/ember-data-1.0.0-beta.12.js')
| -rw-r--r-- | imdb-lookup/js/libs/ember-data-1.0.0-beta.12.js | 12945 |
1 files changed, 0 insertions, 12945 deletions
diff --git a/imdb-lookup/js/libs/ember-data-1.0.0-beta.12.js b/imdb-lookup/js/libs/ember-data-1.0.0-beta.12.js deleted file mode 100644 index a2851b9..0000000 --- a/imdb-lookup/js/libs/ember-data-1.0.0-beta.12.js +++ /dev/null @@ -1,12945 +0,0 @@ -(function(global){ -var enifed, requireModule, eriuqer, requirejs; - -(function() { - - var _isArray; - if (!Array.isArray) { - _isArray = function (x) { - return Object.prototype.toString.call(x) === "[object Array]"; - }; - } else { - _isArray = Array.isArray; - } - - var registry = {}, seen = {}, state = {}; - var FAILED = false; - - enifed = function(name, deps, callback) { - - if (!_isArray(deps)) { - callback = deps; - deps = []; - } - - registry[name] = { - deps: deps, - callback: callback - }; - }; - - function reify(deps, name, seen) { - var length = deps.length; - var reified = new Array(length); - var dep; - var exports; - - for (var i = 0, l = length; i < l; i++) { - dep = deps[i]; - if (dep === 'exports') { - exports = reified[i] = seen; - } else { - reified[i] = eriuqer(resolve(dep, name)); - } - } - - return { - deps: reified, - exports: exports - }; - } - - requirejs = eriuqer = requireModule = function(name) { - if (state[name] !== FAILED && - seen.hasOwnProperty(name)) { - return seen[name]; - } - - if (!registry[name]) { - throw new Error('Could not find module ' + name); - } - - var mod = registry[name]; - var reified; - var module; - var loaded = false; - - seen[name] = { }; // placeholder for run-time cycles - - try { - reified = reify(mod.deps, name, seen[name]); - module = mod.callback.apply(this, reified.deps); - loaded = true; - } finally { - if (!loaded) { - state[name] = FAILED; - } - } - - return reified.exports ? seen[name] : (seen[name] = module); - }; - - function resolve(child, name) { - if (child.charAt(0) !== '.') { return child; } - - var parts = child.split('/'); - var nameParts = name.split('/'); - var parentBase; - - if (nameParts.length === 1) { - parentBase = nameParts; - } else { - parentBase = nameParts.slice(0, -1); - } - - for (var i = 0, l = parts.length; i < l; i++) { - var part = parts[i]; - - if (part === '..') { parentBase.pop(); } - else if (part === '.') { continue; } - else { parentBase.push(part); } - } - - return parentBase.join('/'); - } - - requirejs.entries = requirejs._eak_seen = registry; - requirejs.clear = function(){ - requirejs.entries = requirejs._eak_seen = registry = {}; - seen = state = {}; - }; -})(); - -enifed("activemodel-adapter", - ["activemodel-adapter/system","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var ActiveModelAdapter = __dependency1__.ActiveModelAdapter; - var ActiveModelSerializer = __dependency1__.ActiveModelSerializer; - - __exports__.ActiveModelAdapter = ActiveModelAdapter; - __exports__.ActiveModelSerializer = ActiveModelSerializer; - }); -enifed("activemodel-adapter/setup-container", - ["ember-data/system/container_proxy","activemodel-adapter/system/active_model_serializer","activemodel-adapter/system/active_model_adapter","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __exports__) { - "use strict"; - var ContainerProxy = __dependency1__["default"]; - var ActiveModelSerializer = __dependency2__["default"]; - var ActiveModelAdapter = __dependency3__["default"]; - - __exports__["default"] = function setupActiveModelAdapter(container, application){ - var proxy = new ContainerProxy(container); - proxy.registerDeprecations([ - { deprecated: 'serializer:_ams', valid: 'serializer:-active-model' }, - { deprecated: 'adapter:_ams', valid: 'adapter:-active-model' } - ]); - - container.register('serializer:-active-model', ActiveModelSerializer); - container.register('adapter:-active-model', ActiveModelAdapter); - }; - }); -enifed("activemodel-adapter/system", - ["activemodel-adapter/system/active_model_adapter","activemodel-adapter/system/active_model_serializer","exports"], - function(__dependency1__, __dependency2__, __exports__) { - "use strict"; - var ActiveModelAdapter = __dependency1__["default"]; - var ActiveModelSerializer = __dependency2__["default"]; - - __exports__.ActiveModelAdapter = ActiveModelAdapter; - __exports__.ActiveModelSerializer = ActiveModelSerializer; - }); -enifed("activemodel-adapter/system/active_model_adapter", - ["ember-data/adapters","ember-data/system/adapter","ember-inflector","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __exports__) { - "use strict"; - var RESTAdapter = __dependency1__.RESTAdapter; - var InvalidError = __dependency2__.InvalidError; - var pluralize = __dependency3__.pluralize; - - /** - @module ember-data - */ - - var decamelize = Ember.String.decamelize, - underscore = Ember.String.underscore; - - /** - The ActiveModelAdapter is a subclass of the RESTAdapter designed to integrate - with a JSON API that uses an underscored naming convention instead of camelCasing. - It has been designed to work out of the box with the - [active_model_serializers](http://github.com/rails-api/active_model_serializers) - Ruby gem. This Adapter expects specific settings using ActiveModel::Serializers, - `embed :ids, embed_in_root: true` which sideloads the records. - - This adapter extends the DS.RESTAdapter by making consistent use of the camelization, - decamelization and pluralization methods to normalize the serialized JSON into a - format that is compatible with a conventional Rails backend and Ember Data. - - ## JSON Structure - - The ActiveModelAdapter expects the JSON returned from your server to follow - the REST adapter conventions substituting underscored keys for camelcased ones. - - Unlike the DS.RESTAdapter, async relationship keys must be the singular form - of the relationship name, followed by "_id" for DS.belongsTo relationships, - or "_ids" for DS.hasMany relationships. - - ### Conventional Names - - Attribute names in your JSON payload should be the underscored versions of - the attributes in your Ember.js models. - - For example, if you have a `Person` model: - - ```js - App.FamousPerson = DS.Model.extend({ - firstName: DS.attr('string'), - lastName: DS.attr('string'), - occupation: DS.attr('string') - }); - ``` - - The JSON returned should look like this: - - ```js - { - "famous_person": { - "id": 1, - "first_name": "Barack", - "last_name": "Obama", - "occupation": "President" - } - } - ``` - - Let's imagine that `Occupation` is just another model: - - ```js - App.Person = DS.Model.extend({ - firstName: DS.attr('string'), - lastName: DS.attr('string'), - occupation: DS.belongsTo('occupation') - }); - - App.Occupation = DS.Model.extend({ - name: DS.attr('string'), - salary: DS.attr('number'), - people: DS.hasMany('person') - }); - ``` - - The JSON needed to avoid extra server calls, should look like this: - - ```js - { - "people": [{ - "id": 1, - "first_name": "Barack", - "last_name": "Obama", - "occupation_id": 1 - }], - - "occupations": [{ - "id": 1, - "name": "President", - "salary": 100000, - "person_ids": [1] - }] - } - ``` - - @class ActiveModelAdapter - @constructor - @namespace DS - @extends DS.RESTAdapter - **/ - - var ActiveModelAdapter = RESTAdapter.extend({ - defaultSerializer: '-active-model', - /** - The ActiveModelAdapter overrides the `pathForType` method to build - underscored URLs by decamelizing and pluralizing the object type name. - - ```js - this.pathForType("famousPerson"); - //=> "famous_people" - ``` - - @method pathForType - @param {String} type - @return String - */ - pathForType: function(type) { - var decamelized = decamelize(type); - var underscored = underscore(decamelized); - return pluralize(underscored); - }, - - /** - The ActiveModelAdapter overrides the `ajaxError` method - to return a DS.InvalidError for all 422 Unprocessable Entity - responses. - - A 422 HTTP response from the server generally implies that the request - was well formed but the API was unable to process it because the - content was not semantically correct or meaningful per the API. - - For more information on 422 HTTP Error code see 11.2 WebDAV RFC 4918 - https://tools.ietf.org/html/rfc4918#section-11.2 - - @method ajaxError - @param {Object} jqXHR - @return error - */ - ajaxError: function(jqXHR) { - var error = this._super(jqXHR); - - if (jqXHR && jqXHR.status === 422) { - return new InvalidError(Ember.$.parseJSON(jqXHR.responseText)); - } else { - return error; - } - } - }); - - __exports__["default"] = ActiveModelAdapter; - }); -enifed("activemodel-adapter/system/active_model_serializer", - ["ember-inflector","ember-data/serializers/rest_serializer","exports"], - function(__dependency1__, __dependency2__, __exports__) { - "use strict"; - var singularize = __dependency1__.singularize; - var RESTSerializer = __dependency2__["default"]; - /** - @module ember-data - */ - - var get = Ember.get, - forEach = Ember.EnumerableUtils.forEach, - camelize = Ember.String.camelize, - capitalize = Ember.String.capitalize, - decamelize = Ember.String.decamelize, - underscore = Ember.String.underscore; - /** - The ActiveModelSerializer is a subclass of the RESTSerializer designed to integrate - with a JSON API that uses an underscored naming convention instead of camelCasing. - It has been designed to work out of the box with the - [active_model_serializers](http://github.com/rails-api/active_model_serializers) - Ruby gem. This Serializer expects specific settings using ActiveModel::Serializers, - `embed :ids, embed_in_root: true` which sideloads the records. - - This serializer extends the DS.RESTSerializer by making consistent - use of the camelization, decamelization and pluralization methods to - normalize the serialized JSON into a format that is compatible with - a conventional Rails backend and Ember Data. - - ## JSON Structure - - The ActiveModelSerializer expects the JSON returned from your server - to follow the REST adapter conventions substituting underscored keys - for camelcased ones. - - ### Conventional Names - - Attribute names in your JSON payload should be the underscored versions of - the attributes in your Ember.js models. - - For example, if you have a `Person` model: - - ```js - App.FamousPerson = DS.Model.extend({ - firstName: DS.attr('string'), - lastName: DS.attr('string'), - occupation: DS.attr('string') - }); - ``` - - The JSON returned should look like this: - - ```js - { - "famous_person": { - "id": 1, - "first_name": "Barack", - "last_name": "Obama", - "occupation": "President" - } - } - ``` - - Let's imagine that `Occupation` is just another model: - - ```js - App.Person = DS.Model.extend({ - firstName: DS.attr('string'), - lastName: DS.attr('string'), - occupation: DS.belongsTo('occupation') - }); - - App.Occupation = DS.Model.extend({ - name: DS.attr('string'), - salary: DS.attr('number'), - people: DS.hasMany('person') - }); - ``` - - The JSON needed to avoid extra server calls, should look like this: - - ```js - { - "people": [{ - "id": 1, - "first_name": "Barack", - "last_name": "Obama", - "occupation_id": 1 - }], - - "occupations": [{ - "id": 1, - "name": "President", - "salary": 100000, - "person_ids": [1] - }] - } - ``` - - @class ActiveModelSerializer - @namespace DS - @extends DS.RESTSerializer - */ - var ActiveModelSerializer = RESTSerializer.extend({ - // SERIALIZE - - /** - Converts camelCased attributes to underscored when serializing. - - @method keyForAttribute - @param {String} attribute - @return String - */ - keyForAttribute: function(attr) { - return decamelize(attr); - }, - - /** - Underscores relationship names and appends "_id" or "_ids" when serializing - relationship keys. - - @method keyForRelationship - @param {String} key - @param {String} kind - @return String - */ - keyForRelationship: function(rawKey, kind) { - var key = decamelize(rawKey); - if (kind === "belongsTo") { - return key + "_id"; - } else if (kind === "hasMany") { - return singularize(key) + "_ids"; - } else { - return key; - } - }, - - /* - Does not serialize hasMany relationships by default. - */ - serializeHasMany: Ember.K, - - /** - Underscores the JSON root keys when serializing. - - @method serializeIntoHash - @param {Object} hash - @param {subclass of DS.Model} type - @param {DS.Model} record - @param {Object} options - */ - serializeIntoHash: function(data, type, record, options) { - var root = underscore(decamelize(type.typeKey)); - data[root] = this.serialize(record, options); - }, - - /** - Serializes a polymorphic type as a fully capitalized model name. - - @method serializePolymorphicType - @param {DS.Model} record - @param {Object} json - @param {Object} relationship - */ - serializePolymorphicType: function(record, json, relationship) { - var key = relationship.key; - var belongsTo = get(record, key); - var jsonKey = underscore(key + "_type"); - - if (Ember.isNone(belongsTo)) { - json[jsonKey] = null; - } else { - json[jsonKey] = capitalize(camelize(belongsTo.constructor.typeKey)); - } - }, - - // EXTRACT - - /** - Add extra step to `DS.RESTSerializer.normalize` so links are normalized. - - If your payload looks like: - - ```js - { - "post": { - "id": 1, - "title": "Rails is omakase", - "links": { "flagged_comments": "api/comments/flagged" } - } - } - ``` - - The normalized version would look like this - - ```js - { - "post": { - "id": 1, - "title": "Rails is omakase", - "links": { "flaggedComments": "api/comments/flagged" } - } - } - ``` - - @method normalize - @param {subclass of DS.Model} type - @param {Object} hash - @param {String} prop - @return Object - */ - - normalize: function(type, hash, prop) { - this.normalizeLinks(hash); - - return this._super(type, hash, prop); - }, - - /** - Convert `snake_cased` links to `camelCase` - - @method normalizeLinks - @param {Object} data - */ - - normalizeLinks: function(data){ - if (data.links) { - var links = data.links; - - for (var link in links) { - var camelizedLink = camelize(link); - - if (camelizedLink !== link) { - links[camelizedLink] = links[link]; - delete links[link]; - } - } - } - }, - - /** - Normalize the polymorphic type from the JSON. - - Normalize: - ```js - { - id: "1" - minion: { type: "evil_minion", id: "12"} - } - ``` - - To: - ```js - { - id: "1" - minion: { type: "evilMinion", id: "12"} - } - ``` - - @method normalizeRelationships - @private - */ - normalizeRelationships: function(type, hash) { - - if (this.keyForRelationship) { - type.eachRelationship(function(key, relationship) { - var payloadKey, payload; - if (relationship.options.polymorphic) { - payloadKey = this.keyForAttribute(key); - payload = hash[payloadKey]; - if (payload && payload.type) { - payload.type = this.typeForRoot(payload.type); - } else if (payload && relationship.kind === "hasMany") { - var self = this; - forEach(payload, function(single) { - single.type = self.typeForRoot(single.type); - }); - } - } else { - payloadKey = this.keyForRelationship(key, relationship.kind); - if (!hash.hasOwnProperty(payloadKey)) { return; } - payload = hash[payloadKey]; - } - - hash[key] = payload; - - if (key !== payloadKey) { - delete hash[payloadKey]; - } - }, this); - } - } - }); - - __exports__["default"] = ActiveModelSerializer; - }); -enifed("ember-data", - ["ember-data/system/create","ember-data/core","ember-data/ext/date","ember-data/system/promise_proxies","ember-data/system/store","ember-data/system/model","ember-data/system/adapter","ember-data/system/debug","ember-data/system/record_arrays","ember-data/system/record_array_manager","ember-data/adapters","ember-data/serializers/json_serializer","ember-data/serializers/rest_serializer","ember-inflector","ember-data/serializers/embedded_records_mixin","activemodel-adapter","ember-data/transforms","ember-data/system/relationships","ember-data/ember-initializer","ember-data/setup-container","ember-data/system/container_proxy","ember-data/system/relationships/relationship","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __exports__) { - "use strict"; - /** - Ember Data - - @module ember-data - @main ember-data - */ - - // support RSVP 2.x via resolve, but prefer RSVP 3.x's Promise.cast - Ember.RSVP.Promise.cast = Ember.RSVP.Promise.cast || Ember.RSVP.resolve; - - var DS = __dependency2__["default"]; - - var PromiseArray = __dependency4__.PromiseArray; - var PromiseObject = __dependency4__.PromiseObject; - var Store = __dependency5__.Store; - var Model = __dependency6__.Model; - var Errors = __dependency6__.Errors; - var RootState = __dependency6__.RootState; - var attr = __dependency6__.attr; - var InvalidError = __dependency7__.InvalidError; - var Adapter = __dependency7__.Adapter; - var DebugAdapter = __dependency8__["default"]; - var RecordArray = __dependency9__.RecordArray; - var FilteredRecordArray = __dependency9__.FilteredRecordArray; - var AdapterPopulatedRecordArray = __dependency9__.AdapterPopulatedRecordArray; - var ManyArray = __dependency9__.ManyArray; - var RecordArrayManager = __dependency10__["default"]; - var RESTAdapter = __dependency11__.RESTAdapter; - var FixtureAdapter = __dependency11__.FixtureAdapter; - var JSONSerializer = __dependency12__["default"]; - var RESTSerializer = __dependency13__["default"]; - var EmbeddedRecordsMixin = __dependency15__["default"]; - var ActiveModelAdapter = __dependency16__.ActiveModelAdapter; - var ActiveModelSerializer = __dependency16__.ActiveModelSerializer; - - var Transform = __dependency17__.Transform; - var DateTransform = __dependency17__.DateTransform; - var NumberTransform = __dependency17__.NumberTransform; - var StringTransform = __dependency17__.StringTransform; - var BooleanTransform = __dependency17__.BooleanTransform; - - var hasMany = __dependency18__.hasMany; - var belongsTo = __dependency18__.belongsTo; - var setupContainer = __dependency20__["default"]; - - var ContainerProxy = __dependency21__["default"]; - var Relationship = __dependency22__.Relationship; - - DS.Store = Store; - DS.PromiseArray = PromiseArray; - DS.PromiseObject = PromiseObject; - - DS.Model = Model; - DS.RootState = RootState; - DS.attr = attr; - DS.Errors = Errors; - - DS.Adapter = Adapter; - DS.InvalidError = InvalidError; - - DS.DebugAdapter = DebugAdapter; - - DS.RecordArray = RecordArray; - DS.FilteredRecordArray = FilteredRecordArray; - DS.AdapterPopulatedRecordArray = AdapterPopulatedRecordArray; - DS.ManyArray = ManyArray; - - DS.RecordArrayManager = RecordArrayManager; - - DS.RESTAdapter = RESTAdapter; - DS.FixtureAdapter = FixtureAdapter; - - DS.RESTSerializer = RESTSerializer; - DS.JSONSerializer = JSONSerializer; - - DS.Transform = Transform; - DS.DateTransform = DateTransform; - DS.StringTransform = StringTransform; - DS.NumberTransform = NumberTransform; - DS.BooleanTransform = BooleanTransform; - - DS.ActiveModelAdapter = ActiveModelAdapter; - DS.ActiveModelSerializer = ActiveModelSerializer; - DS.EmbeddedRecordsMixin = EmbeddedRecordsMixin; - - DS.belongsTo = belongsTo; - DS.hasMany = hasMany; - - DS.Relationship = Relationship; - - DS.ContainerProxy = ContainerProxy; - - DS._setupContainer = setupContainer; - - Ember.lookup.DS = DS; - - __exports__["default"] = DS; - }); -enifed("ember-data/adapters", - ["ember-data/adapters/fixture_adapter","ember-data/adapters/rest_adapter","exports"], - function(__dependency1__, __dependency2__, __exports__) { - "use strict"; - /** - @module ember-data - */ - - var FixtureAdapter = __dependency1__["default"]; - var RESTAdapter = __dependency2__["default"]; - - __exports__.RESTAdapter = RESTAdapter; - __exports__.FixtureAdapter = FixtureAdapter; - }); -enifed("ember-data/adapters/fixture_adapter", - ["ember-data/system/adapter","exports"], - function(__dependency1__, __exports__) { - "use strict"; - /** - @module ember-data - */ - - var get = Ember.get; - var fmt = Ember.String.fmt; - var indexOf = Ember.EnumerableUtils.indexOf; - - var counter = 0; - - var Adapter = __dependency1__["default"]; - - /** - `DS.FixtureAdapter` is an adapter that loads records from memory. - It's primarily used for development and testing. You can also use - `DS.FixtureAdapter` while working on the API but is not ready to - integrate yet. It is a fully functioning adapter. All CRUD methods - are implemented. You can also implement query logic that a remote - system would do. It's possible to develop your entire application - with `DS.FixtureAdapter`. - - For information on how to use the `FixtureAdapter` in your - application please see the [FixtureAdapter - guide](/guides/models/the-fixture-adapter/). - - @class FixtureAdapter - @namespace DS - @extends DS.Adapter - */ - __exports__["default"] = Adapter.extend({ - // by default, fixtures are already in normalized form - serializer: null, - - /** - If `simulateRemoteResponse` is `true` the `FixtureAdapter` will - wait a number of milliseconds before resolving promises with the - fixture values. The wait time can be configured via the `latency` - property. - - @property simulateRemoteResponse - @type {Boolean} - @default true - */ - simulateRemoteResponse: true, - - /** - By default the `FixtureAdapter` will simulate a wait of the - `latency` milliseconds before resolving promises with the fixture - values. This behavior can be turned off via the - `simulateRemoteResponse` property. - - @property latency - @type {Number} - @default 50 - */ - latency: 50, - - /** - Implement this method in order to provide data associated with a type - - @method fixturesForType - @param {Subclass of DS.Model} type - @return {Array} - */ - fixturesForType: function(type) { - if (type.FIXTURES) { - var fixtures = Ember.A(type.FIXTURES); - return fixtures.map(function(fixture){ - var fixtureIdType = typeof fixture.id; - if(fixtureIdType !== "number" && fixtureIdType !== "string"){ - throw new Error(fmt('the id property must be defined as a number or string for fixture %@', [fixture])); - } - fixture.id = fixture.id + ''; - return fixture; - }); - } - return null; - }, - - /** - Implement this method in order to query fixtures data - - @method queryFixtures - @param {Array} fixture - @param {Object} query - @param {Subclass of DS.Model} type - @return {Promise|Array} - */ - queryFixtures: function(fixtures, query, type) { - Ember.assert('Not implemented: You must override the DS.FixtureAdapter::queryFixtures method to support querying the fixture store.'); - }, - - /** - @method updateFixtures - @param {Subclass of DS.Model} type - @param {Array} fixture - */ - updateFixtures: function(type, fixture) { - if(!type.FIXTURES) { - type.FIXTURES = []; - } - - var fixtures = type.FIXTURES; - - this.deleteLoadedFixture(type, fixture); - - fixtures.push(fixture); - }, - - /** - Implement this method in order to provide json for CRUD methods - - @method mockJSON - @param {Subclass of DS.Model} type - @param {DS.Model} record - */ - mockJSON: function(store, type, record) { - return store.serializerFor(type).serialize(record, { includeId: true }); - }, - - /** - @method generateIdForRecord - @param {DS.Store} store - @param {DS.Model} record - @return {String} id - */ - generateIdForRecord: function(store) { - return "fixture-" + counter++; - }, - - /** - @method find - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {String} id - @return {Promise} promise - */ - find: function(store, type, id) { - var fixtures = this.fixturesForType(type); - var fixture; - - Ember.assert("Unable to find fixtures for model type "+type.toString() +". If you're defining your fixtures using `Model.FIXTURES = ...`, please change it to `Model.reopenClass({ FIXTURES: ... })`.", fixtures); - - if (fixtures) { - fixture = Ember.A(fixtures).findBy('id', id); - } - - if (fixture) { - return this.simulateRemoteCall(function() { - return fixture; - }, this); - } - }, - - /** - @method findMany - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Array} ids - @return {Promise} promise - */ - findMany: function(store, type, ids) { - var fixtures = this.fixturesForType(type); - - Ember.assert("Unable to find fixtures for model type "+type.toString(), fixtures); - - if (fixtures) { - fixtures = fixtures.filter(function(item) { - return indexOf(ids, item.id) !== -1; - }); - } - - if (fixtures) { - return this.simulateRemoteCall(function() { - return fixtures; - }, this); - } - }, - - /** - @private - @method findAll - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {String} sinceToken - @return {Promise} promise - */ - findAll: function(store, type) { - var fixtures = this.fixturesForType(type); - - Ember.assert("Unable to find fixtures for model type "+type.toString(), fixtures); - - return this.simulateRemoteCall(function() { - return fixtures; - }, this); - }, - - /** - @private - @method findQuery - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} query - @param {DS.AdapterPopulatedRecordArray} recordArray - @return {Promise} promise - */ - findQuery: function(store, type, query, array) { - var fixtures = this.fixturesForType(type); - - Ember.assert("Unable to find fixtures for model type " + type.toString(), fixtures); - - fixtures = this.queryFixtures(fixtures, query, type); - - if (fixtures) { - return this.simulateRemoteCall(function() { - return fixtures; - }, this); - } - }, - - /** - @method createRecord - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {DS.Model} record - @return {Promise} promise - */ - createRecord: function(store, type, record) { - var fixture = this.mockJSON(store, type, record); - - this.updateFixtures(type, fixture); - - return this.simulateRemoteCall(function() { - return fixture; - }, this); - }, - - /** - @method updateRecord - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {DS.Model} record - @return {Promise} promise - */ - updateRecord: function(store, type, record) { - var fixture = this.mockJSON(store, type, record); - - this.updateFixtures(type, fixture); - - return this.simulateRemoteCall(function() { - return fixture; - }, this); - }, - - /** - @method deleteRecord - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {DS.Model} record - @return {Promise} promise - */ - deleteRecord: function(store, type, record) { - this.deleteLoadedFixture(type, record); - - return this.simulateRemoteCall(function() { - // no payload in a deletion - return null; - }); - }, - - /* - @method deleteLoadedFixture - @private - @param type - @param record - */ - deleteLoadedFixture: function(type, record) { - var existingFixture = this.findExistingFixture(type, record); - - if (existingFixture) { - var index = indexOf(type.FIXTURES, existingFixture); - type.FIXTURES.splice(index, 1); - return true; - } - }, - - /* - @method findExistingFixture - @private - @param type - @param record - */ - findExistingFixture: function(type, record) { - var fixtures = this.fixturesForType(type); - var id = get(record, 'id'); - - return this.findFixtureById(fixtures, id); - }, - - /* - @method findFixtureById - @private - @param fixtures - @param id - */ - findFixtureById: function(fixtures, id) { - return Ember.A(fixtures).find(function(r) { - if (''+get(r, 'id') === ''+id) { - return true; - } else { - return false; - } - }); - }, - - /* - @method simulateRemoteCall - @private - @param callback - @param context - */ - simulateRemoteCall: function(callback, context) { - var adapter = this; - - return new Ember.RSVP.Promise(function(resolve) { - var value = Ember.copy(callback.call(context), true); - if (get(adapter, 'simulateRemoteResponse')) { - // Schedule with setTimeout - Ember.run.later(function() { - resolve(value); - }, get(adapter, 'latency')); - } else { - // Asynchronous, but at the of the runloop with zero latency - Ember.run.schedule('actions', null, function() { - resolve(value); - }); - } - }, "DS: FixtureAdapter#simulateRemoteCall"); - } - }); - }); -enifed("ember-data/adapters/rest_adapter", - ["ember-data/system/adapter","ember-data/system/map","exports"], - function(__dependency1__, __dependency2__, __exports__) { - "use strict"; - /** - @module ember-data - */ - - var Adapter = __dependency1__.Adapter; - var InvalidError = __dependency1__.InvalidError; - var MapWithDefault = __dependency2__.MapWithDefault; - var get = Ember.get; - var forEach = Ember.ArrayPolyfills.forEach; - - /** - The REST adapter allows your store to communicate with an HTTP server by - transmitting JSON via XHR. Most Ember.js apps that consume a JSON API - should use the REST adapter. - - This adapter is designed around the idea that the JSON exchanged with - the server should be conventional. - - ## JSON Structure - - The REST adapter expects the JSON returned from your server to follow - these conventions. - - ### Object Root - - The JSON payload should be an object that contains the record inside a - root property. For example, in response to a `GET` request for - `/posts/1`, the JSON should look like this: - - ```js - { - "post": { - "id": 1, - "title": "I'm Running to Reform the W3C's Tag", - "author": "Yehuda Katz" - } - } - ``` - - Similarly, in response to a `GET` request for `/posts`, the JSON should - look like this: - - ```js - { - "posts": [ - { - "id": 1, - "title": "I'm Running to Reform the W3C's Tag", - "author": "Yehuda Katz" - }, - { - "id": 2, - "title": "Rails is omakase", - "author": "D2H" - } - ] - } - ``` - - ### Conventional Names - - Attribute names in your JSON payload should be the camelCased versions of - the attributes in your Ember.js models. - - For example, if you have a `Person` model: - - ```js - App.Person = DS.Model.extend({ - firstName: DS.attr('string'), - lastName: DS.attr('string'), - occupation: DS.attr('string') - }); - ``` - - The JSON returned should look like this: - - ```js - { - "person": { - "id": 5, - "firstName": "Barack", - "lastName": "Obama", - "occupation": "President" - } - } - ``` - - ## Customization - - ### Endpoint path customization - - Endpoint paths can be prefixed with a `namespace` by setting the namespace - property on the adapter: - - ```js - DS.RESTAdapter.reopen({ - namespace: 'api/1' - }); - ``` - Requests for `App.Person` would now target `/api/1/people/1`. - - ### Host customization - - An adapter can target other hosts by setting the `host` property. - - ```js - DS.RESTAdapter.reopen({ - host: 'https://api.example.com' - }); - ``` - - ### Headers customization - - Some APIs require HTTP headers, e.g. to provide an API key. Arbitrary - headers can be set as key/value pairs on the `RESTAdapter`'s `headers` - object and Ember Data will send them along with each ajax request. - - - ```js - App.ApplicationAdapter = DS.RESTAdapter.extend({ - headers: { - "API_KEY": "secret key", - "ANOTHER_HEADER": "Some header value" - } - }); - ``` - - `headers` can also be used as a computed property to support dynamic - headers. In the example below, the `session` object has been - injected into an adapter by Ember's container. - - ```js - App.ApplicationAdapter = DS.RESTAdapter.extend({ - headers: function() { - return { - "API_KEY": this.get("session.authToken"), - "ANOTHER_HEADER": "Some header value" - }; - }.property("session.authToken") - }); - ``` - - In some cases, your dynamic headers may require data from some - object outside of Ember's observer system (for example - `document.cookie`). You can use the - [volatile](/api/classes/Ember.ComputedProperty.html#method_volatile) - function to set the property into a non-cached mode causing the headers to - be recomputed with every request. - - ```js - App.ApplicationAdapter = DS.RESTAdapter.extend({ - headers: function() { - return { - "API_KEY": Ember.get(document.cookie.match(/apiKey\=([^;]*)/), "1"), - "ANOTHER_HEADER": "Some header value" - }; - }.property().volatile() - }); - ``` - - @class RESTAdapter - @constructor - @namespace DS - @extends DS.Adapter - */ - __exports__["default"] = Adapter.extend({ - defaultSerializer: '-rest', - - /** - By default the RESTAdapter will send each find request coming from a `store.find` - or from accessing a relationship separately to the server. If your server supports passing - ids as a query string, you can set coalesceFindRequests to true to coalesce all find requests - within a single runloop. - - For example, if you have an initial payload of - ```javascript - post: { - id:1, - comments: [1,2] - } - ``` - - By default calling `post.get('comments')` will trigger the following requests(assuming the - comments haven't been loaded before): - - ``` - GET /comments/1 - GET /comments/2 - ``` - - If you set coalesceFindRequests to `true` it will instead trigger the following request: - - ``` - GET /comments?ids[]=1&ids[]=2 - ``` - - Setting coalesceFindRequests to `true` also works for `store.find` requests and `belongsTo` - relationships accessed within the same runloop. If you set `coalesceFindRequests: true` - - ```javascript - store.find('comment', 1); - store.find('comment', 2); - ``` - - will also send a request to: `GET /comments?ids[]=1&ids[]=2` - - Note: Requests coalescing rely on URL building strategy. So if you override `buildUrl` in your app - `groupRecordsForFindMany` more likely should be overriden as well in order for coalescing to work. - - @property coalesceFindRequests - @type {boolean} - */ - coalesceFindRequests: false, - - /** - Endpoint paths can be prefixed with a `namespace` by setting the namespace - property on the adapter: - - ```javascript - DS.RESTAdapter.reopen({ - namespace: 'api/1' - }); - ``` - - Requests for `App.Post` would now target `/api/1/post/`. - - @property namespace - @type {String} - */ - - /** - An adapter can target other hosts by setting the `host` property. - - ```javascript - DS.RESTAdapter.reopen({ - host: 'https://api.example.com' - }); - ``` - - Requests for `App.Post` would now target `https://api.example.com/post/`. - - @property host - @type {String} - */ - - /** - Some APIs require HTTP headers, e.g. to provide an API - key. Arbitrary headers can be set as key/value pairs on the - `RESTAdapter`'s `headers` object and Ember Data will send them - along with each ajax request. For dynamic headers see [headers - customization](/api/data/classes/DS.RESTAdapter.html#toc_headers-customization). - - ```javascript - App.ApplicationAdapter = DS.RESTAdapter.extend({ - headers: { - "API_KEY": "secret key", - "ANOTHER_HEADER": "Some header value" - } - }); - ``` - - @property headers - @type {Object} - */ - - /** - Called by the store in order to fetch the JSON for a given - type and ID. - - The `find` method makes an Ajax request to a URL computed by `buildURL`, and returns a - promise for the resulting payload. - - This method performs an HTTP `GET` request with the id provided as part of the query string. - - @method find - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {String} id - @param {DS.Model} record - @return {Promise} promise - */ - find: function(store, type, id, record) { - return this.ajax(this.buildURL(type.typeKey, id, record), 'GET'); - }, - - /** - Called by the store in order to fetch a JSON array for all - of the records for a given type. - - The `findAll` method makes an Ajax (HTTP GET) request to a URL computed by `buildURL`, and returns a - promise for the resulting payload. - - @private - @method findAll - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {String} sinceToken - @return {Promise} promise - */ - findAll: function(store, type, sinceToken) { - var query; - - if (sinceToken) { - query = { since: sinceToken }; - } - - return this.ajax(this.buildURL(type.typeKey), 'GET', { data: query }); - }, - - /** - Called by the store in order to fetch a JSON array for - the records that match a particular query. - - The `findQuery` method makes an Ajax (HTTP GET) request to a URL computed by `buildURL`, and returns a - promise for the resulting payload. - - The `query` argument is a simple JavaScript object that will be passed directly - to the server as parameters. - - @private - @method findQuery - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} query - @return {Promise} promise - */ - findQuery: function(store, type, query) { - return this.ajax(this.buildURL(type.typeKey), 'GET', { data: query }); - }, - - /** - Called by the store in order to fetch several records together if `coalesceFindRequests` is true - - For example, if the original payload looks like: - - ```js - { - "id": 1, - "title": "Rails is omakase", - "comments": [ 1, 2, 3 ] - } - ``` - - The IDs will be passed as a URL-encoded Array of IDs, in this form: - - ``` - ids[]=1&ids[]=2&ids[]=3 - ``` - - Many servers, such as Rails and PHP, will automatically convert this URL-encoded array - into an Array for you on the server-side. If you want to encode the - IDs, differently, just override this (one-line) method. - - The `findMany` method makes an Ajax (HTTP GET) request to a URL computed by `buildURL`, and returns a - promise for the resulting payload. - - @method findMany - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Array} ids - @param {Array} records - @return {Promise} promise - */ - findMany: function(store, type, ids, records) { - return this.ajax(this.buildURL(type.typeKey, ids, records), 'GET', { data: { ids: ids } }); - }, - - /** - Called by the store in order to fetch a JSON array for - the unloaded records in a has-many relationship that were originally - specified as a URL (inside of `links`). - - For example, if your original payload looks like this: - - ```js - { - "post": { - "id": 1, - "title": "Rails is omakase", - "links": { "comments": "/posts/1/comments" } - } - } - ``` - - This method will be called with the parent record and `/posts/1/comments`. - - The `findHasMany` method will make an Ajax (HTTP GET) request to the originally specified URL. - If the URL is host-relative (starting with a single slash), the - request will use the host specified on the adapter (if any). - - @method findHasMany - @param {DS.Store} store - @param {DS.Model} record - @param {String} url - @return {Promise} promise - */ - findHasMany: function(store, record, url, relationship) { - var host = get(this, 'host'); - var id = get(record, 'id'); - var type = record.constructor.typeKey; - - if (host && url.charAt(0) === '/' && url.charAt(1) !== '/') { - url = host + url; - } - - return this.ajax(this.urlPrefix(url, this.buildURL(type, id)), 'GET'); - }, - - /** - Called by the store in order to fetch a JSON array for - the unloaded records in a belongs-to relationship that were originally - specified as a URL (inside of `links`). - - For example, if your original payload looks like this: - - ```js - { - "person": { - "id": 1, - "name": "Tom Dale", - "links": { "group": "/people/1/group" } - } - } - ``` - - This method will be called with the parent record and `/people/1/group`. - - The `findBelongsTo` method will make an Ajax (HTTP GET) request to the originally specified URL. - - @method findBelongsTo - @param {DS.Store} store - @param {DS.Model} record - @param {String} url - @return {Promise} promise - */ - findBelongsTo: function(store, record, url, relationship) { - var id = get(record, 'id'); - var type = record.constructor.typeKey; - - return this.ajax(this.urlPrefix(url, this.buildURL(type, id)), 'GET'); - }, - - /** - Called by the store when a newly created record is - saved via the `save` method on a model record instance. - - The `createRecord` method serializes the record and makes an Ajax (HTTP POST) request - to a URL computed by `buildURL`. - - See `serialize` for information on how to customize the serialized form - of a record. - - @method createRecord - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {DS.Model} record - @return {Promise} promise - */ - createRecord: function(store, type, record) { - var data = {}; - var serializer = store.serializerFor(type.typeKey); - - serializer.serializeIntoHash(data, type, record, { includeId: true }); - - return this.ajax(this.buildURL(type.typeKey, null, record), "POST", { data: data }); - }, - - /** - Called by the store when an existing record is saved - via the `save` method on a model record instance. - - The `updateRecord` method serializes the record and makes an Ajax (HTTP PUT) request - to a URL computed by `buildURL`. - - See `serialize` for information on how to customize the serialized form - of a record. - - @method updateRecord - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {DS.Model} record - @return {Promise} promise - */ - updateRecord: function(store, type, record) { - var data = {}; - var serializer = store.serializerFor(type.typeKey); - - serializer.serializeIntoHash(data, type, record); - - var id = get(record, 'id'); - - return this.ajax(this.buildURL(type.typeKey, id, record), "PUT", { data: data }); - }, - - /** - Called by the store when a record is deleted. - - The `deleteRecord` method makes an Ajax (HTTP DELETE) request to a URL computed by `buildURL`. - - @method deleteRecord - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {DS.Model} record - @return {Promise} promise - */ - deleteRecord: function(store, type, record) { - var id = get(record, 'id'); - - return this.ajax(this.buildURL(type.typeKey, id, record), "DELETE"); - }, - - /** - Builds a URL for a given type and optional ID. - - By default, it pluralizes the type's name (for example, 'post' - becomes 'posts' and 'person' becomes 'people'). To override the - pluralization see [pathForType](#method_pathForType). - - If an ID is specified, it adds the ID to the path generated - for the type, separated by a `/`. - - @method buildURL - @param {String} type - @param {String} id - @param {DS.Model} record - @return {String} url - */ - buildURL: function(type, id, record) { - var url = [], - host = get(this, 'host'), - prefix = this.urlPrefix(); - - if (type) { url.push(this.pathForType(type)); } - - //We might get passed in an array of ids from findMany - //in which case we don't want to modify the url, as the - //ids will be passed in through a query param - if (id && !Ember.isArray(id)) { url.push(encodeURIComponent(id)); } - - if (prefix) { url.unshift(prefix); } - - url = url.join('/'); - if (!host && url) { url = '/' + url; } - - return url; - }, - - /** - @method urlPrefix - @private - @param {String} path - @param {String} parentUrl - @return {String} urlPrefix - */ - urlPrefix: function(path, parentURL) { - var host = get(this, 'host'); - var namespace = get(this, 'namespace'); - var url = []; - - if (path) { - // Absolute path - if (path.charAt(0) === '/') { - if (host) { - path = path.slice(1); - url.push(host); - } - // Relative path - } else if (!/^http(s)?:\/\//.test(path)) { - url.push(parentURL); - } - } else { - if (host) { url.push(host); } - if (namespace) { url.push(namespace); } - } - - if (path) { - url.push(path); - } - - return url.join('/'); - }, - - _stripIDFromURL: function(store, record) { - var type = record.constructor; - var url = this.buildURL(type.typeKey, record.get('id'), record); - - var expandedURL = url.split('/'); - //Case when the url is of the format ...something/:id - var lastSegment = expandedURL[ expandedURL.length - 1 ]; - var id = record.get('id'); - if (lastSegment === id) { - expandedURL[expandedURL.length - 1] = ""; - } else if(endsWith(lastSegment, '?id=' + id)) { - //Case when the url is of the format ...something?id=:id - expandedURL[expandedURL.length - 1] = lastSegment.substring(0, lastSegment.length - id.length - 1); - } - - return expandedURL.join('/'); - }, - - /** - http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers - */ - maxUrlLength: 2048, - - /** - Organize records into groups, each of which is to be passed to separate - calls to `findMany`. - - This implementation groups together records that have the same base URL but - differing ids. For example `/comments/1` and `/comments/2` will be grouped together - because we know findMany can coalesce them together as `/comments?ids[]=1&ids[]=2` - - It also supports urls where ids are passed as a query param, such as `/comments?id=1` - but not those where there is more than 1 query param such as `/comments?id=2&name=David` - Currently only the query param of `id` is supported. If you need to support others, please - override this or the `_stripIDFromURL` method. - - It does not group records that have differing base urls, such as for example: `/posts/1/comments/2` - and `/posts/2/comments/3` - - @method groupRecordsForFindMany - @param {DS.Store} store - @param {Array} records - @return {Array} an array of arrays of records, each of which is to be - loaded separately by `findMany`. - */ - groupRecordsForFindMany: function (store, records) { - var groups = MapWithDefault.create({defaultValue: function(){return [];}}); - var adapter = this; - var maxUrlLength = this.maxUrlLength; - - forEach.call(records, function(record){ - var baseUrl = adapter._stripIDFromURL(store, record); - groups.get(baseUrl).push(record); - }); - - function splitGroupToFitInUrl(group, maxUrlLength, paramNameLength) { - var baseUrl = adapter._stripIDFromURL(store, group[0]); - var idsSize = 0; - var splitGroups = [[]]; - - forEach.call(group, function(record) { - var additionalLength = encodeURIComponent(record.get('id')).length + paramNameLength; - if (baseUrl.length + idsSize + additionalLength >= maxUrlLength) { - idsSize = 0; - splitGroups.push([]); - } - - idsSize += additionalLength; - - var lastGroupIndex = splitGroups.length - 1; - splitGroups[lastGroupIndex].push(record); - }); - - return splitGroups; - } - - var groupsArray = []; - groups.forEach(function(group, key){ - var paramNameLength = '&ids%5B%5D='.length; - var splitGroups = splitGroupToFitInUrl(group, maxUrlLength, paramNameLength); - - forEach.call(splitGroups, function(splitGroup) { - groupsArray.push(splitGroup); - }); - }); - - return groupsArray; - }, - - /** - Determines the pathname for a given type. - - By default, it pluralizes the type's name (for example, - 'post' becomes 'posts' and 'person' becomes 'people'). - - ### Pathname customization - - For example if you have an object LineItem with an - endpoint of "/line_items/". - - ```js - App.ApplicationAdapter = DS.RESTAdapter.extend({ - pathForType: function(type) { - var decamelized = Ember.String.decamelize(type); - return Ember.String.pluralize(decamelized); - } - }); - ``` - - @method pathForType - @param {String} type - @return {String} path - **/ - pathForType: function(type) { - var camelized = Ember.String.camelize(type); - return Ember.String.pluralize(camelized); - }, - - /** - Takes an ajax response, and returns an error payload. - - Returning a `DS.InvalidError` from this method will cause the - record to transition into the `invalid` state and make the - `errors` object available on the record. - - This function should return the entire payload as received from the - server. Error object extraction and normalization of model errors - should be performed by `extractErrors` on the serializer. - - Example - - ```javascript - App.ApplicationAdapter = DS.RESTAdapter.extend({ - ajaxError: function(jqXHR) { - var error = this._super(jqXHR); - - if (jqXHR && jqXHR.status === 422) { - var jsonErrors = Ember.$.parseJSON(jqXHR.responseText); - - return new DS.InvalidError(jsonErrors); - } else { - return error; - } - } - }); - ``` - - Note: As a correctness optimization, the default implementation of - the `ajaxError` method strips out the `then` method from jquery's - ajax response (jqXHR). This is important because the jqXHR's - `then` method fulfills the promise with itself resulting in a - circular "thenable" chain which may cause problems for some - promise libraries. - - @method ajaxError - @param {Object} jqXHR - @param {Object} responseText - @return {Object} jqXHR - */ - ajaxError: function(jqXHR, responseText) { - if (jqXHR && typeof jqXHR === 'object') { - jqXHR.then = null; - } - - return jqXHR; - }, - - /** - Takes an ajax response, and returns the json payload. - - By default this hook just returns the jsonPayload passed to it. - You might want to override it in two cases: - - 1. Your API might return useful results in the request headers. - If you need to access these, you can override this hook to copy them - from jqXHR to the payload object so they can be processed in you serializer. - - - 2. Your API might return errors as successful responses with status code - 200 and an Errors text or object. You can return a DS.InvalidError from - this hook and it will automatically reject the promise and put your record - into the invalid state. - - @method ajaxSuccess - @param {Object} jqXHR - @param {Object} jsonPayload - @return {Object} jsonPayload - */ - - ajaxSuccess: function(jqXHR, jsonPayload) { - return jsonPayload; - }, - - /** - Takes a URL, an HTTP method and a hash of data, and makes an - HTTP request. - - When the server responds with a payload, Ember Data will call into `extractSingle` - or `extractArray` (depending on whether the original query was for one record or - many records). - - By default, `ajax` method has the following behavior: - - * It sets the response `dataType` to `"json"` - * If the HTTP method is not `"GET"`, it sets the `Content-Type` to be - `application/json; charset=utf-8` - * If the HTTP method is not `"GET"`, it stringifies the data passed in. The - data is the serialized record in the case of a save. - * Registers success and failure handlers. - - @method ajax - @private - @param {String} url - @param {String} type The request type GET, POST, PUT, DELETE etc. - @param {Object} hash - @return {Promise} promise - */ - ajax: function(url, type, options) { - var adapter = this; - - return new Ember.RSVP.Promise(function(resolve, reject) { - var hash = adapter.ajaxOptions(url, type, options); - - hash.success = function(json, textStatus, jqXHR) { - json = adapter.ajaxSuccess(jqXHR, json); - if (json instanceof InvalidError) { - Ember.run(null, reject, json); - } else { - Ember.run(null, resolve, json); - } - }; - - hash.error = function(jqXHR, textStatus, errorThrown) { - Ember.run(null, reject, adapter.ajaxError(jqXHR, jqXHR.responseText)); - }; - - Ember.$.ajax(hash); - }, "DS: RESTAdapter#ajax " + type + " to " + url); - }, - - /** - @method ajaxOptions - @private - @param {String} url - @param {String} type The request type GET, POST, PUT, DELETE etc. - @param {Object} hash - @return {Object} hash - */ - ajaxOptions: function(url, type, options) { - var hash = options || {}; - hash.url = url; - hash.type = type; - hash.dataType = 'json'; - hash.context = this; - - if (hash.data && type !== 'GET') { - hash.contentType = 'application/json; charset=utf-8'; - hash.data = JSON.stringify(hash.data); - } - - var headers = get(this, 'headers'); - if (headers !== undefined) { - hash.beforeSend = function (xhr) { - forEach.call(Ember.keys(headers), function(key) { - xhr.setRequestHeader(key, headers[key]); - }); - }; - } - - return hash; - } - }); - - //From http://stackoverflow.com/questions/280634/endswith-in-javascript - function endsWith(string, suffix){ - if (typeof String.prototype.endsWith !== 'function') { - return string.indexOf(suffix, string.length - suffix.length) !== -1; - } else { - return string.endsWith(suffix); - } - } - }); -enifed("ember-data/core", - ["exports"], - function(__exports__) { - "use strict"; - /** - @module ember-data - */ - - /** - All Ember Data methods and functions are defined inside of this namespace. - - @class DS - @static - */ - var DS; - if ('undefined' === typeof DS) { - /** - @property VERSION - @type String - @default '1.0.0-beta.12' - @static - */ - DS = Ember.Namespace.create({ - VERSION: '1.0.0-beta.12' - }); - - if (Ember.libraries) { - Ember.libraries.registerCoreLibrary('Ember Data', DS.VERSION); - } - } - - __exports__["default"] = DS; - }); -enifed("ember-data/ember-initializer", - ["ember-data/setup-container"], - function(__dependency1__) { - "use strict"; - var setupContainer = __dependency1__["default"]; - - var K = Ember.K; - - /** - @module ember-data - */ - - /* - - This code initializes Ember-Data onto an Ember application. - - If an Ember.js developer defines a subclass of DS.Store on their application, - as `App.ApplicationStore` (or via a module system that resolves to `store:application`) - this code will automatically instantiate it and make it available on the - router. - - Additionally, after an application's controllers have been injected, they will - each have the store made available to them. - - For example, imagine an Ember.js application with the following classes: - - App.ApplicationStore = DS.Store.extend({ - adapter: 'custom' - }); - - App.PostsController = Ember.ArrayController.extend({ - // ... - }); - - When the application is initialized, `App.ApplicationStore` will automatically be - instantiated, and the instance of `App.PostsController` will have its `store` - property set to that instance. - - Note that this code will only be run if the `ember-application` package is - loaded. If Ember Data is being used in an environment other than a - typical application (e.g., node.js where only `ember-runtime` is available), - this code will be ignored. - */ - - Ember.onLoad('Ember.Application', function(Application) { - - Application.initializer({ - name: "ember-data", - initialize: setupContainer - }); - - // Deprecated initializers to satisfy old code that depended on them - - Application.initializer({ - name: "store", - after: "ember-data", - initialize: K - }); - - Application.initializer({ - name: "activeModelAdapter", - before: "store", - initialize: K - }); - - Application.initializer({ - name: "transforms", - before: "store", - initialize: K - }); - - Application.initializer({ - name: "data-adapter", - before: "store", - initialize: K - }); - - Application.initializer({ - name: "injectStore", - before: "store", - initialize: K - }); - }); - }); -enifed("ember-data/ext/date", - [], - function() { - "use strict"; - /** - @module ember-data - */ - - /** - Date.parse with progressive enhancement for ISO 8601 <https://github.com/csnover/js-iso8601> - - © 2011 Colin Snover <http://zetafleet.com> - - Released under MIT license. - - @class Date - @namespace Ember - @static - */ - Ember.Date = Ember.Date || {}; - - var origParse = Date.parse, numericKeys = [ 1, 4, 5, 6, 7, 10, 11 ]; - - /** - @method parse - @param {Date} date - @return {Number} timestamp - */ - Ember.Date.parse = function (date) { - var timestamp, struct, minutesOffset = 0; - - // ES5 §15.9.4.2 states that the string should attempt to be parsed as a Date Time String Format string - // before falling back to any implementation-specific date parsing, so that’s what we do, even if native - // implementations could be faster - // 1 YYYY 2 MM 3 DD 4 HH 5 mm 6 ss 7 msec 8 Z 9 ± 10 tzHH 11 tzmm - if ((struct = /^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/.exec(date))) { - // avoid NaN timestamps caused by “undefined” values being passed to Date.UTC - for (var i = 0, k; (k = numericKeys[i]); ++i) { - struct[k] = +struct[k] || 0; - } - - // allow undefined days and months - struct[2] = (+struct[2] || 1) - 1; - struct[3] = +struct[3] || 1; - - if (struct[8] !== 'Z' && struct[9] !== undefined) { - minutesOffset = struct[10] * 60 + struct[11]; - - if (struct[9] === '+') { - minutesOffset = 0 - minutesOffset; - } - } - - timestamp = Date.UTC(struct[1], struct[2], struct[3], struct[4], struct[5] + minutesOffset, struct[6], struct[7]); - } - else { - timestamp = origParse ? origParse(date) : NaN; - } - - return timestamp; - }; - - if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Date) { - Date.parse = Ember.Date.parse; - } - }); -enifed("ember-data/initializers/data_adapter", - ["ember-data/system/debug/debug_adapter","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var DebugAdapter = __dependency1__["default"]; - - /** - Configures a container with injections on Ember applications - for the Ember-Data store. Accepts an optional namespace argument. - - @method initializeStoreInjections - @param {Ember.Container} container - */ - __exports__["default"] = function initializeDebugAdapter(container){ - container.register('data-adapter:main', DebugAdapter); - }; - }); -enifed("ember-data/initializers/store", - ["ember-data/serializers","ember-data/adapters","ember-data/system/container_proxy","ember-data/system/store","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) { - "use strict"; - var JSONSerializer = __dependency1__.JSONSerializer; - var RESTSerializer = __dependency1__.RESTSerializer; - var RESTAdapter = __dependency2__.RESTAdapter; - var ContainerProxy = __dependency3__["default"]; - var Store = __dependency4__["default"]; - - /** - Configures a container for use with an Ember-Data - store. Accepts an optional namespace argument. - - @method initializeStore - @param {Ember.Container} container - @param {Object} [application] an application namespace - */ - __exports__["default"] = function initializeStore(container, application){ - Ember.deprecate('Specifying a custom Store for Ember Data on your global namespace as `App.Store` ' + - 'has been deprecated. Please use `App.ApplicationStore` instead.', !(application && application.Store)); - - container.register('store:main', container.lookupFactory('store:application') || (application && application.Store) || Store); - - // allow older names to be looked up - - var proxy = new ContainerProxy(container); - proxy.registerDeprecations([ - { deprecated: 'serializer:_default', valid: 'serializer:-default' }, - { deprecated: 'serializer:_rest', valid: 'serializer:-rest' }, - { deprecated: 'adapter:_rest', valid: 'adapter:-rest' } - ]); - - // new go forward paths - container.register('serializer:-default', JSONSerializer); - container.register('serializer:-rest', RESTSerializer); - container.register('adapter:-rest', RESTAdapter); - - // Eagerly generate the store so defaultStore is populated. - // TODO: Do this in a finisher hook - container.lookup('store:main'); - }; - }); -enifed("ember-data/initializers/store_injections", - ["exports"], - function(__exports__) { - "use strict"; - /** - Configures a container with injections on Ember applications - for the Ember-Data store. Accepts an optional namespace argument. - - @method initializeStoreInjections - @param {Ember.Container} container - */ - __exports__["default"] = function initializeStoreInjections(container){ - container.injection('controller', 'store', 'store:main'); - container.injection('route', 'store', 'store:main'); - container.injection('serializer', 'store', 'store:main'); - container.injection('data-adapter', 'store', 'store:main'); - }; - }); -enifed("ember-data/initializers/transforms", - ["ember-data/transforms","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var BooleanTransform = __dependency1__.BooleanTransform; - var DateTransform = __dependency1__.DateTransform; - var StringTransform = __dependency1__.StringTransform; - var NumberTransform = __dependency1__.NumberTransform; - - /** - Configures a container for use with Ember-Data - transforms. - - @method initializeTransforms - @param {Ember.Container} container - */ - __exports__["default"] = function initializeTransforms(container){ - container.register('transform:boolean', BooleanTransform); - container.register('transform:date', DateTransform); - container.register('transform:number', NumberTransform); - container.register('transform:string', StringTransform); - }; - }); -enifed("ember-data/serializers", - ["ember-data/serializers/json_serializer","ember-data/serializers/rest_serializer","exports"], - function(__dependency1__, __dependency2__, __exports__) { - "use strict"; - var JSONSerializer = __dependency1__["default"]; - var RESTSerializer = __dependency2__["default"]; - - __exports__.JSONSerializer = JSONSerializer; - __exports__.RESTSerializer = RESTSerializer; - }); -enifed("ember-data/serializers/embedded_records_mixin", - ["exports"], - function(__exports__) { - "use strict"; - var get = Ember.get; - var forEach = Ember.EnumerableUtils.forEach; - var camelize = Ember.String.camelize; - - /** - ## Using Embedded Records - - `DS.EmbeddedRecordsMixin` supports serializing embedded records. - - To set up embedded records, include the mixin when extending a serializer - then define and configure embedded (model) relationships. - - Below is an example of a per-type serializer ('post' type). - - ```js - App.PostSerializer = DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, { - attrs: { - author: { embedded: 'always' }, - comments: { serialize: 'ids' } - } - }); - ``` - Note that this use of `{ embedded: 'always' }` is unrelated to - the `{ embedded: 'always' }` that is defined as an option on `DS.attr` as part of - defining a model while working with the ActiveModelSerializer. Nevertheless, - using `{ embedded: 'always' }` as an option to DS.attr is not a valid way to setup - embedded records. - - The `attrs` option for a resource `{ embedded: 'always' }` is shorthand for: - - ```js - { - serialize: 'records', - deserialize: 'records' - } - ``` - - ### Configuring Attrs - - A resource's `attrs` option may be set to use `ids`, `records` or false for the - `serialize` and `deserialize` settings. - - The `attrs` property can be set on the ApplicationSerializer or a per-type - serializer. - - In the case where embedded JSON is expected while extracting a payload (reading) - the setting is `deserialize: 'records'`, there is no need to use `ids` when - extracting as that is the default behavior without this mixin if you are using - the vanilla EmbeddedRecordsMixin. Likewise, to embed JSON in the payload while - serializing `serialize: 'records'` is the setting to use. There is an option of - not embedding JSON in the serialized payload by using `serialize: 'ids'`. If you - do not want the relationship sent at all, you can use `serialize: false`. - - - ### EmbeddedRecordsMixin defaults - If you do not overwrite `attrs` for a specific relationship, the `EmbeddedRecordsMixin` - will behave in the following way: - - BelongsTo: `{ serialize: 'id', deserialize: 'id' }` - HasMany: `{ serialize: false, deserialize: 'ids' }` - - ### Model Relationships - - Embedded records must have a model defined to be extracted and serialized. Note that - when defining any relationships on your model such as `belongsTo` and `hasMany`, you - should not both specify `async:true` and also indicate through the serializer's - `attrs` attribute that the related model should be embedded. If a model is - declared embedded, then do not use `async:true`. - - To successfully extract and serialize embedded records the model relationships - must be setup correcty See the - [defining relationships](/guides/models/defining-models/#toc_defining-relationships) - section of the **Defining Models** guide page. - - Records without an `id` property are not considered embedded records, model - instances must have an `id` property to be used with Ember Data. - - ### Example JSON payloads, Models and Serializers - - **When customizing a serializer it is important to grok what the customizations - are. Please read the docs for the methods this mixin provides, in case you need - to modify it to fit your specific needs.** - - For example review the docs for each method of this mixin: - * [normalize](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_normalize) - * [serializeBelongsTo](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_serializeBelongsTo) - * [serializeHasMany](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_serializeHasMany) - - @class EmbeddedRecordsMixin - @namespace DS - */ - var EmbeddedRecordsMixin = Ember.Mixin.create({ - - /** - Normalize the record and recursively normalize/extract all the embedded records - while pushing them into the store as they are encountered - - A payload with an attr configured for embedded records needs to be extracted: - - ```js - { - "post": { - "id": "1" - "title": "Rails is omakase", - "comments": [{ - "id": "1", - "body": "Rails is unagi" - }, { - "id": "2", - "body": "Omakase O_o" - }] - } - } - ``` - @method normalize - @param {subclass of DS.Model} type - @param {Object} hash to be normalized - @param {String} key the hash has been referenced by - @return {Object} the normalized hash - **/ - normalize: function(type, hash, prop) { - var normalizedHash = this._super(type, hash, prop); - return extractEmbeddedRecords(this, this.store, type, normalizedHash); - }, - - keyForRelationship: function(key, type){ - if (this.hasDeserializeRecordsOption(key)) { - return this.keyForAttribute(key); - } else { - return this._super(key, type) || key; - } - }, - - /** - Serialize `belongsTo` relationship when it is configured as an embedded object. - - This example of an author model belongs to a post model: - - ```js - Post = DS.Model.extend({ - title: DS.attr('string'), - body: DS.attr('string'), - author: DS.belongsTo('author') - }); - - Author = DS.Model.extend({ - name: DS.attr('string'), - post: DS.belongsTo('post') - }); - ``` - - Use a custom (type) serializer for the post model to configure embedded author - - ```js - App.PostSerializer = DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, { - attrs: { - author: {embedded: 'always'} - } - }) - ``` - - A payload with an attribute configured for embedded records can serialize - the records together under the root attribute's payload: - - ```js - { - "post": { - "id": "1" - "title": "Rails is omakase", - "author": { - "id": "2" - "name": "dhh" - } - } - } - ``` - - @method serializeBelongsTo - @param {DS.Model} record - @param {Object} json - @param {Object} relationship - */ - serializeBelongsTo: function(record, json, relationship) { - var attr = relationship.key; - if (this.noSerializeOptionSpecified(attr)) { - this._super(record, json, relationship); - return; - } - var includeIds = this.hasSerializeIdsOption(attr); - var includeRecords = this.hasSerializeRecordsOption(attr); - var embeddedRecord = record.get(attr); - var key; - if (includeIds) { - key = this.keyForRelationship(attr, relationship.kind); - if (!embeddedRecord) { - json[key] = null; - } else { - json[key] = get(embeddedRecord, 'id'); - } - } else if (includeRecords) { - key = this.keyForAttribute(attr); - if (!embeddedRecord) { - json[key] = null; - } else { - json[key] = embeddedRecord.serialize({includeId: true}); - this.removeEmbeddedForeignKey(record, embeddedRecord, relationship, json[key]); - } - } - }, - - /** - Serialize `hasMany` relationship when it is configured as embedded objects. - - This example of a post model has many comments: - - ```js - Post = DS.Model.extend({ - title: DS.attr('string'), - body: DS.attr('string'), - comments: DS.hasMany('comment') - }); - - Comment = DS.Model.extend({ - body: DS.attr('string'), - post: DS.belongsTo('post') - }); - ``` - - Use a custom (type) serializer for the post model to configure embedded comments - - ```js - App.PostSerializer = DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, { - attrs: { - comments: {embedded: 'always'} - } - }) - ``` - - A payload with an attribute configured for embedded records can serialize - the records together under the root attribute's payload: - - ```js - { - "post": { - "id": "1" - "title": "Rails is omakase", - "body": "I want this for my ORM, I want that for my template language..." - "comments": [{ - "id": "1", - "body": "Rails is unagi" - }, { - "id": "2", - "body": "Omakase O_o" - }] - } - } - ``` - - The attrs options object can use more specific instruction for extracting and - serializing. When serializing, an option to embed `ids` or `records` can be set. - When extracting the only option is `records`. - - So `{embedded: 'always'}` is shorthand for: - `{serialize: 'records', deserialize: 'records'}` - - To embed the `ids` for a related object (using a hasMany relationship): - - ```js - App.PostSerializer = DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, { - attrs: { - comments: {serialize: 'ids', deserialize: 'records'} - } - }) - ``` - - ```js - { - "post": { - "id": "1" - "title": "Rails is omakase", - "body": "I want this for my ORM, I want that for my template language..." - "comments": ["1", "2"] - } - } - ``` - - @method serializeHasMany - @param {DS.Model} record - @param {Object} json - @param {Object} relationship - */ - serializeHasMany: function(record, json, relationship) { - var attr = relationship.key; - if (this.noSerializeOptionSpecified(attr)) { - this._super(record, json, relationship); - return; - } - var includeIds = this.hasSerializeIdsOption(attr); - var includeRecords = this.hasSerializeRecordsOption(attr); - var key; - if (includeIds) { - key = this.keyForRelationship(attr, relationship.kind); - json[key] = get(record, attr).mapBy('id'); - } else if (includeRecords) { - key = this.keyForAttribute(attr); - json[key] = get(record, attr).map(function(embeddedRecord) { - var serializedEmbeddedRecord = embeddedRecord.serialize({includeId: true}); - this.removeEmbeddedForeignKey(record, embeddedRecord, relationship, serializedEmbeddedRecord); - return serializedEmbeddedRecord; - }, this); - } - }, - - /** - When serializing an embedded record, modify the property (in the json payload) - that refers to the parent record (foreign key for relationship). - - Serializing a `belongsTo` relationship removes the property that refers to the - parent record - - Serializing a `hasMany` relationship does not remove the property that refers to - the parent record. - - @method removeEmbeddedForeignKey - @param {DS.Model} record - @param {DS.Model} embeddedRecord - @param {Object} relationship - @param {Object} json - */ - removeEmbeddedForeignKey: function (record, embeddedRecord, relationship, json) { - if (relationship.kind === 'hasMany') { - return; - } else if (relationship.kind === 'belongsTo') { - var parentRecord = record.constructor.inverseFor(relationship.key); - if (parentRecord) { - var name = parentRecord.name; - var embeddedSerializer = this.store.serializerFor(embeddedRecord.constructor); - var parentKey = embeddedSerializer.keyForRelationship(name, parentRecord.kind); - if (parentKey) { - delete json[parentKey]; - } - } - } - }, - - // checks config for attrs option to embedded (always) - serialize and deserialize - hasEmbeddedAlwaysOption: function (attr) { - var option = this.attrsOption(attr); - return option && option.embedded === 'always'; - }, - - // checks config for attrs option to serialize ids - hasSerializeRecordsOption: function(attr) { - var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr); - var option = this.attrsOption(attr); - return alwaysEmbed || (option && (option.serialize === 'records')); - }, - - // checks config for attrs option to serialize records - hasSerializeIdsOption: function(attr) { - var option = this.attrsOption(attr); - return option && (option.serialize === 'ids' || option.serialize === 'id'); - }, - - // checks config for attrs option to serialize records - noSerializeOptionSpecified: function(attr) { - var option = this.attrsOption(attr); - return !(option && (option.serialize || option.embedded)); - }, - - // checks config for attrs option to deserialize records - // a defined option object for a resource is treated the same as - // `deserialize: 'records'` - hasDeserializeRecordsOption: function(attr) { - var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr); - var option = this.attrsOption(attr); - return alwaysEmbed || (option && option.deserialize === 'records'); - }, - - attrsOption: function(attr) { - var attrs = this.get('attrs'); - return attrs && (attrs[camelize(attr)] || attrs[attr]); - } - }); - - // chooses a relationship kind to branch which function is used to update payload - // does not change payload if attr is not embedded - function extractEmbeddedRecords(serializer, store, type, partial) { - - type.eachRelationship(function(key, relationship) { - if (serializer.hasDeserializeRecordsOption(key)) { - var embeddedType = store.modelFor(relationship.type.typeKey); - if (relationship.kind === "hasMany") { - if (relationship.options.polymorphic) { - extractEmbeddedHasManyPolymorphic(store, key, partial); - } - else { - extractEmbeddedHasMany(store, key, embeddedType, partial); - } - } - if (relationship.kind === "belongsTo") { - extractEmbeddedBelongsTo(store, key, embeddedType, partial); - } - } - }); - - return partial; - } - - // handles embedding for `hasMany` relationship - function extractEmbeddedHasMany(store, key, embeddedType, hash) { - if (!hash[key]) { - return hash; - } - - var ids = []; - - var embeddedSerializer = store.serializerFor(embeddedType.typeKey); - forEach(hash[key], function(data) { - var embeddedRecord = embeddedSerializer.normalize(embeddedType, data, null); - store.push(embeddedType, embeddedRecord); - ids.push(embeddedRecord.id); - }); - - hash[key] = ids; - return hash; - } - - function extractEmbeddedHasManyPolymorphic(store, key, hash) { - if (!hash[key]) { - return hash; - } - - var ids = []; - - forEach(hash[key], function(data) { - var typeKey = data.type; - var embeddedSerializer = store.serializerFor(typeKey); - var embeddedType = store.modelFor(typeKey); - var primaryKey = get(embeddedSerializer, 'primaryKey'); - - var embeddedRecord = embeddedSerializer.normalize(embeddedType, data, null); - store.push(embeddedType, embeddedRecord); - ids.push({ id: embeddedRecord[primaryKey], type: typeKey }); - }); - - hash[key] = ids; - return hash; - } - - function extractEmbeddedBelongsTo(store, key, embeddedType, hash) { - if (!hash[key]) { - return hash; - } - - var embeddedSerializer = store.serializerFor(embeddedType.typeKey); - var embeddedRecord = embeddedSerializer.normalize(embeddedType, hash[key], null); - store.push(embeddedType, embeddedRecord); - - hash[key] = embeddedRecord.id; - //TODO Need to add a reference to the parent later so relationship works between both `belongsTo` records - return hash; - } - - __exports__["default"] = EmbeddedRecordsMixin; - }); -enifed("ember-data/serializers/json_serializer", - ["exports"], - function(__exports__) { - "use strict"; - var get = Ember.get; - var isNone = Ember.isNone; - var map = Ember.ArrayPolyfills.map; - var merge = Ember.merge; - - /** - In Ember Data a Serializer is used to serialize and deserialize - records when they are transferred in and out of an external source. - This process involves normalizing property names, transforming - attribute values and serializing relationships. - - For maximum performance Ember Data recommends you use the - [RESTSerializer](DS.RESTSerializer.html) or one of its subclasses. - - `JSONSerializer` is useful for simpler or legacy backends that may - not support the http://jsonapi.org/ spec. - - @class JSONSerializer - @namespace DS - */ - __exports__["default"] = Ember.Object.extend({ - /** - The primaryKey is used when serializing and deserializing - data. Ember Data always uses the `id` property to store the id of - the record. The external source may not always follow this - convention. In these cases it is useful to override the - primaryKey property to match the primaryKey of your external - store. - - Example - - ```javascript - App.ApplicationSerializer = DS.JSONSerializer.extend({ - primaryKey: '_id' - }); - ``` - - @property primaryKey - @type {String} - @default 'id' - */ - primaryKey: 'id', - - /** - The `attrs` object can be used to declare a simple mapping between - property names on `DS.Model` records and payload keys in the - serialized JSON object representing the record. An object with the - property `key` can also be used to designate the attribute's key on - the response payload. - - Example - - ```javascript - App.Person = DS.Model.extend({ - firstName: DS.attr('string'), - lastName: DS.attr('string'), - occupation: DS.attr('string'), - admin: DS.attr('boolean') - }); - - App.PersonSerializer = DS.JSONSerializer.extend({ - attrs: { - admin: 'is_admin', - occupation: {key: 'career'} - } - }); - ``` - - You can also remove attributes by setting the `serialize` key to - false in your mapping object. - - Example - - ```javascript - App.PersonSerializer = DS.JSONSerializer.extend({ - attrs: { - admin: {serialize: false}, - occupation: {key: 'career'} - } - }); - ``` - - When serialized: - - ```javascript - { - "career": "magician" - } - ``` - - Note that the `admin` is now not included in the payload. - - @property attrs - @type {Object} - */ - - /** - Given a subclass of `DS.Model` and a JSON object this method will - iterate through each attribute of the `DS.Model` and invoke the - `DS.Transform#deserialize` method on the matching property of the - JSON object. This method is typically called after the - serializer's `normalize` method. - - @method applyTransforms - @private - @param {subclass of DS.Model} type - @param {Object} data The data to transform - @return {Object} data The transformed data object - */ - applyTransforms: function(type, data) { - type.eachTransformedAttribute(function applyTransform(key, type) { - if (!data.hasOwnProperty(key)) { return; } - - var transform = this.transformFor(type); - data[key] = transform.deserialize(data[key]); - }, this); - - return data; - }, - - /** - Normalizes a part of the JSON payload returned by - the server. You should override this method, munge the hash - and call super if you have generic normalization to do. - - It takes the type of the record that is being normalized - (as a DS.Model class), the property where the hash was - originally found, and the hash to normalize. - - You can use this method, for example, to normalize underscored keys to camelized - or other general-purpose normalizations. - - Example - - ```javascript - App.ApplicationSerializer = DS.JSONSerializer.extend({ - normalize: function(type, hash) { - var fields = Ember.get(type, 'fields'); - fields.forEach(function(field) { - var payloadField = Ember.String.underscore(field); - if (field === payloadField) { return; } - - hash[field] = hash[payloadField]; - delete hash[payloadField]; - }); - return this._super.apply(this, arguments); - } - }); - ``` - - @method normalize - @param {subclass of DS.Model} type - @param {Object} hash - @return {Object} - */ - normalize: function(type, hash) { - if (!hash) { return hash; } - - this.normalizeId(hash); - this.normalizeAttributes(type, hash); - this.normalizeRelationships(type, hash); - - this.normalizeUsingDeclaredMapping(type, hash); - this.applyTransforms(type, hash); - return hash; - }, - - /** - You can use this method to normalize all payloads, regardless of whether they - represent single records or an array. - - For example, you might want to remove some extraneous data from the payload: - - ```js - App.ApplicationSerializer = DS.JSONSerializer.extend({ - normalizePayload: function(payload) { - delete payload.version; - delete payload.status; - return payload; - } - }); - ``` - - @method normalizePayload - @param {Object} payload - @return {Object} the normalized payload - */ - normalizePayload: function(payload) { - return payload; - }, - - /** - @method normalizeAttributes - @private - */ - normalizeAttributes: function(type, hash) { - var payloadKey; - - if (this.keyForAttribute) { - type.eachAttribute(function(key) { - payloadKey = this.keyForAttribute(key); - if (key === payloadKey) { return; } - if (!hash.hasOwnProperty(payloadKey)) { return; } - - hash[key] = hash[payloadKey]; - delete hash[payloadKey]; - }, this); - } - }, - - /** - @method normalizeRelationships - @private - */ - normalizeRelationships: function(type, hash) { - var payloadKey; - - if (this.keyForRelationship) { - type.eachRelationship(function(key, relationship) { - payloadKey = this.keyForRelationship(key, relationship.kind); - if (key === payloadKey) { return; } - if (!hash.hasOwnProperty(payloadKey)) { return; } - - hash[key] = hash[payloadKey]; - delete hash[payloadKey]; - }, this); - } - }, - - /** - @method normalizeUsingDeclaredMapping - @private - */ - normalizeUsingDeclaredMapping: function(type, hash) { - var attrs = get(this, 'attrs'), payloadKey, key; - - if (attrs) { - for (key in attrs) { - payloadKey = this._getMappedKey(key); - if (!hash.hasOwnProperty(payloadKey)) { continue; } - - if (payloadKey !== key) { - hash[key] = hash[payloadKey]; - delete hash[payloadKey]; - } - } - } - }, - - /** - @method normalizeId - @private - */ - normalizeId: function(hash) { - var primaryKey = get(this, 'primaryKey'); - - if (primaryKey === 'id') { return; } - - hash.id = hash[primaryKey]; - delete hash[primaryKey]; - }, - - /** - @method normalizeErrors - @private - */ - normalizeErrors: function(type, hash) { - this.normalizeId(hash); - this.normalizeAttributes(type, hash); - this.normalizeRelationships(type, hash); - }, - - /** - Looks up the property key that was set by the custom `attr` mapping - passed to the serializer. - - @method _getMappedKey - @private - @param {String} key - @return {String} key - */ - _getMappedKey: function(key) { - var attrs = get(this, 'attrs'); - var mappedKey; - if (attrs && attrs[key]) { - mappedKey = attrs[key]; - //We need to account for both the {title: 'post_title'} and - //{title: {key: 'post_title'}} forms - if (mappedKey.key){ - mappedKey = mappedKey.key; - } - if (typeof mappedKey === 'string'){ - key = mappedKey; - } - } - - return key; - }, - - /** - Check attrs.key.serialize property to inform if the `key` - can be serialized - - @method _canSerialize - @private - @param {String} key - @return {boolean} true if the key can be serialized - */ - _canSerialize: function(key) { - var attrs = get(this, 'attrs'); - - return !attrs || !attrs[key] || attrs[key].serialize !== false; - }, - - // SERIALIZE - /** - Called when a record is saved in order to convert the - record into JSON. - - By default, it creates a JSON object with a key for - each attribute and belongsTo relationship. - - For example, consider this model: - - ```javascript - App.Comment = DS.Model.extend({ - title: DS.attr(), - body: DS.attr(), - - author: DS.belongsTo('user') - }); - ``` - - The default serialization would create a JSON object like: - - ```javascript - { - "title": "Rails is unagi", - "body": "Rails? Omakase? O_O", - "author": 12 - } - ``` - - By default, attributes are passed through as-is, unless - you specified an attribute type (`DS.attr('date')`). If - you specify a transform, the JavaScript value will be - serialized when inserted into the JSON hash. - - By default, belongs-to relationships are converted into - IDs when inserted into the JSON hash. - - ## IDs - - `serialize` takes an options hash with a single option: - `includeId`. If this option is `true`, `serialize` will, - by default include the ID in the JSON object it builds. - - The adapter passes in `includeId: true` when serializing - a record for `createRecord`, but not for `updateRecord`. - - ## Customization - - Your server may expect a different JSON format than the - built-in serialization format. - - In that case, you can implement `serialize` yourself and - return a JSON hash of your choosing. - - ```javascript - App.PostSerializer = DS.JSONSerializer.extend({ - serialize: function(post, options) { - var json = { - POST_TTL: post.get('title'), - POST_BDY: post.get('body'), - POST_CMS: post.get('comments').mapBy('id') - } - - if (options.includeId) { - json.POST_ID_ = post.get('id'); - } - - return json; - } - }); - ``` - - ## Customizing an App-Wide Serializer - - If you want to define a serializer for your entire - application, you'll probably want to use `eachAttribute` - and `eachRelationship` on the record. - - ```javascript - App.ApplicationSerializer = DS.JSONSerializer.extend({ - serialize: function(record, options) { - var json = {}; - - record.eachAttribute(function(name) { - json[serverAttributeName(name)] = record.get(name); - }) - - record.eachRelationship(function(name, relationship) { - if (relationship.kind === 'hasMany') { - json[serverHasManyName(name)] = record.get(name).mapBy('id'); - } - }); - - if (options.includeId) { - json.ID_ = record.get('id'); - } - - return json; - } - }); - - function serverAttributeName(attribute) { - return attribute.underscore().toUpperCase(); - } - - function serverHasManyName(name) { - return serverAttributeName(name.singularize()) + "_IDS"; - } - ``` - - This serializer will generate JSON that looks like this: - - ```javascript - { - "TITLE": "Rails is omakase", - "BODY": "Yep. Omakase.", - "COMMENT_IDS": [ 1, 2, 3 ] - } - ``` - - ## Tweaking the Default JSON - - If you just want to do some small tweaks on the default JSON, - you can call super first and make the tweaks on the returned - JSON. - - ```javascript - App.PostSerializer = DS.JSONSerializer.extend({ - serialize: function(record, options) { - var json = this._super.apply(this, arguments); - - json.subject = json.title; - delete json.title; - - return json; - } - }); - ``` - - @method serialize - @param {subclass of DS.Model} record - @param {Object} options - @return {Object} json - */ - serialize: function(record, options) { - var json = {}; - - if (options && options.includeId) { - var id = get(record, 'id'); - - if (id) { - json[get(this, 'primaryKey')] = id; - } - } - - record.eachAttribute(function(key, attribute) { - this.serializeAttribute(record, json, key, attribute); - }, this); - - record.eachRelationship(function(key, relationship) { - if (relationship.kind === 'belongsTo') { - this.serializeBelongsTo(record, json, relationship); - } else if (relationship.kind === 'hasMany') { - this.serializeHasMany(record, json, relationship); - } - }, this); - - return json; - }, - - /** - You can use this method to customize how a serialized record is added to the complete - JSON hash to be sent to the server. By default the JSON Serializer does not namespace - the payload and just sends the raw serialized JSON object. - If your server expects namespaced keys, you should consider using the RESTSerializer. - Otherwise you can override this method to customize how the record is added to the hash. - - For example, your server may expect underscored root objects. - - ```js - App.ApplicationSerializer = DS.RESTSerializer.extend({ - serializeIntoHash: function(data, type, record, options) { - var root = Ember.String.decamelize(type.typeKey); - data[root] = this.serialize(record, options); - } - }); - ``` - - @method serializeIntoHash - @param {Object} hash - @param {subclass of DS.Model} type - @param {DS.Model} record - @param {Object} options - */ - serializeIntoHash: function(hash, type, record, options) { - merge(hash, this.serialize(record, options)); - }, - - /** - `serializeAttribute` can be used to customize how `DS.attr` - properties are serialized - - For example if you wanted to ensure all your attributes were always - serialized as properties on an `attributes` object you could - write: - - ```javascript - App.ApplicationSerializer = DS.JSONSerializer.extend({ - serializeAttribute: function(record, json, key, attributes) { - json.attributes = json.attributes || {}; - this._super(record, json.attributes, key, attributes); - } - }); - ``` - - @method serializeAttribute - @param {DS.Model} record - @param {Object} json - @param {String} key - @param {Object} attribute - */ - serializeAttribute: function(record, json, key, attribute) { - var type = attribute.type; - - if (this._canSerialize(key)) { - var value = get(record, key); - if (type) { - var transform = this.transformFor(type); - value = transform.serialize(value); - } - - // if provided, use the mapping provided by `attrs` in - // the serializer - var payloadKey = this._getMappedKey(key); - - if (payloadKey === key && this.keyForAttribute) { - payloadKey = this.keyForAttribute(key); - } - - json[payloadKey] = value; - } - }, - - /** - `serializeBelongsTo` can be used to customize how `DS.belongsTo` - properties are serialized. - - Example - - ```javascript - App.PostSerializer = DS.JSONSerializer.extend({ - serializeBelongsTo: function(record, json, relationship) { - var key = relationship.key; - - var belongsTo = get(record, key); - - key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo") : key; - - json[key] = Ember.isNone(belongsTo) ? belongsTo : belongsTo.toJSON(); - } - }); - ``` - - @method serializeBelongsTo - @param {DS.Model} record - @param {Object} json - @param {Object} relationship - */ - serializeBelongsTo: function(record, json, relationship) { - var key = relationship.key; - - if (this._canSerialize(key)) { - var belongsTo = get(record, key); - - // if provided, use the mapping provided by `attrs` in - // the serializer - var payloadKey = this._getMappedKey(key); - if (payloadKey === key && this.keyForRelationship) { - payloadKey = this.keyForRelationship(key, "belongsTo"); - } - - //Need to check whether the id is there for new&async records - if (isNone(belongsTo) || isNone(get(belongsTo, 'id'))) { - json[payloadKey] = null; - } else { - json[payloadKey] = get(belongsTo, 'id'); - } - - if (relationship.options.polymorphic) { - this.serializePolymorphicType(record, json, relationship); - } - } - }, - - /** - `serializeHasMany` can be used to customize how `DS.hasMany` - properties are serialized. - - Example - - ```javascript - App.PostSerializer = DS.JSONSerializer.extend({ - serializeHasMany: function(record, json, relationship) { - var key = relationship.key; - if (key === 'comments') { - return; - } else { - this._super.apply(this, arguments); - } - } - }); - ``` - - @method serializeHasMany - @param {DS.Model} record - @param {Object} json - @param {Object} relationship - */ - serializeHasMany: function(record, json, relationship) { - var key = relationship.key; - - if (this._canSerialize(key)) { - var payloadKey; - - // if provided, use the mapping provided by `attrs` in - // the serializer - payloadKey = this._getMappedKey(key); - if (payloadKey === key && this.keyForRelationship) { - payloadKey = this.keyForRelationship(key, "hasMany"); - } - - var relationshipType = record.constructor.determineRelationshipType(relationship); - - if (relationshipType === 'manyToNone' || relationshipType === 'manyToMany') { - json[payloadKey] = get(record, key).mapBy('id'); - // TODO support for polymorphic manyToNone and manyToMany relationships - } - } - }, - - /** - You can use this method to customize how polymorphic objects are - serialized. Objects are considered to be polymorphic if - `{polymorphic: true}` is pass as the second argument to the - `DS.belongsTo` function. - - Example - - ```javascript - App.CommentSerializer = DS.JSONSerializer.extend({ - serializePolymorphicType: function(record, json, relationship) { - var key = relationship.key, - belongsTo = get(record, key); - key = this.keyForAttribute ? this.keyForAttribute(key) : key; - - if (Ember.isNone(belongsTo)) { - json[key + "_type"] = null; - } else { - json[key + "_type"] = belongsTo.constructor.typeKey; - } - } - }); - ``` - - @method serializePolymorphicType - @param {DS.Model} record - @param {Object} json - @param {Object} relationship - */ - serializePolymorphicType: Ember.K, - - // EXTRACT - - /** - The `extract` method is used to deserialize payload data from the - server. By default the `JSONSerializer` does not push the records - into the store. However records that subclass `JSONSerializer` - such as the `RESTSerializer` may push records into the store as - part of the extract call. - - This method delegates to a more specific extract method based on - the `requestType`. - - Example - - ```javascript - var get = Ember.get; - socket.on('message', function(message) { - var modelName = message.model; - var data = message.data; - var type = store.modelFor(modelName); - var serializer = store.serializerFor(type.typeKey); - var record = serializer.extract(store, type, data, get(data, 'id'), 'single'); - store.push(modelName, record); - }); - ``` - - @method extract - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Object} json The deserialized payload - */ - extract: function(store, type, payload, id, requestType) { - this.extractMeta(store, type, payload); - - var specificExtract = "extract" + requestType.charAt(0).toUpperCase() + requestType.substr(1); - return this[specificExtract](store, type, payload, id, requestType); - }, - - /** - `extractFindAll` is a hook into the extract method used when a - call is made to `DS.Store#findAll`. By default this method is an - alias for [extractArray](#method_extractArray). - - @method extractFindAll - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Array} array An array of deserialized objects - */ - extractFindAll: function(store, type, payload, id, requestType){ - return this.extractArray(store, type, payload, id, requestType); - }, - /** - `extractFindQuery` is a hook into the extract method used when a - call is made to `DS.Store#findQuery`. By default this method is an - alias for [extractArray](#method_extractArray). - - @method extractFindQuery - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Array} array An array of deserialized objects - */ - extractFindQuery: function(store, type, payload, id, requestType){ - return this.extractArray(store, type, payload, id, requestType); - }, - /** - `extractFindMany` is a hook into the extract method used when a - call is made to `DS.Store#findMany`. By default this method is - alias for [extractArray](#method_extractArray). - - @method extractFindMany - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Array} array An array of deserialized objects - */ - extractFindMany: function(store, type, payload, id, requestType){ - return this.extractArray(store, type, payload, id, requestType); - }, - /** - `extractFindHasMany` is a hook into the extract method used when a - call is made to `DS.Store#findHasMany`. By default this method is - alias for [extractArray](#method_extractArray). - - @method extractFindHasMany - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Array} array An array of deserialized objects - */ - extractFindHasMany: function(store, type, payload, id, requestType){ - return this.extractArray(store, type, payload, id, requestType); - }, - - /** - `extractCreateRecord` is a hook into the extract method used when a - call is made to `DS.Store#createRecord`. By default this method is - alias for [extractSave](#method_extractSave). - - @method extractCreateRecord - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Object} json The deserialized payload - */ - extractCreateRecord: function(store, type, payload, id, requestType) { - return this.extractSave(store, type, payload, id, requestType); - }, - /** - `extractUpdateRecord` is a hook into the extract method used when - a call is made to `DS.Store#update`. By default this method is alias - for [extractSave](#method_extractSave). - - @method extractUpdateRecord - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Object} json The deserialized payload - */ - extractUpdateRecord: function(store, type, payload, id, requestType) { - return this.extractSave(store, type, payload, id, requestType); - }, - /** - `extractDeleteRecord` is a hook into the extract method used when - a call is made to `DS.Store#deleteRecord`. By default this method is - alias for [extractSave](#method_extractSave). - - @method extractDeleteRecord - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Object} json The deserialized payload - */ - extractDeleteRecord: function(store, type, payload, id, requestType) { - return this.extractSave(store, type, payload, id, requestType); - }, - - /** - `extractFind` is a hook into the extract method used when - a call is made to `DS.Store#find`. By default this method is - alias for [extractSingle](#method_extractSingle). - - @method extractFind - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Object} json The deserialized payload - */ - extractFind: function(store, type, payload, id, requestType) { - return this.extractSingle(store, type, payload, id, requestType); - }, - /** - `extractFindBelongsTo` is a hook into the extract method used when - a call is made to `DS.Store#findBelongsTo`. By default this method is - alias for [extractSingle](#method_extractSingle). - - @method extractFindBelongsTo - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Object} json The deserialized payload - */ - extractFindBelongsTo: function(store, type, payload, id, requestType) { - return this.extractSingle(store, type, payload, id, requestType); - }, - /** - `extractSave` is a hook into the extract method used when a call - is made to `DS.Model#save`. By default this method is alias - for [extractSingle](#method_extractSingle). - - @method extractSave - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Object} json The deserialized payload - */ - extractSave: function(store, type, payload, id, requestType) { - return this.extractSingle(store, type, payload, id, requestType); - }, - - /** - `extractSingle` is used to deserialize a single record returned - from the adapter. - - Example - - ```javascript - App.PostSerializer = DS.JSONSerializer.extend({ - extractSingle: function(store, type, payload) { - payload.comments = payload._embedded.comment; - delete payload._embedded; - - return this._super(store, type, payload); - }, - }); - ``` - - @method extractSingle - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Object} json The deserialized payload - */ - extractSingle: function(store, type, payload, id, requestType) { - payload = this.normalizePayload(payload); - return this.normalize(type, payload); - }, - - /** - `extractArray` is used to deserialize an array of records - returned from the adapter. - - Example - - ```javascript - App.PostSerializer = DS.JSONSerializer.extend({ - extractArray: function(store, type, payload) { - return payload.map(function(json) { - return this.extractSingle(store, type, json); - }, this); - } - }); - ``` - - @method extractArray - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @param {String} requestType - @return {Array} array An array of deserialized objects - */ - extractArray: function(store, type, arrayPayload, id, requestType) { - var normalizedPayload = this.normalizePayload(arrayPayload); - var serializer = this; - - return map.call(normalizedPayload, function(singlePayload) { - return serializer.normalize(type, singlePayload); - }); - }, - - /** - `extractMeta` is used to deserialize any meta information in the - adapter payload. By default Ember Data expects meta information to - be located on the `meta` property of the payload object. - - Example - - ```javascript - App.PostSerializer = DS.JSONSerializer.extend({ - extractMeta: function(store, type, payload) { - if (payload && payload._pagination) { - store.metaForType(type, payload._pagination); - delete payload._pagination; - } - } - }); - ``` - - @method extractMeta - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - */ - extractMeta: function(store, type, payload) { - if (payload && payload.meta) { - store.metaForType(type, payload.meta); - delete payload.meta; - } - }, - - /** - `extractErrors` is used to extract model errors when a call is made - to `DS.Model#save` which fails with an InvalidError`. By default - Ember Data expects error information to be located on the `errors` - property of the payload object. - - Example - - ```javascript - App.PostSerializer = DS.JSONSerializer.extend({ - extractErrors: function(store, type, payload, id) { - if (payload && typeof payload === 'object' && payload._problems) { - payload = payload._problems; - this.normalizeErrors(type, payload); - } - return payload; - } - }); - ``` - - @method extractErrors - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} payload - @param {String or Number} id - @return {Object} json The deserialized errors - */ - extractErrors: function(store, type, payload, id) { - if (payload && typeof payload === 'object' && payload.errors) { - payload = payload.errors; - this.normalizeErrors(type, payload); - } - return payload; - }, - - /** - `keyForAttribute` can be used to define rules for how to convert an - attribute name in your model to a key in your JSON. - - Example - - ```javascript - App.ApplicationSerializer = DS.RESTSerializer.extend({ - keyForAttribute: function(attr) { - return Ember.String.underscore(attr).toUpperCase(); - } - }); - ``` - - @method keyForAttribute - @param {String} key - @return {String} normalized key - */ - keyForAttribute: function(key){ - return key; - }, - - /** - `keyForRelationship` can be used to define a custom key when - serializing relationship properties. By default `JSONSerializer` - does not provide an implementation of this method. - - Example - - ```javascript - App.PostSerializer = DS.JSONSerializer.extend({ - keyForRelationship: function(key, relationship) { - return 'rel_' + Ember.String.underscore(key); - } - }); - ``` - - @method keyForRelationship - @param {String} key - @param {String} relationship type - @return {String} normalized key - */ - - keyForRelationship: function(key, type){ - return key; - }, - - // HELPERS - - /** - @method transformFor - @private - @param {String} attributeType - @param {Boolean} skipAssertion - @return {DS.Transform} transform - */ - transformFor: function(attributeType, skipAssertion) { - var transform = this.container.lookup('transform:' + attributeType); - Ember.assert("Unable to find transform for '" + attributeType + "'", skipAssertion || !!transform); - return transform; - } - }); - }); -enifed("ember-data/serializers/rest_serializer", - ["ember-data/serializers/json_serializer","ember-inflector/system/string","exports"], - function(__dependency1__, __dependency2__, __exports__) { - "use strict"; - /** - @module ember-data - */ - - var JSONSerializer = __dependency1__["default"]; - var get = Ember.get; - var forEach = Ember.ArrayPolyfills.forEach; - var map = Ember.ArrayPolyfills.map; - var camelize = Ember.String.camelize; - - var singularize = __dependency2__.singularize; - - function coerceId(id) { - return id == null ? null : id + ''; - } - - /** - Normally, applications will use the `RESTSerializer` by implementing - the `normalize` method and individual normalizations under - `normalizeHash`. - - This allows you to do whatever kind of munging you need, and is - especially useful if your server is inconsistent and you need to - do munging differently for many different kinds of responses. - - See the `normalize` documentation for more information. - - ## Across the Board Normalization - - There are also a number of hooks that you might find useful to define - across-the-board rules for your payload. These rules will be useful - if your server is consistent, or if you're building an adapter for - an infrastructure service, like Parse, and want to encode service - conventions. - - For example, if all of your keys are underscored and all-caps, but - otherwise consistent with the names you use in your models, you - can implement across-the-board rules for how to convert an attribute - name in your model to a key in your JSON. - - ```js - App.ApplicationSerializer = DS.RESTSerializer.extend({ - keyForAttribute: function(attr) { - return Ember.String.underscore(attr).toUpperCase(); - } - }); - ``` - - You can also implement `keyForRelationship`, which takes the name - of the relationship as the first parameter, and the kind of - relationship (`hasMany` or `belongsTo`) as the second parameter. - - @class RESTSerializer - @namespace DS - @extends DS.JSONSerializer - */ - var RESTSerializer = JSONSerializer.extend({ - /** - If you want to do normalizations specific to some part of the payload, you - can specify those under `normalizeHash`. - - For example, given the following json where the the `IDs` under - `"comments"` are provided as `_id` instead of `id`. - - ```javascript - { - "post": { - "id": 1, - "title": "Rails is omakase", - "comments": [ 1, 2 ] - }, - "comments": [{ - "_id": 1, - "body": "FIRST" - }, { - "_id": 2, - "body": "Rails is unagi" - }] - } - ``` - - You use `normalizeHash` to normalize just the comments: - - ```javascript - App.PostSerializer = DS.RESTSerializer.extend({ - normalizeHash: { - comments: function(hash) { - hash.id = hash._id; - delete hash._id; - return hash; - } - } - }); - ``` - - The key under `normalizeHash` is usually just the original key - that was in the original payload. However, key names will be - impacted by any modifications done in the `normalizePayload` - method. The `DS.RESTSerializer`'s default implementation makes no - changes to the payload keys. - - @property normalizeHash - @type {Object} - @default undefined - */ - - /** - Normalizes a part of the JSON payload returned by - the server. You should override this method, munge the hash - and call super if you have generic normalization to do. - - It takes the type of the record that is being normalized - (as a DS.Model class), the property where the hash was - originally found, and the hash to normalize. - - For example, if you have a payload that looks like this: - - ```js - { - "post": { - "id": 1, - "title": "Rails is omakase", - "comments": [ 1, 2 ] - }, - "comments": [{ - "id": 1, - "body": "FIRST" - }, { - "id": 2, - "body": "Rails is unagi" - }] - } - ``` - - The `normalize` method will be called three times: - - * With `App.Post`, `"posts"` and `{ id: 1, title: "Rails is omakase", ... }` - * With `App.Comment`, `"comments"` and `{ id: 1, body: "FIRST" }` - * With `App.Comment`, `"comments"` and `{ id: 2, body: "Rails is unagi" }` - - You can use this method, for example, to normalize underscored keys to camelized - or other general-purpose normalizations. - - If you want to do normalizations specific to some part of the payload, you - can specify those under `normalizeHash`. - - For example, if the `IDs` under `"comments"` are provided as `_id` instead of - `id`, you can specify how to normalize just the comments: - - ```js - App.PostSerializer = DS.RESTSerializer.extend({ - normalizeHash: { - comments: function(hash) { - hash.id = hash._id; - delete hash._id; - return hash; - } - } - }); - ``` - - The key under `normalizeHash` is just the original key that was in the original - payload. - - @method normalize - @param {subclass of DS.Model} type - @param {Object} hash - @param {String} prop - @return {Object} - */ - normalize: function(type, hash, prop) { - this.normalizeId(hash); - this.normalizeAttributes(type, hash); - this.normalizeRelationships(type, hash); - - this.normalizeUsingDeclaredMapping(type, hash); - - if (this.normalizeHash && this.normalizeHash[prop]) { - this.normalizeHash[prop](hash); - } - - this.applyTransforms(type, hash); - return hash; - }, - - - /** - Called when the server has returned a payload representing - a single record, such as in response to a `find` or `save`. - - It is your opportunity to clean up the server's response into the normalized - form expected by Ember Data. - - If you want, you can just restructure the top-level of your payload, and - do more fine-grained normalization in the `normalize` method. - - For example, if you have a payload like this in response to a request for - post 1: - - ```js - { - "id": 1, - "title": "Rails is omakase", - - "_embedded": { - "comment": [{ - "_id": 1, - "comment_title": "FIRST" - }, { - "_id": 2, - "comment_title": "Rails is unagi" - }] - } - } - ``` - - You could implement a serializer that looks like this to get your payload - into shape: - - ```js - App.PostSerializer = DS.RESTSerializer.extend({ - // First, restructure the top-level so it's organized by type - extractSingle: function(store, type, payload, id) { - var comments = payload._embedded.comment; - delete payload._embedded; - - payload = { comments: comments, post: payload }; - return this._super(store, type, payload, id); - }, - - normalizeHash: { - // Next, normalize individual comments, which (after `extract`) - // are now located under `comments` - comments: function(hash) { - hash.id = hash._id; - hash.title = hash.comment_title; - delete hash._id; - delete hash.comment_title; - return hash; - } - } - }) - ``` - - When you call super from your own implementation of `extractSingle`, the - built-in implementation will find the primary record in your normalized - payload and push the remaining records into the store. - - The primary record is the single hash found under `post` or the first - element of the `posts` array. - - The primary record has special meaning when the record is being created - for the first time or updated (`createRecord` or `updateRecord`). In - particular, it will update the properties of the record that was saved. - - @method extractSingle - @param {DS.Store} store - @param {subclass of DS.Model} primaryType - @param {Object} payload - @param {String} recordId - @return {Object} the primary response to the original request - */ - extractSingle: function(store, primaryType, rawPayload, recordId) { - var payload = this.normalizePayload(rawPayload); - var primaryTypeName = primaryType.typeKey; - var primaryRecord; - - for (var prop in payload) { - var typeName = this.typeForRoot(prop); - - if (!store.modelFactoryFor(typeName)){ - Ember.warn(this.warnMessageNoModelForKey(prop, typeName), false); - continue; - } - var type = store.modelFor(typeName); - var isPrimary = type.typeKey === primaryTypeName; - var value = payload[prop]; - - if (value === null) { - continue; - } - - // legacy support for singular resources - if (isPrimary && Ember.typeOf(value) !== "array" ) { - primaryRecord = this.normalize(primaryType, value, prop); - continue; - } - - /*jshint loopfunc:true*/ - forEach.call(value, function(hash) { - var typeName = this.typeForRoot(prop); - var type = store.modelFor(typeName); - var typeSerializer = store.serializerFor(type); - - hash = typeSerializer.normalize(type, hash, prop); - - var isFirstCreatedRecord = isPrimary && !recordId && !primaryRecord; - var isUpdatedRecord = isPrimary && coerceId(hash.id) === recordId; - - // find the primary record. - // - // It's either: - // * the record with the same ID as the original request - // * in the case of a newly created record that didn't have an ID, the first - // record in the Array - if (isFirstCreatedRecord || isUpdatedRecord) { - primaryRecord = hash; - } else { - store.push(typeName, hash); - } - }, this); - } - - return primaryRecord; - }, - - /** - Called when the server has returned a payload representing - multiple records, such as in response to a `findAll` or `findQuery`. - - It is your opportunity to clean up the server's response into the normalized - form expected by Ember Data. - - If you want, you can just restructure the top-level of your payload, and - do more fine-grained normalization in the `normalize` method. - - For example, if you have a payload like this in response to a request for - all posts: - - ```js - { - "_embedded": { - "post": [{ - "id": 1, - "title": "Rails is omakase" - }, { - "id": 2, - "title": "The Parley Letter" - }], - "comment": [{ - "_id": 1, - "comment_title": "Rails is unagi" - "post_id": 1 - }, { - "_id": 2, - "comment_title": "Don't tread on me", - "post_id": 2 - }] - } - } - ``` - - You could implement a serializer that looks like this to get your payload - into shape: - - ```js - App.PostSerializer = DS.RESTSerializer.extend({ - // First, restructure the top-level so it's organized by type - // and the comments are listed under a post's `comments` key. - extractArray: function(store, type, payload) { - var posts = payload._embedded.post; - var comments = []; - var postCache = {}; - - posts.forEach(function(post) { - post.comments = []; - postCache[post.id] = post; - }); - - payload._embedded.comment.forEach(function(comment) { - comments.push(comment); - postCache[comment.post_id].comments.push(comment); - delete comment.post_id; - }); - - payload = { comments: comments, posts: payload }; - - return this._super(store, type, payload); - }, - - normalizeHash: { - // Next, normalize individual comments, which (after `extract`) - // are now located under `comments` - comments: function(hash) { - hash.id = hash._id; - hash.title = hash.comment_title; - delete hash._id; - delete hash.comment_title; - return hash; - } - } - }) - ``` - - When you call super from your own implementation of `extractArray`, the - built-in implementation will find the primary array in your normalized - payload and push the remaining records into the store. - - The primary array is the array found under `posts`. - - The primary record has special meaning when responding to `findQuery` - or `findHasMany`. In particular, the primary array will become the - list of records in the record array that kicked off the request. - - If your primary array contains secondary (embedded) records of the same type, - you cannot place these into the primary array `posts`. Instead, place the - secondary items into an underscore prefixed property `_posts`, which will - push these items into the store and will not affect the resulting query. - - @method extractArray - @param {DS.Store} store - @param {subclass of DS.Model} primaryType - @param {Object} payload - @return {Array} The primary array that was returned in response - to the original query. - */ - extractArray: function(store, primaryType, rawPayload) { - var payload = this.normalizePayload(rawPayload); - var primaryTypeName = primaryType.typeKey; - var primaryArray; - - for (var prop in payload) { - var typeKey = prop; - var forcedSecondary = false; - - if (prop.charAt(0) === '_') { - forcedSecondary = true; - typeKey = prop.substr(1); - } - - var typeName = this.typeForRoot(typeKey); - if (!store.modelFactoryFor(typeName)) { - Ember.warn(this.warnMessageNoModelForKey(prop, typeName), false); - continue; - } - var type = store.modelFor(typeName); - var typeSerializer = store.serializerFor(type); - var isPrimary = (!forcedSecondary && (type.typeKey === primaryTypeName)); - - /*jshint loopfunc:true*/ - var normalizedArray = map.call(payload[prop], function(hash) { - return typeSerializer.normalize(type, hash, prop); - }, this); - - if (isPrimary) { - primaryArray = normalizedArray; - } else { - store.pushMany(typeName, normalizedArray); - } - } - - return primaryArray; - }, - - /** - This method allows you to push a payload containing top-level - collections of records organized per type. - - ```js - { - "posts": [{ - "id": "1", - "title": "Rails is omakase", - "author", "1", - "comments": [ "1" ] - }], - "comments": [{ - "id": "1", - "body": "FIRST" - }], - "users": [{ - "id": "1", - "name": "@d2h" - }] - } - ``` - - It will first normalize the payload, so you can use this to push - in data streaming in from your server structured the same way - that fetches and saves are structured. - - @method pushPayload - @param {DS.Store} store - @param {Object} payload - */ - pushPayload: function(store, rawPayload) { - var payload = this.normalizePayload(rawPayload); - - for (var prop in payload) { - var typeName = this.typeForRoot(prop); - if (!store.modelFactoryFor(typeName, prop)){ - Ember.warn(this.warnMessageNoModelForKey(prop, typeName), false); - continue; - } - var type = store.modelFor(typeName); - var typeSerializer = store.serializerFor(type); - - /*jshint loopfunc:true*/ - var normalizedArray = map.call(Ember.makeArray(payload[prop]), function(hash) { - return typeSerializer.normalize(type, hash, prop); - }, this); - - store.pushMany(typeName, normalizedArray); - } - }, - - /** - This method is used to convert each JSON root key in the payload - into a typeKey that it can use to look up the appropriate model for - that part of the payload. By default the typeKey for a model is its - name in camelCase, so if your JSON root key is 'fast-car' you would - use typeForRoot to convert it to 'fastCar' so that Ember Data finds - the `FastCar` model. - - If you diverge from this norm you should also consider changes to - store._normalizeTypeKey as well. - - For example, your server may return prefixed root keys like so: - - ```js - { - "response-fast-car": { - "id": "1", - "name": "corvette" - } - } - ``` - - In order for Ember Data to know that the model corresponding to - the 'response-fast-car' hash is `FastCar` (typeKey: 'fastCar'), - you can override typeForRoot to convert 'response-fast-car' to - 'fastCar' like so: - - ```js - App.ApplicationSerializer = DS.RESTSerializer.extend({ - typeForRoot: function(root) { - // 'response-fast-car' should become 'fast-car' - var subRoot = root.substring(9); - - // _super normalizes 'fast-car' to 'fastCar' - return this._super(subRoot); - } - }); - ``` - - @method typeForRoot - @param {String} key - @return {String} the model's typeKey - */ - typeForRoot: function(key) { - return camelize(singularize(key)); - }, - - // SERIALIZE - - /** - Called when a record is saved in order to convert the - record into JSON. - - By default, it creates a JSON object with a key for - each attribute and belongsTo relationship. - - For example, consider this model: - - ```js - App.Comment = DS.Model.extend({ - title: DS.attr(), - body: DS.attr(), - - author: DS.belongsTo('user') - }); - ``` - - The default serialization would create a JSON object like: - - ```js - { - "title": "Rails is unagi", - "body": "Rails? Omakase? O_O", - "author": 12 - } - ``` - - By default, attributes are passed through as-is, unless - you specified an attribute type (`DS.attr('date')`). If - you specify a transform, the JavaScript value will be - serialized when inserted into the JSON hash. - - By default, belongs-to relationships are converted into - IDs when inserted into the JSON hash. - - ## IDs - - `serialize` takes an options hash with a single option: - `includeId`. If this option is `true`, `serialize` will, - by default include the ID in the JSON object it builds. - - The adapter passes in `includeId: true` when serializing - a record for `createRecord`, but not for `updateRecord`. - - ## Customization - - Your server may expect a different JSON format than the - built-in serialization format. - - In that case, you can implement `serialize` yourself and - return a JSON hash of your choosing. - - ```js - App.PostSerializer = DS.RESTSerializer.extend({ - serialize: function(post, options) { - var json = { - POST_TTL: post.get('title'), - POST_BDY: post.get('body'), - POST_CMS: post.get('comments').mapBy('id') - } - - if (options.includeId) { - json.POST_ID_ = post.get('id'); - } - - return json; - } - }); - ``` - - ## Customizing an App-Wide Serializer - - If you want to define a serializer for your entire - application, you'll probably want to use `eachAttribute` - and `eachRelationship` on the record. - - ```js - App.ApplicationSerializer = DS.RESTSerializer.extend({ - serialize: function(record, options) { - var json = {}; - - record.eachAttribute(function(name) { - json[serverAttributeName(name)] = record.get(name); - }) - - record.eachRelationship(function(name, relationship) { - if (relationship.kind === 'hasMany') { - json[serverHasManyName(name)] = record.get(name).mapBy('id'); - } - }); - - if (options.includeId) { - json.ID_ = record.get('id'); - } - - return json; - } - }); - - function serverAttributeName(attribute) { - return attribute.underscore().toUpperCase(); - } - - function serverHasManyName(name) { - return serverAttributeName(name.singularize()) + "_IDS"; - } - ``` - - This serializer will generate JSON that looks like this: - - ```js - { - "TITLE": "Rails is omakase", - "BODY": "Yep. Omakase.", - "COMMENT_IDS": [ 1, 2, 3 ] - } - ``` - - ## Tweaking the Default JSON - - If you just want to do some small tweaks on the default JSON, - you can call super first and make the tweaks on the returned - JSON. - - ```js - App.PostSerializer = DS.RESTSerializer.extend({ - serialize: function(record, options) { - var json = this._super(record, options); - - json.subject = json.title; - delete json.title; - - return json; - } - }); - ``` - - @method serialize - @param {subclass of DS.Model} record - @param {Object} options - @return {Object} json - */ - serialize: function(record, options) { - return this._super.apply(this, arguments); - }, - - /** - You can use this method to customize the root keys serialized into the JSON. - By default the REST Serializer sends the typeKey of a model, which is a camelized - version of the name. - - For example, your server may expect underscored root objects. - - ```js - App.ApplicationSerializer = DS.RESTSerializer.extend({ - serializeIntoHash: function(data, type, record, options) { - var root = Ember.String.decamelize(type.typeKey); - data[root] = this.serialize(record, options); - } - }); - ``` - - @method serializeIntoHash - @param {Object} hash - @param {subclass of DS.Model} type - @param {DS.Model} record - @param {Object} options - */ - serializeIntoHash: function(hash, type, record, options) { - hash[type.typeKey] = this.serialize(record, options); - }, - - /** - You can use this method to customize how polymorphic objects are serialized. - By default the JSON Serializer creates the key by appending `Type` to - the attribute and value from the model's camelcased model name. - - @method serializePolymorphicType - @param {DS.Model} record - @param {Object} json - @param {Object} relationship - */ - serializePolymorphicType: function(record, json, relationship) { - var key = relationship.key; - var belongsTo = get(record, key); - key = this.keyForAttribute ? this.keyForAttribute(key) : key; - if (Ember.isNone(belongsTo)) { - json[key + "Type"] = null; - } else { - json[key + "Type"] = Ember.String.camelize(belongsTo.constructor.typeKey); - } - } - }); - - Ember.runInDebug(function(){ - RESTSerializer.reopen({ - warnMessageNoModelForKey: function(prop, typeKey){ - return 'Encountered "' + prop + '" in payload, but no model was found for model name "' + typeKey + '" (resolved model name using ' + this.constructor.toString() + '.typeForRoot("' + prop + '"))'; - } - }); - }); - - __exports__["default"] = RESTSerializer; - }); -enifed("ember-data/setup-container", - ["ember-data/initializers/store","ember-data/initializers/transforms","ember-data/initializers/store_injections","ember-data/initializers/data_adapter","activemodel-adapter/setup-container","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) { - "use strict"; - var initializeStore = __dependency1__["default"]; - var initializeTransforms = __dependency2__["default"]; - var initializeStoreInjections = __dependency3__["default"]; - var initializeDataAdapter = __dependency4__["default"]; - var setupActiveModelContainer = __dependency5__["default"]; - - __exports__["default"] = function setupContainer(container, application){ - // application is not a required argument. This ensures - // testing setups can setup a container without booting an - // entire ember application. - - initializeDataAdapter(container, application); - initializeTransforms(container, application); - initializeStoreInjections(container, application); - initializeStore(container, application); - setupActiveModelContainer(container, application); - }; - }); -enifed("ember-data/system/adapter", - ["exports"], - function(__exports__) { - "use strict"; - /** - @module ember-data - */ - - var get = Ember.get; - - var errorProps = [ - 'description', - 'fileName', - 'lineNumber', - 'message', - 'name', - 'number', - 'stack' - ]; - - /** - A `DS.InvalidError` is used by an adapter to signal the external API - was unable to process a request because the content was not - semantically correct or meaningful per the API. Usually this means a - record failed some form of server side validation. When a promise - from an adapter is rejected with a `DS.InvalidError` the record will - transition to the `invalid` state and the errors will be set to the - `errors` property on the record. - - This function should return the entire payload as received from the - server. Error object extraction and normalization of model errors - should be performed by `extractErrors` on the serializer. - - Example - - ```javascript - App.ApplicationAdapter = DS.RESTAdapter.extend({ - ajaxError: function(jqXHR) { - var error = this._super(jqXHR); - - if (jqXHR && jqXHR.status === 422) { - var jsonErrors = Ember.$.parseJSON(jqXHR.responseText); - return new DS.InvalidError(jsonErrors); - } else { - return error; - } - } - }); - ``` - - The `DS.InvalidError` must be constructed with a single object whose - keys are the invalid model properties, and whose values are the - corresponding error messages. For example: - - ```javascript - return new DS.InvalidError({ - length: 'Must be less than 15', - name: 'Must not be blank' - }); - ``` - - @class InvalidError - @namespace DS - */ - function InvalidError(errors) { - var tmp = Error.prototype.constructor.call(this, "The backend rejected the commit because it was invalid: " + Ember.inspect(errors)); - this.errors = errors; - - for (var i=0, l=errorProps.length; i<l; i++) { - this[errorProps[i]] = tmp[errorProps[i]]; - } - } - - InvalidError.prototype = Ember.create(Error.prototype); - - /** - An adapter is an object that receives requests from a store and - translates them into the appropriate action to take against your - persistence layer. The persistence layer is usually an HTTP API, but - may be anything, such as the browser's local storage. Typically the - adapter is not invoked directly instead its functionality is accessed - through the `store`. - - ### Creating an Adapter - - Create a new subclass of `DS.Adapter`, then assign - it to the `ApplicationAdapter` property of the application. - - ```javascript - var MyAdapter = DS.Adapter.extend({ - // ...your code here - }); - - App.ApplicationAdapter = MyAdapter; - ``` - - Model-specific adapters can be created by assigning your adapter - class to the `ModelName` + `Adapter` property of the application. - - ```javascript - var MyPostAdapter = DS.Adapter.extend({ - // ...Post-specific adapter code goes here - }); - - App.PostAdapter = MyPostAdapter; - ``` - - `DS.Adapter` is an abstract base class that you should override in your - application to customize it for your backend. The minimum set of methods - that you should implement is: - - * `find()` - * `createRecord()` - * `updateRecord()` - * `deleteRecord()` - * `findAll()` - * `findQuery()` - - To improve the network performance of your application, you can optimize - your adapter by overriding these lower-level methods: - - * `findMany()` - - - For an example implementation, see `DS.RESTAdapter`, the - included REST adapter. - - @class Adapter - @namespace DS - @extends Ember.Object - */ - - var Adapter = Ember.Object.extend({ - - /** - If you would like your adapter to use a custom serializer you can - set the `defaultSerializer` property to be the name of the custom - serializer. - - Note the `defaultSerializer` serializer has a lower priority than - a model specific serializer (i.e. `PostSerializer`) or the - `application` serializer. - - ```javascript - var DjangoAdapter = DS.Adapter.extend({ - defaultSerializer: 'django' - }); - ``` - - @property defaultSerializer - @type {String} - */ - - /** - The `find()` method is invoked when the store is asked for a record that - has not previously been loaded. In response to `find()` being called, you - should query your persistence layer for a record with the given ID. Once - found, you can asynchronously call the store's `push()` method to push - the record into the store. - - Here is an example `find` implementation: - - ```javascript - App.ApplicationAdapter = DS.Adapter.extend({ - find: function(store, type, id) { - var url = [type.typeKey, id].join('/'); - - return new Ember.RSVP.Promise(function(resolve, reject) { - jQuery.getJSON(url).then(function(data) { - Ember.run(null, resolve, data); - }, function(jqXHR) { - jqXHR.then = null; // tame jQuery's ill mannered promises - Ember.run(null, reject, jqXHR); - }); - }); - } - }); - ``` - - @method find - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {String} id - @return {Promise} promise - */ - find: Ember.required(Function), - - /** - The `findAll()` method is called when you call `find` on the store - without an ID (i.e. `store.find('post')`). - - Example - - ```javascript - App.ApplicationAdapter = DS.Adapter.extend({ - findAll: function(store, type, sinceToken) { - var url = type; - var query = { since: sinceToken }; - return new Ember.RSVP.Promise(function(resolve, reject) { - jQuery.getJSON(url, query).then(function(data) { - Ember.run(null, resolve, data); - }, function(jqXHR) { - jqXHR.then = null; // tame jQuery's ill mannered promises - Ember.run(null, reject, jqXHR); - }); - }); - } - }); - ``` - - @private - @method findAll - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {String} sinceToken - @return {Promise} promise - */ - findAll: null, - - /** - This method is called when you call `find` on the store with a - query object as the second parameter (i.e. `store.find('person', { - page: 1 })`). - - Example - - ```javascript - App.ApplicationAdapter = DS.Adapter.extend({ - findQuery: function(store, type, query) { - var url = type; - return new Ember.RSVP.Promise(function(resolve, reject) { - jQuery.getJSON(url, query).then(function(data) { - Ember.run(null, resolve, data); - }, function(jqXHR) { - jqXHR.then = null; // tame jQuery's ill mannered promises - Ember.run(null, reject, jqXHR); - }); - }); - } - }); - ``` - - @private - @method findQuery - @param {DS.Store} store - @param {subclass of DS.Model} type - @param {Object} query - @param {DS.AdapterPopulatedRecordArray} recordArray - @return {Promise} promise - */ - findQuery: null, - - /** - If the globally unique IDs for your records should be generated on the client, - implement the `generateIdForRecord()` method. This method will be invoked - each time you create a new record, and the value returned from it will be - assigned to the record's `primaryKey`. - - Most traditional REST-like HTTP APIs will not use this method. Instead, the ID - of the record will be set by the server, and your adapter will update the store - with the new ID when it calls `didCreateRecord()`. Only implement this method if - you intend to generate record IDs on the client-side. - - The `generateIdForRecord()` method will be invoked with the requesting store as - the first parameter and the newly created record as the second parameter: - - ```javascript - generateIdForRecord: function(store, record) { - var uuid = App.generateUUIDWithStatisticallyLowOddsOfCollision(); - return uuid; - } - ``` - - @method generateIdForRecord - @param {DS.Store} store - @param {DS.Model} record - @return {String|Number} id - */ - generateIdForRecord: null, - - /** - Proxies to the serializer's `serialize` method. - - Example - - ```javascript - App.ApplicationAdapter = DS.Adapter.extend({ - createRecord: function(store, type, record) { - var data = this.serialize(record, { includeId: true }); - var url = type; - - // ... - } - }); - ``` - - @method serialize - @param {DS.Model} record - @param {Object} options - @return {Object} serialized record - */ - serialize: function(record, options) { - return get(record, 'store').serializerFor(record.constructor.typeKey).serialize(record, options); - }, - - /** - Implement this method in a subclass to handle the creation of - new records. - - Serializes the record and send it to the server. - - Example - - ```javascript - App.ApplicationAdapter = DS.Adapter.extend({ - createRecord: function(store, type, record) { - var data = this.serialize(record, { includeId: true }); - var url = type; - - return new Ember.RSVP.Promise(function(resolve, reject) { - jQuery.ajax({ - type: 'POST', - url: url, - dataType: 'json', - data: data - }).then(function(data) { - Ember.run(null, resolve, data); - }, function(jqXHR) { - jqXHR.then = null; // tame jQuery's ill mannered promises - Ember.run(null, reject, jqXHR); - }); - }); - } - }); - ``` - - @method createRecord - @param {DS.Store} store - @param {subclass of DS.Model} type the DS.Model class of the record - @param {DS.Model} record - @return {Promise} promise - */ - createRecord: Ember.required(Function), - - /** - Implement this method in a subclass to handle the updating of - a record. - - Serializes the record update and send it to the server. - - Example - - ```javascript - App.ApplicationAdapter = DS.Adapter.extend({ - updateRecord: function(store, type, record) { - var data = this.serialize(record, { includeId: true }); - var id = record.get('id'); - var url = [type, id].join('/'); - - return new Ember.RSVP.Promise(function(resolve, reject) { - jQuery.ajax({ - type: 'PUT', - url: url, - dataType: 'json', - data: data - }).then(function(data) { - Ember.run(null, resolve, data); - }, function(jqXHR) { - jqXHR.then = null; // tame jQuery's ill mannered promises - Ember.run(null, reject, jqXHR); - }); - }); - } - }); - ``` - - @method updateRecord - @param {DS.Store} store - @param {subclass of DS.Model} type the DS.Model class of the record - @param {DS.Model} record - @return {Promise} promise - */ - updateRecord: Ember.required(Function), - - /** - Implement this method in a subclass to handle the deletion of - a record. - - Sends a delete request for the record to the server. - - Example - - ```javascript - App.ApplicationAdapter = DS.Adapter.extend({ - deleteRecord: function(store, type, record) { - var data = this.serialize(record, { includeId: true }); - var id = record.get('id'); - var url = [type, id].join('/'); - - return new Ember.RSVP.Promise(function(resolve, reject) { - jQuery.ajax({ - type: 'DELETE', - url: url, - dataType: 'json', - data: data - }).then(function(data) { - Ember.run(null, resolve, data); - }, function(jqXHR) { - jqXHR.then = null; // tame jQuery's ill mannered promises - Ember.run(null, reject, jqXHR); - }); - }); - } - }); - ``` - - @method deleteRecord - @param {DS.Store} store - @param {subclass of DS.Model} type the DS.Model class of the record - @param {DS.Model} record - @return {Promise} promise - */ - deleteRecord: Ember.required(Function), - - /** - By default the store will try to coalesce all `fetchRecord` calls within the same runloop - into as few requests as possible by calling groupRecordsForFindMany and passing it into a findMany call. - You can opt out of this behaviour by either not implementing the findMany hook or by setting - coalesceFindRequests to false - - @property coalesceFindRequests - @type {boolean} - */ - coalesceFindRequests: true, - - /** - Find multiple records at once if coalesceFindRequests is true - - @method findMany - @param {DS.Store} store - @param {subclass of DS.Model} type the DS.Model class of the records - @param {Array} ids - @param {Array} records - @return {Promise} promise - */ - - /** - Organize records into groups, each of which is to be passed to separate - calls to `findMany`. - - For example, if your api has nested URLs that depend on the parent, you will - want to group records by their parent. - - The default implementation returns the records as a single group. - - @method groupRecordsForFindMany - @param {DS.Store} store - @param {Array} records - @return {Array} an array of arrays of records, each of which is to be - loaded separately by `findMany`. - */ - groupRecordsForFindMany: function (store, records) { - return [records]; - } - }); - - __exports__.InvalidError = InvalidError; - __exports__.Adapter = Adapter; - __exports__["default"] = Adapter; - }); -enifed("ember-data/system/container_proxy", - ["exports"], - function(__exports__) { - "use strict"; - /** - This is used internally to enable deprecation of container paths and provide - a decent message to the user indicating how to fix the issue. - - @class ContainerProxy - @namespace DS - @private - */ - function ContainerProxy(container){ - this.container = container; - } - - ContainerProxy.prototype.aliasedFactory = function(path, preLookup) { - var _this = this; - - return {create: function(){ - if (preLookup) { preLookup(); } - - return _this.container.lookup(path); - }}; - }; - - ContainerProxy.prototype.registerAlias = function(source, dest, preLookup) { - var factory = this.aliasedFactory(dest, preLookup); - - return this.container.register(source, factory); - }; - - ContainerProxy.prototype.registerDeprecation = function(deprecated, valid) { - var preLookupCallback = function(){ - Ember.deprecate("You tried to look up '" + deprecated + "', " + - "but this has been deprecated in favor of '" + valid + "'.", false); - }; - - return this.registerAlias(deprecated, valid, preLookupCallback); - }; - - ContainerProxy.prototype.registerDeprecations = function(proxyPairs) { - var i, proxyPair, deprecated, valid; - - for (i = proxyPairs.length; i > 0; i--) { - proxyPair = proxyPairs[i - 1]; - deprecated = proxyPair['deprecated']; - valid = proxyPair['valid']; - - this.registerDeprecation(deprecated, valid); - } - }; - - __exports__["default"] = ContainerProxy; - }); -enifed("ember-data/system/create", - [], - function() { - "use strict"; - /* - Detect if the user has a correct Object.create shim. - Ember has provided this for a long time but has had an incorrect shim before 1.8 - TODO: Remove for Ember Data 1.0. - */ - var object = Ember.create(null); - if (object.toString !== undefined && Ember.keys(Ember.create({}))[0] === '__proto__'){ - throw new Error("Ember Data requires a correct Object.create shim. You should upgrade to Ember >= 1.8 which provides one for you. If you are using ES5-shim, you should try removing that after upgrading Ember."); - } - }); -enifed("ember-data/system/debug", - ["ember-data/system/debug/debug_info","ember-data/system/debug/debug_adapter","exports"], - function(__dependency1__, __dependency2__, __exports__) { - "use strict"; - /** - @module ember-data - */ - - var DebugAdapter = __dependency2__["default"]; - - __exports__["default"] = DebugAdapter; - }); -enifed("ember-data/system/debug/debug_adapter", - ["ember-data/system/model","exports"], - function(__dependency1__, __exports__) { - "use strict"; - /** - @module ember-data - */ - var Model = __dependency1__.Model; - var get = Ember.get; - var capitalize = Ember.String.capitalize; - var underscore = Ember.String.underscore; - - /** - Extend `Ember.DataAdapter` with ED specific code. - - @class DebugAdapter - @namespace DS - @extends Ember.DataAdapter - @private - */ - __exports__["default"] = Ember.DataAdapter.extend({ - getFilters: function() { - return [ - { name: 'isNew', desc: 'New' }, - { name: 'isModified', desc: 'Modified' }, - { name: 'isClean', desc: 'Clean' } - ]; - }, - - detect: function(klass) { - return klass !== Model && Model.detect(klass); - }, - - columnsForType: function(type) { - var columns = [{ - name: 'id', - desc: 'Id' - }]; - var count = 0; - var self = this; - get(type, 'attributes').forEach(function(meta, name) { - if (count++ > self.attributeLimit) { return false; } - var desc = capitalize(underscore(name).replace('_', ' ')); - columns.push({ name: name, desc: desc }); - }); - return columns; - }, - - getRecords: function(type) { - return this.get('store').all(type); - }, - - getRecordColumnValues: function(record) { - var self = this, count = 0; - var columnValues = { id: get(record, 'id') }; - - record.eachAttribute(function(key) { - if (count++ > self.attributeLimit) { - return false; - } - var value = get(record, key); - columnValues[key] = value; - }); - return columnValues; - }, - - getRecordKeywords: function(record) { - var keywords = []; - var keys = Ember.A(['id']); - record.eachAttribute(function(key) { - keys.push(key); - }); - keys.forEach(function(key) { - keywords.push(get(record, key)); - }); - return keywords; - }, - - getRecordFilterValues: function(record) { - return { - isNew: record.get('isNew'), - isModified: record.get('isDirty') && !record.get('isNew'), - isClean: !record.get('isDirty') - }; - }, - - getRecordColor: function(record) { - var color = 'black'; - if (record.get('isNew')) { - color = 'green'; - } else if (record.get('isDirty')) { - color = 'blue'; - } - return color; - }, - - observeRecord: function(record, recordUpdated) { - var releaseMethods = Ember.A(), self = this; - var keysToObserve = Ember.A(['id', 'isNew', 'isDirty']); - - record.eachAttribute(function(key) { - keysToObserve.push(key); - }); - - keysToObserve.forEach(function(key) { - var handler = function() { - recordUpdated(self.wrapRecord(record)); - }; - Ember.addObserver(record, key, handler); - releaseMethods.push(function() { - Ember.removeObserver(record, key, handler); - }); - }); - - var release = function() { - releaseMethods.forEach(function(fn) { fn(); } ); - }; - - return release; - } - - }); - }); -enifed("ember-data/system/debug/debug_info", - ["ember-data/system/model","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var Model = __dependency1__.Model; - - Model.reopen({ - - /** - Provides info about the model for debugging purposes - by grouping the properties into more semantic groups. - - Meant to be used by debugging tools such as the Chrome Ember Extension. - - - Groups all attributes in "Attributes" group. - - Groups all belongsTo relationships in "Belongs To" group. - - Groups all hasMany relationships in "Has Many" group. - - Groups all flags in "Flags" group. - - Flags relationship CPs as expensive properties. - - @method _debugInfo - @for DS.Model - @private - */ - _debugInfo: function() { - var attributes = ['id'], - relationships = { belongsTo: [], hasMany: [] }, - expensiveProperties = []; - - this.eachAttribute(function(name, meta) { - attributes.push(name); - }, this); - - this.eachRelationship(function(name, relationship) { - relationships[relationship.kind].push(name); - expensiveProperties.push(name); - }); - - var groups = [ - { - name: 'Attributes', - properties: attributes, - expand: true - }, - { - name: 'Belongs To', - properties: relationships.belongsTo, - expand: true - }, - { - name: 'Has Many', - properties: relationships.hasMany, - expand: true - }, - { - name: 'Flags', - properties: ['isLoaded', 'isDirty', 'isSaving', 'isDeleted', 'isError', 'isNew', 'isValid'] - } - ]; - - return { - propertyInfo: { - // include all other mixins / properties (not just the grouped ones) - includeOtherProperties: true, - groups: groups, - // don't pre-calculate unless cached - expensiveProperties: expensiveProperties - } - }; - } - }); - - __exports__["default"] = Model; - }); -enifed("ember-data/system/map", - ["exports"], - function(__exports__) { - "use strict"; - /** - * Polyfill Ember.Map behavior for Ember <= 1.7 - * This can probably be removed before 1.0 final - */ - var mapForEach, deleteFn; - - function OrderedSet(){ - Ember.OrderedSet.apply(this, arguments); - } - - function Map() { - Ember.Map.apply(this, arguments); - } - - function MapWithDefault(){ - Ember.MapWithDefault.apply(this, arguments); - } - - var testMap = Ember.Map.create(); - testMap.set('key', 'value'); - - var usesOldBehavior = false; - - testMap.forEach(function(value, key){ - usesOldBehavior = value === 'key' && key === 'value'; - }); - - Map.prototype = Ember.create(Ember.Map.prototype); - MapWithDefault.prototype = Ember.create(Ember.MapWithDefault.prototype); - OrderedSet.prototype = Ember.create(Ember.OrderedSet.prototype); - - OrderedSet.create = function(){ - return new OrderedSet(); - }; - - /** - * returns a function that calls the original - * callback function in the correct order. - * if we are in pre-Ember.1.8 land, Map/MapWithDefault - * forEach calls with key, value, in that order. - * >= 1.8 forEach is called with the order value, key as per - * the ES6 spec. - */ - function translate(valueKeyOrderedCallback){ - return function(key, value){ - valueKeyOrderedCallback.call(this, value, key); - }; - } - - // old, non ES6 compliant behavior - if (usesOldBehavior){ - mapForEach = function(callback, thisArg){ - this.__super$forEach(translate(callback), thisArg); - }; - - /* alias to remove */ - deleteFn = function(thing){ - this.remove(thing); - }; - - Map.prototype.__super$forEach = Ember.Map.prototype.forEach; - Map.prototype.forEach = mapForEach; - Map.prototype["delete"] = deleteFn; - - MapWithDefault.prototype.forEach = mapForEach; - MapWithDefault.prototype.__super$forEach = Ember.MapWithDefault.prototype.forEach; - MapWithDefault.prototype["delete"] = deleteFn; - - OrderedSet.prototype["delete"] = deleteFn; - } - - MapWithDefault.constructor = MapWithDefault; - Map.constructor = Map; - - MapWithDefault.create = function(options){ - if (options) { - return new MapWithDefault(options); - } else { - return new Map(); - } - }; - - Map.create = function(){ - return new this.constructor(); - }; - - __exports__["default"] = Map; - __exports__.Map = Map; - __exports__.MapWithDefault = MapWithDefault; - __exports__.OrderedSet = OrderedSet; - }); -enifed("ember-data/system/model", - ["ember-data/system/model/model","ember-data/system/model/attributes","ember-data/system/model/states","ember-data/system/model/errors","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) { - "use strict"; - /** - @module ember-data - */ - - var Model = __dependency1__["default"]; - var attr = __dependency2__["default"]; - var RootState = __dependency3__["default"]; - var Errors = __dependency4__["default"]; - - __exports__.Model = Model; - __exports__.RootState = RootState; - __exports__.attr = attr; - __exports__.Errors = Errors; - }); -enifed("ember-data/system/model/attributes", - ["ember-data/system/model/model","ember-data/system/map","exports"], - function(__dependency1__, __dependency2__, __exports__) { - "use strict"; - var Model = __dependency1__["default"]; - var Map = __dependency2__.Map; - - /** - @module ember-data - */ - - var get = Ember.get; - - /** - @class Model - @namespace DS - */ - Model.reopenClass({ - /** - A map whose keys are the attributes of the model (properties - described by DS.attr) and whose values are the meta object for the - property. - - Example - - ```javascript - - App.Person = DS.Model.extend({ - firstName: attr('string'), - lastName: attr('string'), - birthday: attr('date') - }); - - var attributes = Ember.get(App.Person, 'attributes') - - attributes.forEach(function(name, meta) { - console.log(name, meta); - }); - - // prints: - // firstName {type: "string", isAttribute: true, options: Object, parentType: function, name: "firstName"} - // lastName {type: "string", isAttribute: true, options: Object, parentType: function, name: "lastName"} - // birthday {type: "date", isAttribute: true, options: Object, parentType: function, name: "birthday"} - ``` - - @property attributes - @static - @type {Ember.Map} - @readOnly - */ - attributes: Ember.computed(function() { - var map = Map.create(); - - this.eachComputedProperty(function(name, meta) { - if (meta.isAttribute) { - Ember.assert("You may not set `id` as an attribute on your model. Please remove any lines that look like: `id: DS.attr('<type>')` from " + this.toString(), name !== 'id'); - - meta.name = name; - map.set(name, meta); - } - }); - - return map; - }).readOnly(), - - /** - A map whose keys are the attributes of the model (properties - described by DS.attr) and whose values are type of transformation - applied to each attribute. This map does not include any - attributes that do not have an transformation type. - - Example - - ```javascript - App.Person = DS.Model.extend({ - firstName: attr(), - lastName: attr('string'), - birthday: attr('date') - }); - - var transformedAttributes = Ember.get(App.Person, 'transformedAttributes') - - transformedAttributes.forEach(function(field, type) { - console.log(field, type); - }); - - // prints: - // lastName string - // birthday date - ``` - - @property transformedAttributes - @static - @type {Ember.Map} - @readOnly - */ - transformedAttributes: Ember.computed(function() { - var map = Map.create(); - - this.eachAttribute(function(key, meta) { - if (meta.type) { - map.set(key, meta.type); - } - }); - - return map; - }).readOnly(), - - /** - Iterates through the attributes of the model, calling the passed function on each - attribute. - - The callback method you provide should have the following signature (all - parameters are optional): - - ```javascript - function(name, meta); - ``` - - - `name` the name of the current property in the iteration - - `meta` the meta object for the attribute property in the iteration - - Note that in addition to a callback, you can also pass an optional target - object that will be set as `this` on the context. - - Example - - ```javascript - App.Person = DS.Model.extend({ - firstName: attr('string'), - lastName: attr('string'), - birthday: attr('date') - }); - - App.Person.eachAttribute(function(name, meta) { - console.log(name, meta); - }); - - // prints: - // firstName {type: "string", isAttribute: true, options: Object, parentType: function, name: "firstName"} - // lastName {type: "string", isAttribute: true, options: Object, parentType: function, name: "lastName"} - // birthday {type: "date", isAttribute: true, options: Object, parentType: function, name: "birthday"} - ``` - - @method eachAttribute - @param {Function} callback The callback to execute - @param {Object} [target] The target object to use - @static - */ - eachAttribute: function(callback, binding) { - get(this, 'attributes').forEach(function(meta, name) { - callback.call(binding, name, meta); - }, binding); - }, - - /** - Iterates through the transformedAttributes of the model, calling - the passed function on each attribute. Note the callback will not be - called for any attributes that do not have an transformation type. - - The callback method you provide should have the following signature (all - parameters are optional): - - ```javascript - function(name, type); - ``` - - - `name` the name of the current property in the iteration - - `type` a string containing the name of the type of transformed - applied to the attribute - - Note that in addition to a callback, you can also pass an optional target - object that will be set as `this` on the context. - - Example - - ```javascript - App.Person = DS.Model.extend({ - firstName: attr(), - lastName: attr('string'), - birthday: attr('date') - }); - - App.Person.eachTransformedAttribute(function(name, type) { - console.log(name, type); - }); - - // prints: - // lastName string - // birthday date - ``` - - @method eachTransformedAttribute - @param {Function} callback The callback to execute - @param {Object} [target] The target object to use - @static - */ - eachTransformedAttribute: function(callback, binding) { - get(this, 'transformedAttributes').forEach(function(type, name) { - callback.call(binding, name, type); - }); - } - }); - - - Model.reopen({ - eachAttribute: function(callback, binding) { - this.constructor.eachAttribute(callback, binding); - } - }); - - function getDefaultValue(record, options, key) { - if (typeof options.defaultValue === "function") { - return options.defaultValue.apply(null, arguments); - } else { - return options.defaultValue; - } - } - - function hasValue(record, key) { - return record._attributes.hasOwnProperty(key) || - record._inFlightAttributes.hasOwnProperty(key) || - record._data.hasOwnProperty(key); - } - - function getValue(record, key) { - if (record._attributes.hasOwnProperty(key)) { - return record._attributes[key]; - } else if (record._inFlightAttributes.hasOwnProperty(key)) { - return record._inFlightAttributes[key]; - } else { - return record._data[key]; - } - } - - /** - `DS.attr` defines an attribute on a [DS.Model](/api/data/classes/DS.Model.html). - By default, attributes are passed through as-is, however you can specify an - optional type to have the value automatically transformed. - Ember Data ships with four basic transform types: `string`, `number`, - `boolean` and `date`. You can define your own transforms by subclassing - [DS.Transform](/api/data/classes/DS.Transform.html). - - Note that you cannot use `attr` to define an attribute of `id`. - - `DS.attr` takes an optional hash as a second parameter, currently - supported options are: - - - `defaultValue`: Pass a string or a function to be called to set the attribute - to a default value if none is supplied. - - Example - - ```javascript - var attr = DS.attr; - - App.User = DS.Model.extend({ - username: attr('string'), - email: attr('string'), - verified: attr('boolean', {defaultValue: false}) - }); - ``` - - @namespace - @method attr - @for DS - @param {String} type the attribute type - @param {Object} options a hash of options - @return {Attribute} - */ - - __exports__["default"] = function attr(type, options) { - options = options || {}; - - var meta = { - type: type, - isAttribute: true, - options: options - }; - - return Ember.computed(function(key, value) { - if (arguments.length > 1) { - Ember.assert("You may not set `id` as an attribute on your model. Please remove any lines that look like: `id: DS.attr('<type>')` from " + this.constructor.toString(), key !== 'id'); - var oldValue = getValue(this, key); - - if (value !== oldValue) { - // Add the new value to the changed attributes hash; it will get deleted by - // the 'didSetProperty' handler if it is no different from the original value - this._attributes[key] = value; - - this.send('didSetProperty', { - name: key, - oldValue: oldValue, - originalValue: this._data[key], - value: value - }); - } - - return value; - } else if (hasValue(this, key)) { - return getValue(this, key); - } else { - return getDefaultValue(this, options, key); - } - - // `data` is never set directly. However, it may be - // invalidated from the state manager's setData - // event. - }).meta(meta); - }; - }); -enifed("ember-data/system/model/errors", - ["ember-data/system/map","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var get = Ember.get; - var isEmpty = Ember.isEmpty; - var map = Ember.EnumerableUtils.map; - - var MapWithDefault = __dependency1__.MapWithDefault; - - /** - @module ember-data - */ - - /** - Holds validation errors for a given record organized by attribute names. - - Every DS.Model has an `errors` property that is an instance of - `DS.Errors`. This can be used to display validation error - messages returned from the server when a `record.save()` rejects. - This works automatically with `DS.ActiveModelAdapter`, but you - can implement [ajaxError](/api/data/classes/DS.RESTAdapter.html#method_ajaxError) - in other adapters as well. - - For Example, if you had an `User` model that looked like this: - - ```javascript - App.User = DS.Model.extend({ - username: attr('string'), - email: attr('string') - }); - ``` - And you attempted to save a record that did not validate on the backend. - - ```javascript - var user = store.createRecord('user', { - username: 'tomster', - email: 'invalidEmail' - }); - user.save(); - ``` - - Your backend data store might return a response that looks like - this. This response will be used to populate the error object. - - ```javascript - { - "errors": { - "username": ["This username is already taken!"], - "email": ["Doesn't look like a valid email."] - } - } - ``` - - Errors can be displayed to the user by accessing their property name - or using the `messages` property to get an array of all errors. - - ```handlebars - {{#each errors.messages}} - <div class="error"> - {{message}} - </div> - {{/each}} - - <label>Username: {{input value=username}} </label> - {{#each errors.username}} - <div class="error"> - {{message}} - </div> - {{/each}} - - <label>Email: {{input value=email}} </label> - {{#each errors.email}} - <div class="error"> - {{message}} - </div> - {{/each}} - ``` - - @class Errors - @namespace DS - @extends Ember.Object - @uses Ember.Enumerable - @uses Ember.Evented - */ - __exports__["default"] = Ember.Object.extend(Ember.Enumerable, Ember.Evented, { - /** - Register with target handler - - @method registerHandlers - @param {Object} target - @param {Function} becameInvalid - @param {Function} becameValid - */ - registerHandlers: function(target, becameInvalid, becameValid) { - this.on('becameInvalid', target, becameInvalid); - this.on('becameValid', target, becameValid); - }, - - /** - @property errorsByAttributeName - @type {Ember.MapWithDefault} - @private - */ - errorsByAttributeName: Ember.reduceComputed("content", { - initialValue: function() { - return MapWithDefault.create({ - defaultValue: function() { - return Ember.A(); - } - }); - }, - - addedItem: function(errors, error) { - errors.get(error.attribute).pushObject(error); - - return errors; - }, - - removedItem: function(errors, error) { - errors.get(error.attribute).removeObject(error); - - return errors; - } - }), - - /** - Returns errors for a given attribute - - ```javascript - var user = store.createRecord('user', { - username: 'tomster', - email: 'invalidEmail' - }); - user.save().catch(function(){ - user.get('errors').errorsFor('email'); // ["Doesn't look like a valid email."] - }); - ``` - - @method errorsFor - @param {String} attribute - @return {Array} - */ - errorsFor: function(attribute) { - return get(this, 'errorsByAttributeName').get(attribute); - }, - - /** - An array containing all of the error messages for this - record. This is useful for displaying all errors to the user. - - ```handlebars - {{#each errors.messages}} - <div class="error"> - {{message}} - </div> - {{/each}} - ``` - - @property messages - @type {Array} - */ - messages: Ember.computed.mapBy('content', 'message'), - - /** - @property content - @type {Array} - @private - */ - content: Ember.computed(function() { - return Ember.A(); - }), - - /** - @method unknownProperty - @private - */ - unknownProperty: function(attribute) { - var errors = this.errorsFor(attribute); - if (isEmpty(errors)) { return null; } - return errors; - }, - - /** - @method nextObject - @private - */ - nextObject: function(index, previousObject, context) { - return get(this, 'content').objectAt(index); - }, - - /** - Total number of errors. - - @property length - @type {Number} - @readOnly - */ - length: Ember.computed.oneWay('content.length').readOnly(), - - /** - @property isEmpty - @type {Boolean} - @readOnly - */ - isEmpty: Ember.computed.not('length').readOnly(), - - /** - Adds error messages to a given attribute and sends - `becameInvalid` event to the record. - - Example: - - ```javascript - if (!user.get('username') { - user.get('errors').add('username', 'This field is required'); - } - ``` - - @method add - @param {String} attribute - @param {Array|String} messages - */ - add: function(attribute, messages) { - var wasEmpty = get(this, 'isEmpty'); - - messages = this._findOrCreateMessages(attribute, messages); - get(this, 'content').addObjects(messages); - - this.notifyPropertyChange(attribute); - this.enumerableContentDidChange(); - - if (wasEmpty && !get(this, 'isEmpty')) { - this.trigger('becameInvalid'); - } - }, - - /** - @method _findOrCreateMessages - @private - */ - _findOrCreateMessages: function(attribute, messages) { - var errors = this.errorsFor(attribute); - - return map(Ember.makeArray(messages), function(message) { - return errors.findBy('message', message) || { - attribute: attribute, - message: message - }; - }); - }, - - /** - Removes all error messages from the given attribute and sends - `becameValid` event to the record if there no more errors left. - - Example: - - ```javascript - App.User = DS.Model.extend({ - email: DS.attr('string'), - twoFactorAuth: DS.attr('boolean'), - phone: DS.attr('string') - }); - - App.UserEditRoute = Ember.Route.extend({ - actions: { - save: function(user) { - if (!user.get('twoFactorAuth')) { - user.get('errors').remove('phone'); - } - user.save(); - } - } - }); - ``` - - @method remove - @param {String} attribute - */ - remove: function(attribute) { - if (get(this, 'isEmpty')) { return; } - - var content = get(this, 'content').rejectBy('attribute', attribute); - get(this, 'content').setObjects(content); - - this.notifyPropertyChange(attribute); - this.enumerableContentDidChange(); - - if (get(this, 'isEmpty')) { - this.trigger('becameValid'); - } - }, - - /** - Removes all error messages and sends `becameValid` event - to the record. - - Example: - - ```javascript - App.UserEditRoute = Ember.Route.extend({ - actions: { - retrySave: function(user) { - user.get('errors').clear(); - user.save(); - } - } - }); - ``` - - @method clear - */ - clear: function() { - if (get(this, 'isEmpty')) { return; } - - get(this, 'content').clear(); - this.enumerableContentDidChange(); - - this.trigger('becameValid'); - }, - - /** - Checks if there is error messages for the given attribute. - - ```javascript - App.UserEditRoute = Ember.Route.extend({ - actions: { - save: function(user) { - if (user.get('errors').has('email')) { - return alert('Please update your email before attempting to save.'); - } - user.save(); - } - } - }); - ``` - - @method has - @param {String} attribute - @return {Boolean} true if there some errors on given attribute - */ - has: function(attribute) { - return !isEmpty(this.errorsFor(attribute)); - } - }); - }); -enifed("ember-data/system/model/model", - ["ember-data/system/model/states","ember-data/system/model/errors","ember-data/system/promise_proxies","ember-data/system/relationships/relationship","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) { - "use strict"; - var RootState = __dependency1__["default"]; - var Errors = __dependency2__["default"]; - var PromiseObject = __dependency3__.PromiseObject; - var createRelationshipFor = __dependency4__.createRelationshipFor; - - /** - @module ember-data - */ - - var get = Ember.get; - var set = Ember.set; - var merge = Ember.merge; - var Promise = Ember.RSVP.Promise; - var forEach = Ember.ArrayPolyfills.forEach; - var map = Ember.ArrayPolyfills.map; - - var JSONSerializer; - var retrieveFromCurrentState = Ember.computed('currentState', function(key, value) { - return get(get(this, 'currentState'), key); - }).readOnly(); - - var _extractPivotNameCache = Ember.create(null); - var _splitOnDotCache = Ember.create(null); - - function splitOnDot(name) { - return _splitOnDotCache[name] || ( - _splitOnDotCache[name] = name.split('.') - ); - } - - function extractPivotName(name) { - return _extractPivotNameCache[name] || ( - _extractPivotNameCache[name] = splitOnDot(name)[0] - ); - } - - /** - - The model class that all Ember Data records descend from. - - @class Model - @namespace DS - @extends Ember.Object - @uses Ember.Evented - */ - var Model = Ember.Object.extend(Ember.Evented, { - _recordArrays: undefined, - _relationships: undefined, - _loadingRecordArrays: undefined, - /** - If this property is `true` the record is in the `empty` - state. Empty is the first state all records enter after they have - been created. Most records created by the store will quickly - transition to the `loading` state if data needs to be fetched from - the server or the `created` state if the record is created on the - client. A record can also enter the empty state if the adapter is - unable to locate the record. - - @property isEmpty - @type {Boolean} - @readOnly - */ - isEmpty: retrieveFromCurrentState, - /** - If this property is `true` the record is in the `loading` state. A - record enters this state when the store asks the adapter for its - data. It remains in this state until the adapter provides the - requested data. - - @property isLoading - @type {Boolean} - @readOnly - */ - isLoading: retrieveFromCurrentState, - /** - If this property is `true` the record is in the `loaded` state. A - record enters this state when its data is populated. Most of a - record's lifecycle is spent inside substates of the `loaded` - state. - - Example - - ```javascript - var record = store.createRecord('model'); - record.get('isLoaded'); // true - - store.find('model', 1).then(function(model) { - model.get('isLoaded'); // true - }); - ``` - - @property isLoaded - @type {Boolean} - @readOnly - */ - isLoaded: retrieveFromCurrentState, - /** - If this property is `true` the record is in the `dirty` state. The - record has local changes that have not yet been saved by the - adapter. This includes records that have been created (but not yet - saved) or deleted. - - Example - - ```javascript - var record = store.createRecord('model'); - record.get('isDirty'); // true - - store.find('model', 1).then(function(model) { - model.get('isDirty'); // false - model.set('foo', 'some value'); - model.get('isDirty'); // true - }); - ``` - - @property isDirty - @type {Boolean} - @readOnly - */ - isDirty: retrieveFromCurrentState, - /** - If this property is `true` the record is in the `saving` state. A - record enters the saving state when `save` is called, but the - adapter has not yet acknowledged that the changes have been - persisted to the backend. - - Example - - ```javascript - var record = store.createRecord('model'); - record.get('isSaving'); // false - var promise = record.save(); - record.get('isSaving'); // true - promise.then(function() { - record.get('isSaving'); // false - }); - ``` - - @property isSaving - @type {Boolean} - @readOnly - */ - isSaving: retrieveFromCurrentState, - /** - If this property is `true` the record is in the `deleted` state - and has been marked for deletion. When `isDeleted` is true and - `isDirty` is true, the record is deleted locally but the deletion - was not yet persisted. When `isSaving` is true, the change is - in-flight. When both `isDirty` and `isSaving` are false, the - change has persisted. - - Example - - ```javascript - var record = store.createRecord('model'); - record.get('isDeleted'); // false - record.deleteRecord(); - - // Locally deleted - record.get('isDeleted'); // true - record.get('isDirty'); // true - record.get('isSaving'); // false - - // Persisting the deletion - var promise = record.save(); - record.get('isDeleted'); // true - record.get('isSaving'); // true - - // Deletion Persisted - promise.then(function() { - record.get('isDeleted'); // true - record.get('isSaving'); // false - record.get('isDirty'); // false - }); - ``` - - @property isDeleted - @type {Boolean} - @readOnly - */ - isDeleted: retrieveFromCurrentState, - /** - If this property is `true` the record is in the `new` state. A - record will be in the `new` state when it has been created on the - client and the adapter has not yet report that it was successfully - saved. - - Example - - ```javascript - var record = store.createRecord('model'); - record.get('isNew'); // true - - record.save().then(function(model) { - model.get('isNew'); // false - }); - ``` - - @property isNew - @type {Boolean} - @readOnly - */ - isNew: retrieveFromCurrentState, - /** - If this property is `true` the record is in the `valid` state. - - A record will be in the `valid` state when the adapter did not report any - server-side validation failures. - - @property isValid - @type {Boolean} - @readOnly - */ - isValid: retrieveFromCurrentState, - /** - If the record is in the dirty state this property will report what - kind of change has caused it to move into the dirty - state. Possible values are: - - - `created` The record has been created by the client and not yet saved to the adapter. - - `updated` The record has been updated by the client and not yet saved to the adapter. - - `deleted` The record has been deleted by the client and not yet saved to the adapter. - - Example - - ```javascript - var record = store.createRecord('model'); - record.get('dirtyType'); // 'created' - ``` - - @property dirtyType - @type {String} - @readOnly - */ - dirtyType: retrieveFromCurrentState, - - /** - If `true` the adapter reported that it was unable to save local - changes to the backend for any reason other than a server-side - validation error. - - Example - - ```javascript - record.get('isError'); // false - record.set('foo', 'valid value'); - record.save().then(null, function() { - record.get('isError'); // true - }); - ``` - - @property isError - @type {Boolean} - @readOnly - */ - isError: false, - /** - If `true` the store is attempting to reload the record form the adapter. - - Example - - ```javascript - record.get('isReloading'); // false - record.reload(); - record.get('isReloading'); // true - ``` - - @property isReloading - @type {Boolean} - @readOnly - */ - isReloading: false, - - /** - The `clientId` property is a transient numerical identifier - generated at runtime by the data store. It is important - primarily because newly created objects may not yet have an - externally generated id. - - @property clientId - @private - @type {Number|String} - */ - clientId: null, - /** - All ember models have an id property. This is an identifier - managed by an external source. These are always coerced to be - strings before being used internally. Note when declaring the - attributes for a model it is an error to declare an id - attribute. - - ```javascript - var record = store.createRecord('model'); - record.get('id'); // null - - store.find('model', 1).then(function(model) { - model.get('id'); // '1' - }); - ``` - - @property id - @type {String} - */ - id: null, - - /** - @property currentState - @private - @type {Object} - */ - currentState: RootState.empty, - - /** - When the record is in the `invalid` state this object will contain - any errors returned by the adapter. When present the errors hash - typically contains keys corresponding to the invalid property names - and values which are an array of error messages. - - ```javascript - record.get('errors.length'); // 0 - record.set('foo', 'invalid value'); - record.save().then(null, function() { - record.get('errors').get('foo'); // ['foo should be a number.'] - }); - ``` - - @property errors - @type {DS.Errors} - */ - errors: Ember.computed(function() { - var errors = Errors.create(); - - errors.registerHandlers(this, function() { - this.send('becameInvalid'); - }, function() { - this.send('becameValid'); - }); - - return errors; - }).readOnly(), - - /** - Create a JSON representation of the record, using the serialization - strategy of the store's adapter. - - `serialize` takes an optional hash as a parameter, currently - supported options are: - - - `includeId`: `true` if the record's ID should be included in the - JSON representation. - - @method serialize - @param {Object} options - @return {Object} an object whose values are primitive JSON values only - */ - serialize: function(options) { - var store = get(this, 'store'); - return store.serialize(this, options); - }, - - /** - Use [DS.JSONSerializer](DS.JSONSerializer.html) to - get the JSON representation of a record. - - `toJSON` takes an optional hash as a parameter, currently - supported options are: - - - `includeId`: `true` if the record's ID should be included in the - JSON representation. - - @method toJSON - @param {Object} options - @return {Object} A JSON representation of the object. - */ - toJSON: function(options) { - if (!JSONSerializer) { JSONSerializer = requireModule("ember-data/serializers/json_serializer")["default"]; } - // container is for lazy transform lookups - var serializer = JSONSerializer.create({ container: this.container }); - return serializer.serialize(this, options); - }, - - /** - Fired when the record is loaded from the server. - - @event didLoad - */ - didLoad: Ember.K, - - /** - Fired when the record is updated. - - @event didUpdate - */ - didUpdate: Ember.K, - - /** - Fired when the record is created. - - @event didCreate - */ - didCreate: Ember.K, - - /** - Fired when the record is deleted. - - @event didDelete - */ - didDelete: Ember.K, - - /** - Fired when the record becomes invalid. - - @event becameInvalid - */ - becameInvalid: Ember.K, - - /** - Fired when the record enters the error state. - - @event becameError - */ - becameError: Ember.K, - - /** - @property data - @private - @type {Object} - */ - data: Ember.computed(function() { - this._data = this._data || {}; - return this._data; - }).readOnly(), - - _data: null, - - init: function() { - this._super(); - this._setup(); - }, - - _setup: function() { - this._changesToSync = {}; - this._deferredTriggers = []; - this._data = {}; - this._attributes = {}; - this._inFlightAttributes = {}; - this._relationships = {}; - /* - implicit relationships are relationship which have not been declared but the inverse side exists on - another record somewhere - For example if there was - ``` - App.Comment = DS.Model.extend({ - name: DS.attr() - }) - ``` - but there is also - ``` - App.Post = DS.Model.extend({ - name: DS.attr(), - comments: DS.hasMany('comment') - }) - ``` - - would have a implicit post relationship in order to be do things like remove ourselves from the post - when we are deleted - */ - this._implicitRelationships = Ember.create(null); - var model = this; - //TODO Move into a getter for better perf - this.constructor.eachRelationship(function(key, descriptor) { - model._relationships[key] = createRelationshipFor(model, descriptor, model.store); - }); - - }, - - /** - @method send - @private - @param {String} name - @param {Object} context - */ - send: function(name, context) { - var currentState = get(this, 'currentState'); - - if (!currentState[name]) { - this._unhandledEvent(currentState, name, context); - } - - return currentState[name](this, context); - }, - - /** - @method transitionTo - @private - @param {String} name - */ - transitionTo: function(name) { - // POSSIBLE TODO: Remove this code and replace with - // always having direct references to state objects - - var pivotName = extractPivotName(name); - var currentState = get(this, 'currentState'); - var state = currentState; - - do { - if (state.exit) { state.exit(this); } - state = state.parentState; - } while (!state.hasOwnProperty(pivotName)); - - var path = splitOnDot(name); - var setups = [], enters = [], i, l; - - for (i=0, l=path.length; i<l; i++) { - state = state[path[i]]; - - if (state.enter) { enters.push(state); } - if (state.setup) { setups.push(state); } - } - - for (i=0, l=enters.length; i<l; i++) { - enters[i].enter(this); - } - - set(this, 'currentState', state); - - for (i=0, l=setups.length; i<l; i++) { - setups[i].setup(this); - } - - this.updateRecordArraysLater(); - }, - - _unhandledEvent: function(state, name, context) { - var errorMessage = "Attempted to handle event `" + name + "` "; - errorMessage += "on " + String(this) + " while in state "; - errorMessage += state.stateName + ". "; - - if (context !== undefined) { - errorMessage += "Called with " + Ember.inspect(context) + "."; - } - - throw new Ember.Error(errorMessage); - }, - - withTransaction: function(fn) { - var transaction = get(this, 'transaction'); - if (transaction) { fn(transaction); } - }, - - /** - @method loadingData - @private - @param {Promise} promise - */ - loadingData: function(promise) { - this.send('loadingData', promise); - }, - - /** - @method loadedData - @private - */ - loadedData: function() { - this.send('loadedData'); - }, - - /** - @method notFound - @private - */ - notFound: function() { - this.send('notFound'); - }, - - /** - @method pushedData - @private - */ - pushedData: function() { - this.send('pushedData'); - }, - - /** - Marks the record as deleted but does not save it. You must call - `save` afterwards if you want to persist it. You might use this - method if you want to allow the user to still `rollback()` a - delete after it was made. - - Example - - ```javascript - App.ModelDeleteRoute = Ember.Route.extend({ - actions: { - softDelete: function() { - this.controller.get('model').deleteRecord(); - }, - confirm: function() { - this.controller.get('model').save(); - }, - undo: function() { - this.controller.get('model').rollback(); - } - } - }); - ``` - - @method deleteRecord - */ - deleteRecord: function() { - this.send('deleteRecord'); - }, - - /** - Same as `deleteRecord`, but saves the record immediately. - - Example - - ```javascript - App.ModelDeleteRoute = Ember.Route.extend({ - actions: { - delete: function() { - var controller = this.controller; - controller.get('model').destroyRecord().then(function() { - controller.transitionToRoute('model.index'); - }); - } - } - }); - ``` - - @method destroyRecord - @return {Promise} a promise that will be resolved when the adapter returns - successfully or rejected if the adapter returns with an error. - */ - destroyRecord: function() { - this.deleteRecord(); - return this.save(); - }, - - /** - @method unloadRecord - @private - */ - unloadRecord: function() { - if (this.isDestroyed) { return; } - - this.send('unloadRecord'); - }, - - /** - @method clearRelationships - @private - */ - clearRelationships: function() { - this.eachRelationship(function(name, relationship) { - var rel = this._relationships[name]; - if (rel){ - //TODO(Igor) figure out whether we want to clear or disconnect - rel.clear(); - rel.destroy(); - } - }, this); - }, - - disconnectRelationships: function() { - this.eachRelationship(function(name, relationship) { - this._relationships[name].disconnect(); - }, this); - var model = this; - forEach.call(Ember.keys(this._implicitRelationships), function(key) { - model._implicitRelationships[key].disconnect(); - }); - }, - - reconnectRelationships: function() { - this.eachRelationship(function(name, relationship) { - this._relationships[name].reconnect(); - }, this); - var model = this; - forEach.call(Ember.keys(this._implicitRelationships), function(key) { - model._implicitRelationships[key].reconnect(); - }); - }, - - - /** - @method updateRecordArrays - @private - */ - updateRecordArrays: function() { - this._updatingRecordArraysLater = false; - get(this, 'store').dataWasUpdated(this.constructor, this); - }, - - /** - When a find request is triggered on the store, the user can optionally pass in - attributes and relationships to be preloaded. These are meant to behave as if they - came back from the server, except the user obtained them out of band and is informing - the store of their existence. The most common use case is for supporting client side - nested URLs, such as `/posts/1/comments/2` so the user can do - `store.find('comment', 2, {post:1})` without having to fetch the post. - - Preloaded data can be attributes and relationships passed in either as IDs or as actual - models. - - @method _preloadData - @private - @param {Object} preload - */ - _preloadData: function(preload) { - var record = this; - //TODO(Igor) consider the polymorphic case - forEach.call(Ember.keys(preload), function(key) { - var preloadValue = get(preload, key); - var relationshipMeta = record.constructor.metaForProperty(key); - if (relationshipMeta.isRelationship) { - record._preloadRelationship(key, preloadValue); - } else { - get(record, '_data')[key] = preloadValue; - } - }); - }, - - _preloadRelationship: function(key, preloadValue) { - var relationshipMeta = this.constructor.metaForProperty(key); - var type = relationshipMeta.type; - if (relationshipMeta.kind === 'hasMany'){ - this._preloadHasMany(key, preloadValue, type); - } else { - this._preloadBelongsTo(key, preloadValue, type); - } - }, - - _preloadHasMany: function(key, preloadValue, type) { - Ember.assert("You need to pass in an array to set a hasMany property on a record", Ember.isArray(preloadValue)); - var record = this; - - var recordsToSet = map.call(preloadValue, function(recordToPush) { - return record._convertStringOrNumberIntoRecord(recordToPush, type); - }); - //We use the pathway of setting the hasMany as if it came from the adapter - //because the user told us that they know this relationships exists already - this._relationships[key].updateRecordsFromAdapter(recordsToSet); - }, - - _preloadBelongsTo: function(key, preloadValue, type){ - var recordToSet = this._convertStringOrNumberIntoRecord(preloadValue, type); - - //We use the pathway of setting the hasMany as if it came from the adapter - //because the user told us that they know this relationships exists already - this._relationships[key].setRecord(recordToSet); - }, - - _convertStringOrNumberIntoRecord: function(value, type) { - if (Ember.typeOf(value) === 'string' || Ember.typeOf(value) === 'number'){ - return this.store.recordForId(type, value); - } - return value; - }, - - /** - @method _notifyProperties - @private - */ - _notifyProperties: function(keys) { - Ember.beginPropertyChanges(); - var key; - for (var i = 0, length = keys.length; i < length; i++){ - key = keys[i]; - this.notifyPropertyChange(key); - } - Ember.endPropertyChanges(); - }, - - /** - Returns an object, whose keys are changed properties, and value is - an [oldProp, newProp] array. - - Example - - ```javascript - App.Mascot = DS.Model.extend({ - name: attr('string') - }); - - var person = store.createRecord('person'); - person.changedAttributes(); // {} - person.set('name', 'Tomster'); - person.changedAttributes(); // {name: [undefined, 'Tomster']} - ``` - - @method changedAttributes - @return {Object} an object, whose keys are changed properties, - and value is an [oldProp, newProp] array. - */ - changedAttributes: function() { - var oldData = get(this, '_data'); - var newData = get(this, '_attributes'); - var diffData = {}; - var prop; - - for (prop in newData) { - diffData[prop] = [oldData[prop], newData[prop]]; - } - - return diffData; - }, - - /** - @method adapterWillCommit - @private - */ - adapterWillCommit: function() { - this.send('willCommit'); - }, - - /** - If the adapter did not return a hash in response to a commit, - merge the changed attributes and relationships into the existing - saved data. - - @method adapterDidCommit - */ - adapterDidCommit: function(data) { - set(this, 'isError', false); - - if (data) { - this._data = data; - } else { - Ember.mixin(this._data, this._inFlightAttributes); - } - - this._inFlightAttributes = {}; - - this.send('didCommit'); - this.updateRecordArraysLater(); - - if (!data) { return; } - - this._notifyProperties(Ember.keys(data)); - }, - - /** - @method adapterDidDirty - @private - */ - adapterDidDirty: function() { - this.send('becomeDirty'); - this.updateRecordArraysLater(); - }, - - - /** - @method updateRecordArraysLater - @private - */ - updateRecordArraysLater: function() { - // quick hack (something like this could be pushed into run.once - if (this._updatingRecordArraysLater) { return; } - this._updatingRecordArraysLater = true; - - Ember.run.schedule('actions', this, this.updateRecordArrays); - }, - - /** - @method setupData - @private - @param {Object} data - @param {Boolean} partial the data should be merged into - the existing data, not replace it. - */ - setupData: function(data, partial) { - Ember.assert("Expected an object as `data` in `setupData`", Ember.typeOf(data) === 'object'); - - if (partial) { - Ember.merge(this._data, data); - } else { - this._data = data; - } - - this.pushedData(); - - this._notifyProperties(Ember.keys(data)); - }, - - materializeId: function(id) { - set(this, 'id', id); - }, - - materializeAttributes: function(attributes) { - Ember.assert("Must pass a hash of attributes to materializeAttributes", !!attributes); - merge(this._data, attributes); - }, - - materializeAttribute: function(name, value) { - this._data[name] = value; - }, - - /** - If the model `isDirty` this function will discard any unsaved - changes - - Example - - ```javascript - record.get('name'); // 'Untitled Document' - record.set('name', 'Doc 1'); - record.get('name'); // 'Doc 1' - record.rollback(); - record.get('name'); // 'Untitled Document' - ``` - - @method rollback - */ - rollback: function() { - this._attributes = {}; - - if (get(this, 'isError')) { - this._inFlightAttributes = {}; - set(this, 'isError', false); - } - - //Eventually rollback will always work for relationships - //For now we support it only out of deleted state, because we - //have an explicit way of knowing when the server acked the relationship change - if (get(this, 'isDeleted')) { - this.reconnectRelationships(); - } - - if (get(this, 'isNew')) { - this.clearRelationships(); - } - - if (!get(this, 'isValid')) { - this._inFlightAttributes = {}; - } - - this.send('rolledBack'); - - this._notifyProperties(Ember.keys(this._data)); - - }, - - toStringExtension: function() { - return get(this, 'id'); - }, - - /** - Save the record and persist any changes to the record to an - external source via the adapter. - - Example - - ```javascript - record.set('name', 'Tomster'); - record.save().then(function(){ - // Success callback - }, function() { - // Error callback - }); - ``` - @method save - @return {Promise} a promise that will be resolved when the adapter returns - successfully or rejected if the adapter returns with an error. - */ - save: function() { - var promiseLabel = "DS: Model#save " + this; - var resolver = Ember.RSVP.defer(promiseLabel); - - this.get('store').scheduleSave(this, resolver); - this._inFlightAttributes = this._attributes; - this._attributes = {}; - - return PromiseObject.create({ - promise: resolver.promise - }); - }, - - /** - Reload the record from the adapter. - - This will only work if the record has already finished loading - and has not yet been modified (`isLoaded` but not `isDirty`, - or `isSaving`). - - Example - - ```javascript - App.ModelViewRoute = Ember.Route.extend({ - actions: { - reload: function() { - this.controller.get('model').reload().then(function(model) { - // do something with the reloaded model - }); - } - } - }); - ``` - - @method reload - @return {Promise} a promise that will be resolved with the record when the - adapter returns successfully or rejected if the adapter returns - with an error. - */ - reload: function() { - set(this, 'isReloading', true); - - var record = this; - var promiseLabel = "DS: Model#reload of " + this; - var promise = new Promise(function(resolve){ - record.send('reloadRecord', resolve); - }, promiseLabel).then(function() { - record.set('isReloading', false); - record.set('isError', false); - return record; - }, function(reason) { - record.set('isError', true); - throw reason; - }, "DS: Model#reload complete, update flags")['finally'](function () { - record.updateRecordArrays(); - }); - - return PromiseObject.create({ - promise: promise - }); - }, - - // FOR USE DURING COMMIT PROCESS - - adapterDidUpdateAttribute: function(attributeName, value) { - - // If a value is passed in, update the internal attributes and clear - // the attribute cache so it picks up the new value. Otherwise, - // collapse the current value into the internal attributes because - // the adapter has acknowledged it. - if (value !== undefined) { - this._data[attributeName] = value; - this.notifyPropertyChange(attributeName); - } else { - this._data[attributeName] = this._inFlightAttributes[attributeName]; - } - - this.updateRecordArraysLater(); - }, - - /** - @method adapterDidInvalidate - @private - */ - adapterDidInvalidate: function(errors) { - var recordErrors = get(this, 'errors'); - function addError(name) { - if (errors[name]) { - recordErrors.add(name, errors[name]); - } - } - - this.eachAttribute(addError); - this.eachRelationship(addError); - }, - - /** - @method adapterDidError - @private - */ - adapterDidError: function() { - this.send('becameError'); - set(this, 'isError', true); - }, - - /** - Override the default event firing from Ember.Evented to - also call methods with the given name. - - @method trigger - @private - @param {String} name - */ - trigger: function() { - var length = arguments.length; - var args = new Array(length - 1); - var name = arguments[0]; - - for (var i = 1; i < length; i++ ){ - args[i - 1] = arguments[i]; - } - - Ember.tryInvoke(this, name, args); - this._super.apply(this, arguments); - }, - - triggerLater: function() { - var length = arguments.length; - var args = new Array(length); - - for (var i = 0; i < length; i++ ){ - args[i] = arguments[i]; - } - - if (this._deferredTriggers.push(args) !== 1) { - return; - } - Ember.run.schedule('actions', this, '_triggerDeferredTriggers'); - }, - - _triggerDeferredTriggers: function() { - for (var i=0, l= this._deferredTriggers.length; i<l; i++) { - this.trigger.apply(this, this._deferredTriggers[i]); - } - - this._deferredTriggers.length = 0; - }, - - willDestroy: function() { - this._super(); - this.clearRelationships(); - }, - - // This is a temporary solution until we refactor DS.Model to not - // rely on the data property. - willMergeMixin: function(props) { - Ember.assert('`data` is a reserved property name on DS.Model objects. Please choose a different property name for ' + this.constructor.toString(), !props.data); - } - }); - - Model.reopenClass({ - /** - Alias DS.Model's `create` method to `_create`. This allows us to create DS.Model - instances from within the store, but if end users accidentally call `create()` - (instead of `createRecord()`), we can raise an error. - - @method _create - @private - @static - */ - _create: Model.create, - - /** - Override the class' `create()` method to raise an error. This - prevents end users from inadvertently calling `create()` instead - of `createRecord()`. The store is still able to create instances - by calling the `_create()` method. To create an instance of a - `DS.Model` use [store.createRecord](DS.Store.html#method_createRecord). - - @method create - @private - @static - */ - create: function() { - throw new Ember.Error("You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set."); - } - }); - - __exports__["default"] = Model; - }); -enifed("ember-data/system/model/states", - ["exports"], - function(__exports__) { - "use strict"; - /** - @module ember-data - */ - - var get = Ember.get; - var set = Ember.set; - /* - This file encapsulates the various states that a record can transition - through during its lifecycle. - */ - /** - ### State - - Each record has a `currentState` property that explicitly tracks what - state a record is in at any given time. For instance, if a record is - newly created and has not yet been sent to the adapter to be saved, - it would be in the `root.loaded.created.uncommitted` state. If a - record has had local modifications made to it that are in the - process of being saved, the record would be in the - `root.loaded.updated.inFlight` state. (This state paths will be - explained in more detail below.) - - Events are sent by the record or its store to the record's - `currentState` property. How the state reacts to these events is - dependent on which state it is in. In some states, certain events - will be invalid and will cause an exception to be raised. - - States are hierarchical and every state is a substate of the - `RootState`. For example, a record can be in the - `root.deleted.uncommitted` state, then transition into the - `root.deleted.inFlight` state. If a child state does not implement - an event handler, the state manager will attempt to invoke the event - on all parent states until the root state is reached. The state - hierarchy of a record is described in terms of a path string. You - can determine a record's current state by getting the state's - `stateName` property: - - ```javascript - record.get('currentState.stateName'); - //=> "root.created.uncommitted" - ``` - - The hierarchy of valid states that ship with ember data looks like - this: - - ```text - * root - * deleted - * saved - * uncommitted - * inFlight - * empty - * loaded - * created - * uncommitted - * inFlight - * saved - * updated - * uncommitted - * inFlight - * loading - ``` - - The `DS.Model` states are themselves stateless. What that means is - that, the hierarchical states that each of *those* points to is a - shared data structure. For performance reasons, instead of each - record getting its own copy of the hierarchy of states, each record - points to this global, immutable shared instance. How does a state - know which record it should be acting on? We pass the record - instance into the state's event handlers as the first argument. - - The record passed as the first parameter is where you should stash - state about the record if needed; you should never store data on the state - object itself. - - ### Events and Flags - - A state may implement zero or more events and flags. - - #### Events - - Events are named functions that are invoked when sent to a record. The - record will first look for a method with the given name on the - current state. If no method is found, it will search the current - state's parent, and then its grandparent, and so on until reaching - the top of the hierarchy. If the root is reached without an event - handler being found, an exception will be raised. This can be very - helpful when debugging new features. - - Here's an example implementation of a state with a `myEvent` event handler: - - ```javascript - aState: DS.State.create({ - myEvent: function(manager, param) { - console.log("Received myEvent with", param); - } - }) - ``` - - To trigger this event: - - ```javascript - record.send('myEvent', 'foo'); - //=> "Received myEvent with foo" - ``` - - Note that an optional parameter can be sent to a record's `send()` method, - which will be passed as the second parameter to the event handler. - - Events should transition to a different state if appropriate. This can be - done by calling the record's `transitionTo()` method with a path to the - desired state. The state manager will attempt to resolve the state path - relative to the current state. If no state is found at that path, it will - attempt to resolve it relative to the current state's parent, and then its - parent, and so on until the root is reached. For example, imagine a hierarchy - like this: - - * created - * uncommitted <-- currentState - * inFlight - * updated - * inFlight - - If we are currently in the `uncommitted` state, calling - `transitionTo('inFlight')` would transition to the `created.inFlight` state, - while calling `transitionTo('updated.inFlight')` would transition to - the `updated.inFlight` state. - - Remember that *only events* should ever cause a state transition. You should - never call `transitionTo()` from outside a state's event handler. If you are - tempted to do so, create a new event and send that to the state manager. - - #### Flags - - Flags are Boolean values that can be used to introspect a record's current - state in a more user-friendly way than examining its state path. For example, - instead of doing this: - - ```javascript - var statePath = record.get('stateManager.currentPath'); - if (statePath === 'created.inFlight') { - doSomething(); - } - ``` - - You can say: - - ```javascript - if (record.get('isNew') && record.get('isSaving')) { - doSomething(); - } - ``` - - If your state does not set a value for a given flag, the value will - be inherited from its parent (or the first place in the state hierarchy - where it is defined). - - The current set of flags are defined below. If you want to add a new flag, - in addition to the area below, you will also need to declare it in the - `DS.Model` class. - - - * [isEmpty](DS.Model.html#property_isEmpty) - * [isLoading](DS.Model.html#property_isLoading) - * [isLoaded](DS.Model.html#property_isLoaded) - * [isDirty](DS.Model.html#property_isDirty) - * [isSaving](DS.Model.html#property_isSaving) - * [isDeleted](DS.Model.html#property_isDeleted) - * [isNew](DS.Model.html#property_isNew) - * [isValid](DS.Model.html#property_isValid) - - @namespace DS - @class RootState - */ - - function didSetProperty(record, context) { - if (context.value === context.originalValue) { - delete record._attributes[context.name]; - record.send('propertyWasReset', context.name); - } else if (context.value !== context.oldValue) { - record.send('becomeDirty'); - } - - record.updateRecordArraysLater(); - } - - // Implementation notes: - // - // Each state has a boolean value for all of the following flags: - // - // * isLoaded: The record has a populated `data` property. When a - // record is loaded via `store.find`, `isLoaded` is false - // until the adapter sets it. When a record is created locally, - // its `isLoaded` property is always true. - // * isDirty: The record has local changes that have not yet been - // saved by the adapter. This includes records that have been - // created (but not yet saved) or deleted. - // * isSaving: The record has been committed, but - // the adapter has not yet acknowledged that the changes have - // been persisted to the backend. - // * isDeleted: The record was marked for deletion. When `isDeleted` - // is true and `isDirty` is true, the record is deleted locally - // but the deletion was not yet persisted. When `isSaving` is - // true, the change is in-flight. When both `isDirty` and - // `isSaving` are false, the change has persisted. - // * isError: The adapter reported that it was unable to save - // local changes to the backend. This may also result in the - // record having its `isValid` property become false if the - // adapter reported that server-side validations failed. - // * isNew: The record was created on the client and the adapter - // did not yet report that it was successfully saved. - // * isValid: The adapter did not report any server-side validation - // failures. - - // The dirty state is a abstract state whose functionality is - // shared between the `created` and `updated` states. - // - // The deleted state shares the `isDirty` flag with the - // subclasses of `DirtyState`, but with a very different - // implementation. - // - // Dirty states have three child states: - // - // `uncommitted`: the store has not yet handed off the record - // to be saved. - // `inFlight`: the store has handed off the record to be saved, - // but the adapter has not yet acknowledged success. - // `invalid`: the record has invalid information and cannot be - // send to the adapter yet. - var DirtyState = { - initialState: 'uncommitted', - - // FLAGS - isDirty: true, - - // SUBSTATES - - // When a record first becomes dirty, it is `uncommitted`. - // This means that there are local pending changes, but they - // have not yet begun to be saved, and are not invalid. - uncommitted: { - // EVENTS - didSetProperty: didSetProperty, - - //TODO(Igor) reloading now triggers a - //loadingData event, though it seems fine? - loadingData: Ember.K, - - propertyWasReset: function(record, name) { - var length = Ember.keys(record._attributes); - var stillDirty = length > 0; - - if (!stillDirty) { record.send('rolledBack'); } - }, - - pushedData: Ember.K, - - becomeDirty: Ember.K, - - willCommit: function(record) { - record.transitionTo('inFlight'); - }, - - reloadRecord: function(record, resolve) { - resolve(get(record, 'store').reloadRecord(record)); - }, - - rolledBack: function(record) { - record.transitionTo('loaded.saved'); - }, - - becameInvalid: function(record) { - record.transitionTo('invalid'); - }, - - rollback: function(record) { - record.rollback(); - } - }, - - // Once a record has been handed off to the adapter to be - // saved, it is in the 'in flight' state. Changes to the - // record cannot be made during this window. - inFlight: { - // FLAGS - isSaving: true, - - // EVENTS - didSetProperty: didSetProperty, - becomeDirty: Ember.K, - pushedData: Ember.K, - - unloadRecord: function(record) { - Ember.assert("You can only unload a record which is not inFlight. `" + Ember.inspect(record) + " `", false); - }, - - // TODO: More robust semantics around save-while-in-flight - willCommit: Ember.K, - - didCommit: function(record) { - var dirtyType = get(this, 'dirtyType'); - - record.transitionTo('saved'); - record.send('invokeLifecycleCallbacks', dirtyType); - }, - - becameInvalid: function(record) { - record.transitionTo('invalid'); - record.send('invokeLifecycleCallbacks'); - }, - - becameError: function(record) { - record.transitionTo('uncommitted'); - record.triggerLater('becameError', record); - } - }, - - // A record is in the `invalid` if the adapter has indicated - // the the record failed server-side invalidations. - invalid: { - // FLAGS - isValid: false, - - // EVENTS - deleteRecord: function(record) { - record.transitionTo('deleted.uncommitted'); - record.disconnectRelationships(); - }, - - didSetProperty: function(record, context) { - get(record, 'errors').remove(context.name); - - didSetProperty(record, context); - }, - - becomeDirty: Ember.K, - - willCommit: function(record) { - get(record, 'errors').clear(); - record.transitionTo('inFlight'); - }, - - rolledBack: function(record) { - get(record, 'errors').clear(); - }, - - becameValid: function(record) { - record.transitionTo('uncommitted'); - }, - - invokeLifecycleCallbacks: function(record) { - record.triggerLater('becameInvalid', record); - }, - - exit: function(record) { - record._inFlightAttributes = {}; - } - } - }; - - // The created and updated states are created outside the state - // chart so we can reopen their substates and add mixins as - // necessary. - - function deepClone(object) { - var clone = {}, value; - - for (var prop in object) { - value = object[prop]; - if (value && typeof value === 'object') { - clone[prop] = deepClone(value); - } else { - clone[prop] = value; - } - } - - return clone; - } - - function mixin(original, hash) { - for (var prop in hash) { - original[prop] = hash[prop]; - } - - return original; - } - - function dirtyState(options) { - var newState = deepClone(DirtyState); - return mixin(newState, options); - } - - var createdState = dirtyState({ - dirtyType: 'created', - // FLAGS - isNew: true - }); - - createdState.uncommitted.rolledBack = function(record) { - record.transitionTo('deleted.saved'); - }; - - var updatedState = dirtyState({ - dirtyType: 'updated' - }); - - createdState.uncommitted.deleteRecord = function(record) { - record.disconnectRelationships(); - record.transitionTo('deleted.saved'); - }; - - createdState.uncommitted.rollback = function(record) { - DirtyState.uncommitted.rollback.apply(this, arguments); - record.transitionTo('deleted.saved'); - }; - - createdState.uncommitted.propertyWasReset = Ember.K; - - function assertAgainstUnloadRecord(record) { - Ember.assert("You can only unload a record which is not inFlight. `" + Ember.inspect(record) + "`", false); - } - - updatedState.inFlight.unloadRecord = assertAgainstUnloadRecord; - - updatedState.uncommitted.deleteRecord = function(record) { - record.transitionTo('deleted.uncommitted'); - record.disconnectRelationships(); - }; - - var RootState = { - // FLAGS - isEmpty: false, - isLoading: false, - isLoaded: false, - isDirty: false, - isSaving: false, - isDeleted: false, - isNew: false, - isValid: true, - - // DEFAULT EVENTS - - // Trying to roll back if you're not in the dirty state - // doesn't change your state. For example, if you're in the - // in-flight state, rolling back the record doesn't move - // you out of the in-flight state. - rolledBack: Ember.K, - unloadRecord: function(record) { - // clear relationships before moving to deleted state - // otherwise it fails - record.clearRelationships(); - record.transitionTo('deleted.saved'); - }, - - - propertyWasReset: Ember.K, - - // SUBSTATES - - // A record begins its lifecycle in the `empty` state. - // If its data will come from the adapter, it will - // transition into the `loading` state. Otherwise, if - // the record is being created on the client, it will - // transition into the `created` state. - empty: { - isEmpty: true, - - // EVENTS - loadingData: function(record, promise) { - record._loadingPromise = promise; - record.transitionTo('loading'); - }, - - loadedData: function(record) { - record.transitionTo('loaded.created.uncommitted'); - record.notifyPropertyChange('data'); - }, - - pushedData: function(record) { - record.transitionTo('loaded.saved'); - record.triggerLater('didLoad'); - } - }, - - // A record enters this state when the store asks - // the adapter for its data. It remains in this state - // until the adapter provides the requested data. - // - // Usually, this process is asynchronous, using an - // XHR to retrieve the data. - loading: { - // FLAGS - isLoading: true, - - exit: function(record) { - record._loadingPromise = null; - }, - - // EVENTS - pushedData: function(record) { - record.transitionTo('loaded.saved'); - record.triggerLater('didLoad'); - set(record, 'isError', false); - }, - - becameError: function(record) { - record.triggerLater('becameError', record); - }, - - notFound: function(record) { - record.transitionTo('empty'); - } - }, - - // A record enters this state when its data is populated. - // Most of a record's lifecycle is spent inside substates - // of the `loaded` state. - loaded: { - initialState: 'saved', - - // FLAGS - isLoaded: true, - - //TODO(Igor) Reloading now triggers a loadingData event, - //but it should be ok? - loadingData: Ember.K, - - // SUBSTATES - - // If there are no local changes to a record, it remains - // in the `saved` state. - saved: { - setup: function(record) { - var attrs = record._attributes; - var isDirty = false; - - for (var prop in attrs) { - if (attrs.hasOwnProperty(prop)) { - isDirty = true; - break; - } - } - - if (isDirty) { - record.adapterDidDirty(); - } - }, - - // EVENTS - didSetProperty: didSetProperty, - - pushedData: Ember.K, - - becomeDirty: function(record) { - record.transitionTo('updated.uncommitted'); - }, - - willCommit: function(record) { - record.transitionTo('updated.inFlight'); - }, - - reloadRecord: function(record, resolve) { - resolve(get(record, 'store').reloadRecord(record)); - }, - - deleteRecord: function(record) { - record.transitionTo('deleted.uncommitted'); - record.disconnectRelationships(); - }, - - unloadRecord: function(record) { - // clear relationships before moving to deleted state - // otherwise it fails - record.clearRelationships(); - record.transitionTo('deleted.saved'); - }, - - didCommit: function(record) { - record.send('invokeLifecycleCallbacks', get(record, 'lastDirtyType')); - }, - - // loaded.saved.notFound would be triggered by a failed - // `reload()` on an unchanged record - notFound: Ember.K - - }, - - // A record is in this state after it has been locally - // created but before the adapter has indicated that - // it has been saved. - created: createdState, - - // A record is in this state if it has already been - // saved to the server, but there are new local changes - // that have not yet been saved. - updated: updatedState - }, - - // A record is in this state if it was deleted from the store. - deleted: { - initialState: 'uncommitted', - dirtyType: 'deleted', - - // FLAGS - isDeleted: true, - isLoaded: true, - isDirty: true, - - // TRANSITIONS - setup: function(record) { - record.updateRecordArrays(); - }, - - // SUBSTATES - - // When a record is deleted, it enters the `start` - // state. It will exit this state when the record - // starts to commit. - uncommitted: { - - // EVENTS - - willCommit: function(record) { - record.transitionTo('inFlight'); - }, - - rollback: function(record) { - record.rollback(); - }, - - becomeDirty: Ember.K, - deleteRecord: Ember.K, - - rolledBack: function(record) { - record.transitionTo('loaded.saved'); - } - }, - - // After a record starts committing, but - // before the adapter indicates that the deletion - // has saved to the server, a record is in the - // `inFlight` substate of `deleted`. - inFlight: { - // FLAGS - isSaving: true, - - // EVENTS - - unloadRecord: assertAgainstUnloadRecord, - - // TODO: More robust semantics around save-while-in-flight - willCommit: Ember.K, - didCommit: function(record) { - record.transitionTo('saved'); - - record.send('invokeLifecycleCallbacks'); - }, - - becameError: function(record) { - record.transitionTo('uncommitted'); - record.triggerLater('becameError', record); - } - }, - - // Once the adapter indicates that the deletion has - // been saved, the record enters the `saved` substate - // of `deleted`. - saved: { - // FLAGS - isDirty: false, - - setup: function(record) { - var store = get(record, 'store'); - store.dematerializeRecord(record); - }, - - invokeLifecycleCallbacks: function(record) { - record.triggerLater('didDelete', record); - record.triggerLater('didCommit', record); - }, - - willCommit: Ember.K, - - didCommit: Ember.K - } - }, - - invokeLifecycleCallbacks: function(record, dirtyType) { - if (dirtyType === 'created') { - record.triggerLater('didCreate', record); - } else { - record.triggerLater('didUpdate', record); - } - - record.triggerLater('didCommit', record); - } - }; - - function wireState(object, parent, name) { - /*jshint proto:true*/ - // TODO: Use Object.create and copy instead - object = mixin(parent ? Ember.create(parent) : {}, object); - object.parentState = parent; - object.stateName = name; - - for (var prop in object) { - if (!object.hasOwnProperty(prop) || prop === 'parentState' || prop === 'stateName') { continue; } - if (typeof object[prop] === 'object') { - object[prop] = wireState(object[prop], object, name + "." + prop); - } - } - - return object; - } - - RootState = wireState(RootState, null, "root"); - - __exports__["default"] = RootState; - }); -enifed("ember-data/system/promise_proxies", - ["exports"], - function(__exports__) { - "use strict"; - var Promise = Ember.RSVP.Promise; - var get = Ember.get; - - /** - A `PromiseArray` is an object that acts like both an `Ember.Array` - and a promise. When the promise is resolved the resulting value - will be set to the `PromiseArray`'s `content` property. This makes - it easy to create data bindings with the `PromiseArray` that will be - updated when the promise resolves. - - For more information see the [Ember.PromiseProxyMixin - documentation](/api/classes/Ember.PromiseProxyMixin.html). - - Example - - ```javascript - var promiseArray = DS.PromiseArray.create({ - promise: $.getJSON('/some/remote/data.json') - }); - - promiseArray.get('length'); // 0 - - promiseArray.then(function() { - promiseArray.get('length'); // 100 - }); - ``` - - @class PromiseArray - @namespace DS - @extends Ember.ArrayProxy - @uses Ember.PromiseProxyMixin - */ - var PromiseArray = Ember.ArrayProxy.extend(Ember.PromiseProxyMixin); - - /** - A `PromiseObject` is an object that acts like both an `Ember.Object` - and a promise. When the promise is resolved, then the resulting value - will be set to the `PromiseObject`'s `content` property. This makes - it easy to create data bindings with the `PromiseObject` that will - be updated when the promise resolves. - - For more information see the [Ember.PromiseProxyMixin - documentation](/api/classes/Ember.PromiseProxyMixin.html). - - Example - - ```javascript - var promiseObject = DS.PromiseObject.create({ - promise: $.getJSON('/some/remote/data.json') - }); - - promiseObject.get('name'); // null - - promiseObject.then(function() { - promiseObject.get('name'); // 'Tomster' - }); - ``` - - @class PromiseObject - @namespace DS - @extends Ember.ObjectProxy - @uses Ember.PromiseProxyMixin - */ - var PromiseObject = Ember.ObjectProxy.extend(Ember.PromiseProxyMixin); - - var promiseObject = function(promise, label) { - return PromiseObject.create({ - promise: Promise.resolve(promise, label) - }); - }; - - var promiseArray = function(promise, label) { - return PromiseArray.create({ - promise: Promise.resolve(promise, label) - }); - }; - - /** - A PromiseManyArray is a PromiseArray that also proxies certain method calls - to the underlying manyArray. - Right now we proxy: - `reload()` - `createRecord()` - `on()` - `one()` - `trigger()` - `off()` - `has()` - */ - - function proxyToContent(method) { - return function() { - var content = get(this, 'content'); - return content[method].apply(content, arguments); - }; - } - - var PromiseManyArray = PromiseArray.extend({ - reload: function() { - //I don't think this should ever happen right now, but worth guarding if we refactor the async relationships - Ember.assert('You are trying to reload an async manyArray before it has been created', get(this, 'content')); - return get(this, 'content').reload(); - }, - - createRecord: proxyToContent('createRecord'), - - on: proxyToContent('on'), - - one: proxyToContent('one'), - - trigger: proxyToContent('trigger'), - - off: proxyToContent('off'), - - has: proxyToContent('has') - }); - - var promiseManyArray = function(promise, label) { - return PromiseManyArray.create({ - promise: Promise.resolve(promise, label) - }); - }; - - - __exports__.PromiseArray = PromiseArray; - __exports__.PromiseObject = PromiseObject; - __exports__.PromiseManyArray = PromiseManyArray; - __exports__.promiseArray = promiseArray; - __exports__.promiseObject = promiseObject; - __exports__.promiseManyArray = promiseManyArray; - }); -enifed("ember-data/system/record_array_manager", - ["ember-data/system/record_arrays","ember-data/system/map","exports"], - function(__dependency1__, __dependency2__, __exports__) { - "use strict"; - /** - @module ember-data - */ - - var RecordArray = __dependency1__.RecordArray; - var FilteredRecordArray = __dependency1__.FilteredRecordArray; - var AdapterPopulatedRecordArray = __dependency1__.AdapterPopulatedRecordArray; - var ManyArray = __dependency1__.ManyArray; - var MapWithDefault = __dependency2__.MapWithDefault; - var OrderedSet = __dependency2__.OrderedSet; - var get = Ember.get; - var forEach = Ember.EnumerableUtils.forEach; - var indexOf = Ember.EnumerableUtils.indexOf; - - /** - @class RecordArrayManager - @namespace DS - @private - @extends Ember.Object - */ - __exports__["default"] = Ember.Object.extend({ - init: function() { - this.filteredRecordArrays = MapWithDefault.create({ - defaultValue: function() { return []; } - }); - - this.changedRecords = []; - this._adapterPopulatedRecordArrays = []; - }, - - recordDidChange: function(record) { - if (this.changedRecords.push(record) !== 1) { return; } - - Ember.run.schedule('actions', this, this.updateRecordArrays); - }, - - recordArraysForRecord: function(record) { - record._recordArrays = record._recordArrays || OrderedSet.create(); - return record._recordArrays; - }, - - /** - This method is invoked whenever data is loaded into the store by the - adapter or updated by the adapter, or when a record has changed. - - It updates all record arrays that a record belongs to. - - To avoid thrashing, it only runs at most once per run loop. - - @method updateRecordArrays - @param {Class} type - @param {Number|String} clientId - */ - updateRecordArrays: function() { - forEach(this.changedRecords, function(record) { - if (get(record, 'isDeleted')) { - this._recordWasDeleted(record); - } else { - this._recordWasChanged(record); - } - }, this); - - this.changedRecords.length = 0; - }, - - _recordWasDeleted: function (record) { - var recordArrays = record._recordArrays; - - if (!recordArrays) { return; } - - recordArrays.forEach(function(array){ - array.removeRecord(record); - }); - - record._recordArrays = null; - }, - - _recordWasChanged: function (record) { - var type = record.constructor; - var recordArrays = this.filteredRecordArrays.get(type); - var filter; - - forEach(recordArrays, function(array) { - filter = get(array, 'filterFunction'); - this.updateRecordArray(array, filter, type, record); - }, this); - - // loop through all manyArrays containing an unloaded copy of this - // clientId and notify them that the record was loaded. - var manyArrays = record._loadingRecordArrays; - - if (manyArrays) { - for (var i=0, l=manyArrays.length; i<l; i++) { - manyArrays[i].loadedRecord(); - } - - record._loadingRecordArrays = []; - } - }, - - /** - Update an individual filter. - - @method updateRecordArray - @param {DS.FilteredRecordArray} array - @param {Function} filter - @param {Class} type - @param {Number|String} clientId - */ - updateRecordArray: function(array, filter, type, record) { - var shouldBeInArray; - - if (!filter) { - shouldBeInArray = true; - } else { - shouldBeInArray = filter(record); - } - - var recordArrays = this.recordArraysForRecord(record); - - if (shouldBeInArray) { - if (!recordArrays.has(array)) { - array.pushRecord(record); - recordArrays.add(array); - } - } else if (!shouldBeInArray) { - recordArrays["delete"](array); - array.removeRecord(record); - } - }, - - /** - This method is invoked if the `filterFunction` property is - changed on a `DS.FilteredRecordArray`. - - It essentially re-runs the filter from scratch. This same - method is invoked when the filter is created in th first place. - - @method updateFilter - @param {Array} array - @param {String} type - @param {Function} filter - */ - updateFilter: function(array, type, filter) { - var typeMap = this.store.typeMapFor(type); - var records = typeMap.records, record; - - for (var i=0, l=records.length; i<l; i++) { - record = records[i]; - - if (!get(record, 'isDeleted') && !get(record, 'isEmpty')) { - this.updateRecordArray(array, filter, type, record); - } - } - }, - - /** - Create a `DS.ManyArray` for a type and list of record references, and index - the `ManyArray` under each reference. This allows us to efficiently remove - records from `ManyArray`s when they are deleted. - - @method createManyArray - @param {Class} type - @param {Array} references - @return {DS.ManyArray} - */ - createManyArray: function(type, records) { - var manyArray = ManyArray.create({ - type: type, - content: records, - store: this.store - }); - - forEach(records, function(record) { - var arrays = this.recordArraysForRecord(record); - arrays.add(manyArray); - }, this); - - return manyArray; - }, - - /** - Create a `DS.RecordArray` for a type and register it for updates. - - @method createRecordArray - @param {Class} type - @return {DS.RecordArray} - */ - createRecordArray: function(type) { - var array = RecordArray.create({ - type: type, - content: Ember.A(), - store: this.store, - isLoaded: true - }); - - this.registerFilteredRecordArray(array, type); - - return array; - }, - - /** - Create a `DS.FilteredRecordArray` for a type and register it for updates. - - @method createFilteredRecordArray - @param {Class} type - @param {Function} filter - @param {Object} query (optional - @return {DS.FilteredRecordArray} - */ - createFilteredRecordArray: function(type, filter, query) { - var array = FilteredRecordArray.create({ - query: query, - type: type, - content: Ember.A(), - store: this.store, - manager: this, - filterFunction: filter - }); - - this.registerFilteredRecordArray(array, type, filter); - - return array; - }, - - /** - Create a `DS.AdapterPopulatedRecordArray` for a type with given query. - - @method createAdapterPopulatedRecordArray - @param {Class} type - @param {Object} query - @return {DS.AdapterPopulatedRecordArray} - */ - createAdapterPopulatedRecordArray: function(type, query) { - var array = AdapterPopulatedRecordArray.create({ - type: type, - query: query, - content: Ember.A(), - store: this.store, - manager: this - }); - - this._adapterPopulatedRecordArrays.push(array); - - return array; - }, - - /** - Register a RecordArray for a given type to be backed by - a filter function. This will cause the array to update - automatically when records of that type change attribute - values or states. - - @method registerFilteredRecordArray - @param {DS.RecordArray} array - @param {Class} type - @param {Function} filter - */ - registerFilteredRecordArray: function(array, type, filter) { - var recordArrays = this.filteredRecordArrays.get(type); - recordArrays.push(array); - - this.updateFilter(array, type, filter); - }, - - /** - Unregister a FilteredRecordArray. - So manager will not update this array. - - @method unregisterFilteredRecordArray - @param {DS.RecordArray} array - */ - unregisterFilteredRecordArray: function(array) { - var recordArrays = this.filteredRecordArrays.get(array.type); - var index = indexOf(recordArrays, array); - recordArrays.splice(index, 1); - }, - - // Internally, we maintain a map of all unloaded IDs requested by - // a ManyArray. As the adapter loads data into the store, the - // store notifies any interested ManyArrays. When the ManyArray's - // total number of loading records drops to zero, it becomes - // `isLoaded` and fires a `didLoad` event. - registerWaitingRecordArray: function(record, array) { - var loadingRecordArrays = record._loadingRecordArrays || []; - loadingRecordArrays.push(array); - record._loadingRecordArrays = loadingRecordArrays; - }, - - willDestroy: function(){ - this._super(); - - forEach(flatten(values(this.filteredRecordArrays.values)), destroy); - forEach(this._adapterPopulatedRecordArrays, destroy); - } - }); - - function values(obj) { - var result = []; - var keys = Ember.keys(obj); - - for (var i = 0; i < keys.length; i++) { - result.push(obj[keys[i]]); - } - - return result; - } - - function destroy(entry) { - entry.destroy(); - } - - function flatten(list) { - var length = list.length; - var result = Ember.A(); - - for (var i = 0; i < length; i++) { - result = result.concat(list[i]); - } - - return result; - } - }); -enifed("ember-data/system/record_arrays", - ["ember-data/system/record_arrays/record_array","ember-data/system/record_arrays/filtered_record_array","ember-data/system/record_arrays/adapter_populated_record_array","ember-data/system/record_arrays/many_array","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) { - "use strict"; - /** - @module ember-data - */ - - var RecordArray = __dependency1__["default"]; - var FilteredRecordArray = __dependency2__["default"]; - var AdapterPopulatedRecordArray = __dependency3__["default"]; - var ManyArray = __dependency4__["default"]; - - __exports__.RecordArray = RecordArray; - __exports__.FilteredRecordArray = FilteredRecordArray; - __exports__.AdapterPopulatedRecordArray = AdapterPopulatedRecordArray; - __exports__.ManyArray = ManyArray; - }); -enifed("ember-data/system/record_arrays/adapter_populated_record_array", - ["ember-data/system/record_arrays/record_array","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var RecordArray = __dependency1__["default"]; - /** - @module ember-data - */ - - var get = Ember.get; - - function cloneNull(source) { - var clone = Ember.create(null); - for (var key in source) { - clone[key] = source[key]; - } - return clone; - } - - /** - Represents an ordered list of records whose order and membership is - determined by the adapter. For example, a query sent to the adapter - may trigger a search on the server, whose results would be loaded - into an instance of the `AdapterPopulatedRecordArray`. - - @class AdapterPopulatedRecordArray - @namespace DS - @extends DS.RecordArray - */ - __exports__["default"] = RecordArray.extend({ - query: null, - - replace: function() { - var type = get(this, 'type').toString(); - throw new Error("The result of a server query (on " + type + ") is immutable."); - }, - - /** - @method load - @private - @param {Array} data - */ - load: function(data) { - var store = get(this, 'store'); - var type = get(this, 'type'); - var records = store.pushMany(type, data); - var meta = store.metadataFor(type); - - this.setProperties({ - content: Ember.A(records), - isLoaded: true, - meta: cloneNull(meta) - }); - - records.forEach(function(record) { - this.manager.recordArraysForRecord(record).add(this); - }, this); - - // TODO: should triggering didLoad event be the last action of the runLoop? - Ember.run.once(this, 'trigger', 'didLoad'); - } - }); - }); -enifed("ember-data/system/record_arrays/filtered_record_array", - ["ember-data/system/record_arrays/record_array","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var RecordArray = __dependency1__["default"]; - - /** - @module ember-data - */ - - var get = Ember.get; - - /** - Represents a list of records whose membership is determined by the - store. As records are created, loaded, or modified, the store - evaluates them to determine if they should be part of the record - array. - - @class FilteredRecordArray - @namespace DS - @extends DS.RecordArray - */ - __exports__["default"] = RecordArray.extend({ - /** - The filterFunction is a function used to test records from the store to - determine if they should be part of the record array. - - Example - - ```javascript - var allPeople = store.all('person'); - allPeople.mapBy('name'); // ["Tom Dale", "Yehuda Katz", "Trek Glowacki"] - - var people = store.filter('person', function(person) { - if (person.get('name').match(/Katz$/)) { return true; } - }); - people.mapBy('name'); // ["Yehuda Katz"] - - var notKatzFilter = function(person) { - return !person.get('name').match(/Katz$/); - }; - people.set('filterFunction', notKatzFilter); - people.mapBy('name'); // ["Tom Dale", "Trek Glowacki"] - ``` - - @method filterFunction - @param {DS.Model} record - @return {Boolean} `true` if the record should be in the array - */ - filterFunction: null, - isLoaded: true, - - replace: function() { - var type = get(this, 'type').toString(); - throw new Error("The result of a client-side filter (on " + type + ") is immutable."); - }, - - /** - @method updateFilter - @private - */ - _updateFilter: function() { - var manager = get(this, 'manager'); - manager.updateFilter(this, get(this, 'type'), get(this, 'filterFunction')); - }, - - updateFilter: Ember.observer(function() { - Ember.run.once(this, this._updateFilter); - }, 'filterFunction'), - - /** - @method _unregisterFromManager - @private - */ - _unregisterFromManager: function(){ - this.manager.unregisterFilteredRecordArray(this); - }, - - willDestroy: function(){ - this._unregisterFromManager(); - this._super(); - } - }); - }); -enifed("ember-data/system/record_arrays/many_array", - ["ember-data/system/record_arrays/record_array","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var RecordArray = __dependency1__["default"]; - - /** - @module ember-data - */ - - var get = Ember.get, set = Ember.set; - - /** - A `ManyArray` is a `RecordArray` that represents the contents of a has-many - relationship. - - The `ManyArray` is instantiated lazily the first time the relationship is - requested. - - ### Inverses - - Often, the relationships in Ember Data applications will have - an inverse. For example, imagine the following models are - defined: - - ```javascript - App.Post = DS.Model.extend({ - comments: DS.hasMany('comment') - }); - - App.Comment = DS.Model.extend({ - post: DS.belongsTo('post') - }); - ``` - - If you created a new instance of `App.Post` and added - a `App.Comment` record to its `comments` has-many - relationship, you would expect the comment's `post` - property to be set to the post that contained - the has-many. - - We call the record to which a relationship belongs the - relationship's _owner_. - - @class ManyArray - @namespace DS - @extends DS.RecordArray - */ - __exports__["default"] = RecordArray.extend({ - init: function() { - this._super.apply(this, arguments); - }, - - /** - `true` if the relationship is polymorphic, `false` otherwise. - - @property {Boolean} isPolymorphic - @private - */ - isPolymorphic: false, - - /** - The loading state of this array - - @property {Boolean} isLoaded - */ - isLoaded: false, - - /** - The relationship which manages this array. - - @property {ManyRelationship} relationship - @private - */ - relationship: null, - - - /** - Used for async `hasMany` arrays - to keep track of when they will resolve. - - @property {Ember.RSVP.Promise} promise - @private - */ - promise: null, - - /** - @method loadingRecordsCount - @param {Number} count - @private - */ - loadingRecordsCount: function(count) { - this.loadingRecordsCount = count; - }, - - /** - @method loadedRecord - @private - */ - loadedRecord: function() { - this.loadingRecordsCount--; - if (this.loadingRecordsCount === 0) { - set(this, 'isLoaded', true); - this.trigger('didLoad'); - } - }, - - replaceContent: function(idx, amt, objects){ - var records; - if (amt > 0){ - records = get(this, 'content').slice(idx, idx+amt); - this.get('relationship').removeRecords(records); - } - if (objects){ - this.get('relationship').addRecords(objects, idx); - } - }, - /** - @method reload - @public - */ - reload: function() { - return this.relationship.reload(); - }, - - /** - Create a child record within the owner - - @method createRecord - @private - @param {Object} hash - @return {DS.Model} record - */ - createRecord: function(hash) { - var store = get(this, 'store'); - var type = get(this, 'type'); - var record; - - Ember.assert("You cannot add '" + type.typeKey + "' records to this polymorphic relationship.", !get(this, 'isPolymorphic')); - - record = store.createRecord(type, hash); - this.pushObject(record); - - return record; - } - }); - }); -enifed("ember-data/system/record_arrays/record_array", - ["ember-data/system/promise_proxies","exports"], - function(__dependency1__, __exports__) { - "use strict"; - /** - @module ember-data - */ - - var PromiseArray = __dependency1__.PromiseArray; - var get = Ember.get; - - /** - A record array is an array that contains records of a certain type. The record - array materializes records as needed when they are retrieved for the first - time. You should not create record arrays yourself. Instead, an instance of - `DS.RecordArray` or its subclasses will be returned by your application's store - in response to queries. - - @class RecordArray - @namespace DS - @extends Ember.ArrayProxy - @uses Ember.Evented - */ - - __exports__["default"] = Ember.ArrayProxy.extend(Ember.Evented, { - /** - The model type contained by this record array. - - @property type - @type DS.Model - */ - type: null, - - /** - The array of client ids backing the record array. When a - record is requested from the record array, the record - for the client id at the same index is materialized, if - necessary, by the store. - - @property content - @private - @type Ember.Array - */ - content: null, - - /** - The flag to signal a `RecordArray` is currently loading data. - - Example - - ```javascript - var people = store.all('person'); - people.get('isLoaded'); // true - ``` - - @property isLoaded - @type Boolean - */ - isLoaded: false, - /** - The flag to signal a `RecordArray` is currently loading data. - - Example - - ```javascript - var people = store.all('person'); - people.get('isUpdating'); // false - people.update(); - people.get('isUpdating'); // true - ``` - - @property isUpdating - @type Boolean - */ - isUpdating: false, - - /** - The store that created this record array. - - @property store - @private - @type DS.Store - */ - store: null, - - /** - Retrieves an object from the content by index. - - @method objectAtContent - @private - @param {Number} index - @return {DS.Model} record - */ - objectAtContent: function(index) { - var content = get(this, 'content'); - - return content.objectAt(index); - }, - - /** - Used to get the latest version of all of the records in this array - from the adapter. - - Example - - ```javascript - var people = store.all('person'); - people.get('isUpdating'); // false - people.update(); - people.get('isUpdating'); // true - ``` - - @method update - */ - update: function() { - if (get(this, 'isUpdating')) { return; } - - var store = get(this, 'store'); - var type = get(this, 'type'); - - return store.fetchAll(type, this); - }, - - /** - Adds a record to the `RecordArray` without duplicates - - @method addRecord - @private - @param {DS.Model} record - @param {DS.Model} an optional index to insert at - */ - addRecord: function(record, idx) { - var content = get(this, 'content'); - if (idx === undefined) { - content.addObject(record); - } else { - if (!content.contains(record)) { - content.insertAt(idx, record); - } - } - }, - - /** - Adds a record to the `RecordArray`, but allows duplicates - - @method pushRecord - @private - @param {DS.Model} record - */ - pushRecord: function(record) { - get(this, 'content').pushObject(record); - }, - - - /** - Removes a record to the `RecordArray`. - - @method removeRecord - @private - @param {DS.Model} record - */ - removeRecord: function(record) { - get(this, 'content').removeObject(record); - }, - - /** - Saves all of the records in the `RecordArray`. - - Example - - ```javascript - var messages = store.all('message'); - messages.forEach(function(message) { - message.set('hasBeenSeen', true); - }); - messages.save(); - ``` - - @method save - @return {DS.PromiseArray} promise - */ - save: function() { - var promiseLabel = "DS: RecordArray#save " + get(this, 'type'); - var promise = Ember.RSVP.all(this.invoke("save"), promiseLabel).then(function(array) { - return Ember.A(array); - }, null, "DS: RecordArray#save apply Ember.NativeArray"); - - return PromiseArray.create({ promise: promise }); - }, - - _dissociateFromOwnRecords: function() { - var array = this; - - this.forEach(function(record){ - var recordArrays = record._recordArrays; - - if (recordArrays) { - recordArrays["delete"](array); - } - }); - }, - - willDestroy: function(){ - this._dissociateFromOwnRecords(); - this._super(); - } - }); - }); -enifed("ember-data/system/relationship-meta", - ["ember-inflector/system","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var singularize = __dependency1__.singularize; - - function typeForRelationshipMeta(store, meta) { - var typeKey, type; - - typeKey = meta.type || meta.key; - if (typeof typeKey === 'string') { - if (meta.kind === 'hasMany') { - typeKey = singularize(typeKey); - } - type = store.modelFor(typeKey); - } else { - type = meta.type; - } - - return type; - } - - __exports__.typeForRelationshipMeta = typeForRelationshipMeta;function relationshipFromMeta(store, meta) { - return { - key: meta.key, - kind: meta.kind, - type: typeForRelationshipMeta(store, meta), - options: meta.options, - parentType: meta.parentType, - isRelationship: true - }; - } - - __exports__.relationshipFromMeta = relationshipFromMeta; - }); -enifed("ember-data/system/relationships", - ["./relationships/belongs_to","./relationships/has_many","ember-data/system/relationships/ext","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __exports__) { - "use strict"; - /** - @module ember-data - */ - - var belongsTo = __dependency1__["default"]; - var hasMany = __dependency2__["default"]; - - - __exports__.belongsTo = belongsTo; - __exports__.hasMany = hasMany; - }); -enifed("ember-data/system/relationships/belongs_to", - ["ember-data/system/model","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var Model = __dependency1__.Model; - - - /** - `DS.belongsTo` is used to define One-To-One and One-To-Many - relationships on a [DS.Model](/api/data/classes/DS.Model.html). - - - `DS.belongsTo` takes an optional hash as a second parameter, currently - supported options are: - - - `async`: A boolean value used to explicitly declare this to be an async relationship. - - `inverse`: A string used to identify the inverse property on a - related model in a One-To-Many relationship. See [Explicit Inverses](#toc_explicit-inverses) - - #### One-To-One - To declare a one-to-one relationship between two models, use - `DS.belongsTo`: - - ```javascript - App.User = DS.Model.extend({ - profile: DS.belongsTo('profile') - }); - - App.Profile = DS.Model.extend({ - user: DS.belongsTo('user') - }); - ``` - - #### One-To-Many - To declare a one-to-many relationship between two models, use - `DS.belongsTo` in combination with `DS.hasMany`, like this: - - ```javascript - App.Post = DS.Model.extend({ - comments: DS.hasMany('comment') - }); - - App.Comment = DS.Model.extend({ - post: DS.belongsTo('post') - }); - ``` - - @namespace - @method belongsTo - @for DS - @param {String or DS.Model} type the model type of the relationship - @param {Object} options a hash of options - @return {Ember.computed} relationship - */ - function belongsTo(type, options) { - if (typeof type === 'object') { - options = type; - type = undefined; - } else { - Ember.assert("The first argument to DS.belongsTo must be a string representing a model type key, e.g. use DS.belongsTo('person') to define a relation to the App.Person model", !!type && (typeof type === 'string' || Model.detect(type))); - } - - options = options || {}; - - var meta = { - type: type, - isRelationship: true, - options: options, - kind: 'belongsTo', - key: null - }; - - return Ember.computed(function(key, value) { - if (arguments.length>1) { - if ( value === undefined ) { - value = null; - } - if (value && value.then) { - this._relationships[key].setRecordPromise(value); - } else { - this._relationships[key].setRecord(value); - } - } - - return this._relationships[key].getRecord(); - }).meta(meta); - } - - /** - These observers observe all `belongsTo` relationships on the record. See - `relationships/ext` to see how these observers get their dependencies. - - @class Model - @namespace DS - */ - Model.reopen({ - notifyBelongsToAdded: function(key, relationship) { - this.notifyPropertyChange(key); - }, - - notifyBelongsToRemoved: function(key) { - this.notifyPropertyChange(key); - } - }); - - __exports__["default"] = belongsTo; - }); -enifed("ember-data/system/relationships/ext", - ["ember-data/system/relationship-meta","ember-data/system/model","ember-data/system/map"], - function(__dependency1__, __dependency2__, __dependency3__) { - "use strict"; - var typeForRelationshipMeta = __dependency1__.typeForRelationshipMeta; - var relationshipFromMeta = __dependency1__.relationshipFromMeta; - var Model = __dependency2__.Model; - var Map = __dependency3__.Map; - var MapWithDefault = __dependency3__.MapWithDefault; - - var get = Ember.get; - var filter = Ember.ArrayPolyfills.filter; - - /** - @module ember-data - */ - - /* - This file defines several extensions to the base `DS.Model` class that - add support for one-to-many relationships. - */ - - /** - @class Model - @namespace DS - */ - Model.reopen({ - - /** - This Ember.js hook allows an object to be notified when a property - is defined. - - In this case, we use it to be notified when an Ember Data user defines a - belongs-to relationship. In that case, we need to set up observers for - each one, allowing us to track relationship changes and automatically - reflect changes in the inverse has-many array. - - This hook passes the class being set up, as well as the key and value - being defined. So, for example, when the user does this: - - ```javascript - DS.Model.extend({ - parent: DS.belongsTo('user') - }); - ``` - - This hook would be called with "parent" as the key and the computed - property returned by `DS.belongsTo` as the value. - - @method didDefineProperty - @param {Object} proto - @param {String} key - @param {Ember.ComputedProperty} value - */ - didDefineProperty: function(proto, key, value) { - // Check if the value being set is a computed property. - if (value instanceof Ember.ComputedProperty) { - - // If it is, get the metadata for the relationship. This is - // populated by the `DS.belongsTo` helper when it is creating - // the computed property. - var meta = value.meta(); - - meta.parentType = proto.constructor; - } - } - }); - - /* - These DS.Model extensions add class methods that provide relationship - introspection abilities about relationships. - - A note about the computed properties contained here: - - **These properties are effectively sealed once called for the first time.** - To avoid repeatedly doing expensive iteration over a model's fields, these - values are computed once and then cached for the remainder of the runtime of - your application. - - If your application needs to modify a class after its initial definition - (for example, using `reopen()` to add additional attributes), make sure you - do it before using your model with the store, which uses these properties - extensively. - */ - - Model.reopenClass({ - - /** - For a given relationship name, returns the model type of the relationship. - - For example, if you define a model like this: - - ```javascript - App.Post = DS.Model.extend({ - comments: DS.hasMany('comment') - }); - ``` - - Calling `App.Post.typeForRelationship('comments')` will return `App.Comment`. - - @method typeForRelationship - @static - @param {String} name the name of the relationship - @return {subclass of DS.Model} the type of the relationship, or undefined - */ - typeForRelationship: function(name) { - var relationship = get(this, 'relationshipsByName').get(name); - return relationship && relationship.type; - }, - - inverseMap: Ember.computed(function() { - return Ember.create(null); - }), - - /** - Find the relationship which is the inverse of the one asked for. - - For example, if you define models like this: - - ```javascript - App.Post = DS.Model.extend({ - comments: DS.hasMany('message') - }); - - App.Message = DS.Model.extend({ - owner: DS.belongsTo('post') - }); - ``` - - App.Post.inverseFor('comments') -> {type: App.Message, name:'owner', kind:'belongsTo'} - App.Message.inverseFor('owner') -> {type: App.Post, name:'comments', kind:'hasMany'} - - @method inverseFor - @static - @param {String} name the name of the relationship - @return {Object} the inverse relationship, or null - */ - inverseFor: function(name) { - var inverseMap = get(this, 'inverseMap'); - if (inverseMap[name]) { - return inverseMap[name]; - } else { - var inverse = this._findInverseFor(name); - inverseMap[name] = inverse; - return inverse; - } - }, - - //Calculate the inverse, ignoring the cache - _findInverseFor: function(name) { - - var inverseType = this.typeForRelationship(name); - if (!inverseType) { - return null; - } - - //If inverse is manually specified to be null, like `comments: DS.hasMany('message', {inverse: null})` - var options = this.metaForProperty(name).options; - if (options.inverse === null) { return null; } - - var inverseName, inverseKind, inverse; - - //If inverse is specified manually, return the inverse - if (options.inverse) { - inverseName = options.inverse; - inverse = Ember.get(inverseType, 'relationshipsByName').get(inverseName); - - Ember.assert("We found no inverse relationships by the name of '" + inverseName + "' on the '" + inverseType.typeKey + - "' model. This is most likely due to a missing attribute on your model definition.", !Ember.isNone(inverse)); - - inverseKind = inverse.kind; - } else { - //No inverse was specified manually, we need to use a heuristic to guess one - var possibleRelationships = findPossibleInverses(this, inverseType); - - if (possibleRelationships.length === 0) { return null; } - - var filteredRelationships = filter.call(possibleRelationships, function(possibleRelationship) { - var optionsForRelationship = inverseType.metaForProperty(possibleRelationship.name).options; - return name === optionsForRelationship.inverse; - }); - - Ember.assert("You defined the '" + name + "' relationship on " + this + ", but you defined the inverse relationships of type " + - inverseType.toString() + " multiple times. Look at http://emberjs.com/guides/models/defining-models/#toc_explicit-inverses for how to explicitly specify inverses", - filteredRelationships.length < 2); - - if (filteredRelationships.length === 1 ) { - possibleRelationships = filteredRelationships; - } - - Ember.assert("You defined the '" + name + "' relationship on " + this + ", but multiple possible inverse relationships of type " + - this + " were found on " + inverseType + ". Look at http://emberjs.com/guides/models/defining-models/#toc_explicit-inverses for how to explicitly specify inverses", - possibleRelationships.length === 1); - - inverseName = possibleRelationships[0].name; - inverseKind = possibleRelationships[0].kind; - } - - function findPossibleInverses(type, inverseType, relationshipsSoFar) { - var possibleRelationships = relationshipsSoFar || []; - - var relationshipMap = get(inverseType, 'relationships'); - if (!relationshipMap) { return; } - - var relationships = relationshipMap.get(type); - - relationships = filter.call(relationships, function(relationship) { - var optionsForRelationship = inverseType.metaForProperty(relationship.name).options; - - if (!optionsForRelationship.inverse){ - return true; - } - - return name === optionsForRelationship.inverse; - }); - - if (relationships) { - possibleRelationships.push.apply(possibleRelationships, relationships); - } - - //Recurse to support polymorphism - if (type.superclass) { - findPossibleInverses(type.superclass, inverseType, possibleRelationships); - } - - return possibleRelationships; - } - - return { - type: inverseType, - name: inverseName, - kind: inverseKind - }; - }, - - /** - The model's relationships as a map, keyed on the type of the - relationship. The value of each entry is an array containing a descriptor - for each relationship with that type, describing the name of the relationship - as well as the type. - - For example, given the following model definition: - - ```javascript - App.Blog = DS.Model.extend({ - users: DS.hasMany('user'), - owner: DS.belongsTo('user'), - posts: DS.hasMany('post') - }); - ``` - - This computed property would return a map describing these - relationships, like this: - - ```javascript - var relationships = Ember.get(App.Blog, 'relationships'); - relationships.get(App.User); - //=> [ { name: 'users', kind: 'hasMany' }, - // { name: 'owner', kind: 'belongsTo' } ] - relationships.get(App.Post); - //=> [ { name: 'posts', kind: 'hasMany' } ] - ``` - - @property relationships - @static - @type Ember.Map - @readOnly - */ - relationships: Ember.computed(function() { - var map = new MapWithDefault({ - defaultValue: function() { return []; } - }); - - // Loop through each computed property on the class - this.eachComputedProperty(function(name, meta) { - // If the computed property is a relationship, add - // it to the map. - if (meta.isRelationship) { - meta.key = name; - var relationshipsForType = map.get(typeForRelationshipMeta(this.store, meta)); - - relationshipsForType.push({ - name: name, - kind: meta.kind - }); - } - }); - - return map; - }).cacheable(false).readOnly(), - - /** - A hash containing lists of the model's relationships, grouped - by the relationship kind. For example, given a model with this - definition: - - ```javascript - App.Blog = DS.Model.extend({ - users: DS.hasMany('user'), - owner: DS.belongsTo('user'), - - posts: DS.hasMany('post') - }); - ``` - - This property would contain the following: - - ```javascript - var relationshipNames = Ember.get(App.Blog, 'relationshipNames'); - relationshipNames.hasMany; - //=> ['users', 'posts'] - relationshipNames.belongsTo; - //=> ['owner'] - ``` - - @property relationshipNames - @static - @type Object - @readOnly - */ - relationshipNames: Ember.computed(function() { - var names = { - hasMany: [], - belongsTo: [] - }; - - this.eachComputedProperty(function(name, meta) { - if (meta.isRelationship) { - names[meta.kind].push(name); - } - }); - - return names; - }), - - /** - An array of types directly related to a model. Each type will be - included once, regardless of the number of relationships it has with - the model. - - For example, given a model with this definition: - - ```javascript - App.Blog = DS.Model.extend({ - users: DS.hasMany('user'), - owner: DS.belongsTo('user'), - - posts: DS.hasMany('post') - }); - ``` - - This property would contain the following: - - ```javascript - var relatedTypes = Ember.get(App.Blog, 'relatedTypes'); - //=> [ App.User, App.Post ] - ``` - - @property relatedTypes - @static - @type Ember.Array - @readOnly - */ - relatedTypes: Ember.computed(function() { - var type; - var types = Ember.A(); - - // Loop through each computed property on the class, - // and create an array of the unique types involved - // in relationships - this.eachComputedProperty(function(name, meta) { - if (meta.isRelationship) { - meta.key = name; - type = typeForRelationshipMeta(this.store, meta); - - Ember.assert("You specified a hasMany (" + meta.type + ") on " + meta.parentType + " but " + meta.type + " was not found.", type); - - if (!types.contains(type)) { - Ember.assert("Trying to sideload " + name + " on " + this.toString() + " but the type doesn't exist.", !!type); - types.push(type); - } - } - }); - - return types; - }).cacheable(false).readOnly(), - - /** - A map whose keys are the relationships of a model and whose values are - relationship descriptors. - - For example, given a model with this - definition: - - ```javascript - App.Blog = DS.Model.extend({ - users: DS.hasMany('user'), - owner: DS.belongsTo('user'), - - posts: DS.hasMany('post') - }); - ``` - - This property would contain the following: - - ```javascript - var relationshipsByName = Ember.get(App.Blog, 'relationshipsByName'); - relationshipsByName.get('users'); - //=> { key: 'users', kind: 'hasMany', type: App.User } - relationshipsByName.get('owner'); - //=> { key: 'owner', kind: 'belongsTo', type: App.User } - ``` - - @property relationshipsByName - @static - @type Ember.Map - @readOnly - */ - relationshipsByName: Ember.computed(function() { - var map = Map.create(); - - this.eachComputedProperty(function(name, meta) { - if (meta.isRelationship) { - meta.key = name; - var relationship = relationshipFromMeta(this.store, meta); - relationship.type = typeForRelationshipMeta(this.store, meta); - map.set(name, relationship); - } - }); - - return map; - }).cacheable(false).readOnly(), - - /** - A map whose keys are the fields of the model and whose values are strings - describing the kind of the field. A model's fields are the union of all of its - attributes and relationships. - - For example: - - ```javascript - - App.Blog = DS.Model.extend({ - users: DS.hasMany('user'), - owner: DS.belongsTo('user'), - - posts: DS.hasMany('post'), - - title: DS.attr('string') - }); - - var fields = Ember.get(App.Blog, 'fields'); - fields.forEach(function(kind, field) { - console.log(field, kind); - }); - - // prints: - // users, hasMany - // owner, belongsTo - // posts, hasMany - // title, attribute - ``` - - @property fields - @static - @type Ember.Map - @readOnly - */ - fields: Ember.computed(function() { - var map = Map.create(); - - this.eachComputedProperty(function(name, meta) { - if (meta.isRelationship) { - map.set(name, meta.kind); - } else if (meta.isAttribute) { - map.set(name, 'attribute'); - } - }); - - return map; - }).readOnly(), - - /** - Given a callback, iterates over each of the relationships in the model, - invoking the callback with the name of each relationship and its relationship - descriptor. - - @method eachRelationship - @static - @param {Function} callback the callback to invoke - @param {any} binding the value to which the callback's `this` should be bound - */ - eachRelationship: function(callback, binding) { - get(this, 'relationshipsByName').forEach(function(relationship, name) { - callback.call(binding, name, relationship); - }); - }, - - /** - Given a callback, iterates over each of the types related to a model, - invoking the callback with the related type's class. Each type will be - returned just once, regardless of how many different relationships it has - with a model. - - @method eachRelatedType - @static - @param {Function} callback the callback to invoke - @param {any} binding the value to which the callback's `this` should be bound - */ - eachRelatedType: function(callback, binding) { - get(this, 'relatedTypes').forEach(function(type) { - callback.call(binding, type); - }); - }, - - determineRelationshipType: function(knownSide) { - var knownKey = knownSide.key; - var knownKind = knownSide.kind; - var inverse = this.inverseFor(knownKey); - var key, otherKind; - - if (!inverse) { - return knownKind === 'belongsTo' ? 'oneToNone' : 'manyToNone'; - } - - key = inverse.name; - otherKind = inverse.kind; - - if (otherKind === 'belongsTo') { - return knownKind === 'belongsTo' ? 'oneToOne' : 'manyToOne'; - } else { - return knownKind === 'belongsTo' ? 'oneToMany' : 'manyToMany'; - } - } - - }); - - Model.reopen({ - /** - Given a callback, iterates over each of the relationships in the model, - invoking the callback with the name of each relationship and its relationship - descriptor. - - @method eachRelationship - @param {Function} callback the callback to invoke - @param {any} binding the value to which the callback's `this` should be bound - */ - eachRelationship: function(callback, binding) { - this.constructor.eachRelationship(callback, binding); - }, - - relationshipFor: function(name) { - return get(this.constructor, 'relationshipsByName').get(name); - }, - - inverseFor: function(key) { - return this.constructor.inverseFor(key); - } - - }); - }); -enifed("ember-data/system/relationships/has_many", - ["ember-data/system/model","exports"], - function(__dependency1__, __exports__) { - "use strict"; - /** - @module ember-data - */ - - var Model = __dependency1__.Model; - - /** - `DS.hasMany` is used to define One-To-Many and Many-To-Many - relationships on a [DS.Model](/api/data/classes/DS.Model.html). - - `DS.hasMany` takes an optional hash as a second parameter, currently - supported options are: - - - `async`: A boolean value used to explicitly declare this to be an async relationship. - - `inverse`: A string used to identify the inverse property on a related model. - - #### One-To-Many - To declare a one-to-many relationship between two models, use - `DS.belongsTo` in combination with `DS.hasMany`, like this: - - ```javascript - App.Post = DS.Model.extend({ - comments: DS.hasMany('comment') - }); - - App.Comment = DS.Model.extend({ - post: DS.belongsTo('post') - }); - ``` - - #### Many-To-Many - To declare a many-to-many relationship between two models, use - `DS.hasMany`: - - ```javascript - App.Post = DS.Model.extend({ - tags: DS.hasMany('tag') - }); - - App.Tag = DS.Model.extend({ - posts: DS.hasMany('post') - }); - ``` - - #### Explicit Inverses - - Ember Data will do its best to discover which relationships map to - one another. In the one-to-many code above, for example, Ember Data - can figure out that changing the `comments` relationship should update - the `post` relationship on the inverse because post is the only - relationship to that model. - - However, sometimes you may have multiple `belongsTo`/`hasManys` for the - same type. You can specify which property on the related model is - the inverse using `DS.hasMany`'s `inverse` option: - - ```javascript - var belongsTo = DS.belongsTo, - hasMany = DS.hasMany; - - App.Comment = DS.Model.extend({ - onePost: belongsTo('post'), - twoPost: belongsTo('post'), - redPost: belongsTo('post'), - bluePost: belongsTo('post') - }); - - App.Post = DS.Model.extend({ - comments: hasMany('comment', { - inverse: 'redPost' - }) - }); - ``` - - You can also specify an inverse on a `belongsTo`, which works how - you'd expect. - - @namespace - @method hasMany - @for DS - @param {String or DS.Model} type the model type of the relationship - @param {Object} options a hash of options - @return {Ember.computed} relationship - */ - function hasMany(type, options) { - if (typeof type === 'object') { - options = type; - type = undefined; - } - - options = options || {}; - - // Metadata about relationships is stored on the meta of - // the relationship. This is used for introspection and - // serialization. Note that `key` is populated lazily - // the first time the CP is called. - var meta = { - type: type, - isRelationship: true, - options: options, - kind: 'hasMany', - key: null - }; - - return Ember.computed(function(key) { - var relationship = this._relationships[key]; - return relationship.getRecords(); - }).meta(meta).readOnly(); - } - - Model.reopen({ - notifyHasManyAdded: function(key, record, idx) { - var relationship = this._relationships[key]; - var manyArray = relationship.manyArray; - manyArray.addRecord(record, idx); - //We need to notifyPropertyChange in the adding case because we need to make sure - //we fetch the newly added record in case it is unloaded - //TODO(Igor): Consider whether we could do this only if the record state is unloaded - this.notifyPropertyChange(key); - }, - - notifyHasManyRemoved: function(key, record) { - var relationship = this._relationships[key]; - var manyArray = relationship.manyArray; - manyArray.removeRecord(record); - } - }); - - - __exports__["default"] = hasMany; - }); -enifed("ember-data/system/relationships/relationship", - ["ember-data/system/promise_proxies","ember-data/system/map","exports"], - function(__dependency1__, __dependency2__, __exports__) { - "use strict"; - var PromiseManyArray = __dependency1__.PromiseManyArray; - var PromiseObject = __dependency1__.PromiseObject; - var OrderedSet = __dependency2__.OrderedSet; - - var Relationship = function(store, record, inverseKey, relationshipMeta) { - this.members = new OrderedSet(); - this.store = store; - this.key = relationshipMeta.key; - this.inverseKey = inverseKey; - this.record = record; - this.isAsync = relationshipMeta.options.async; - this.relationshipMeta = relationshipMeta; - //This probably breaks for polymorphic relationship in complex scenarios, due to - //multiple possible typeKeys - this.inverseKeyForImplicit = this.store.modelFor(this.record.constructor).typeKey + this.key; - //Cached promise when fetching the relationship from a link - this.linkPromise = null; - }; - - Relationship.prototype = { - constructor: Relationship, - - destroy: Ember.K, - - clear: function() { - this.members.forEach(function(member) { - this.removeRecord(member); - }, this); - }, - - disconnect: function(){ - this.members.forEach(function(member) { - this.removeRecordFromInverse(member); - }, this); - }, - - reconnect: function(){ - this.members.forEach(function(member) { - this.addRecordToInverse(member); - }, this); - }, - - removeRecords: function(records){ - var length = Ember.get(records, 'length'); - var record; - for (var i = 0; i < length; i++){ - record = records[i]; - this.removeRecord(record); - } - }, - - addRecords: function(records, idx){ - var length = Ember.get(records, 'length'); - var record; - for (var i = 0; i < length; i++){ - record = records[i]; - this.addRecord(record, idx); - if (idx !== undefined) { - idx++; - } - } - }, - - addRecord: function(record, idx) { - if (!this.members.has(record)) { - this.members.add(record); - this.notifyRecordRelationshipAdded(record, idx); - if (this.inverseKey) { - record._relationships[this.inverseKey].addRecord(this.record); - } else { - if (!record._implicitRelationships[this.inverseKeyForImplicit]) { - record._implicitRelationships[this.inverseKeyForImplicit] = new Relationship(this.store, record, this.key, {options:{}}); - } - record._implicitRelationships[this.inverseKeyForImplicit].addRecord(this.record); - } - this.record.updateRecordArrays(); - } - }, - - removeRecord: function(record) { - if (this.members.has(record)) { - this.removeRecordFromOwn(record); - if (this.inverseKey) { - this.removeRecordFromInverse(record); - } else { - if (record._implicitRelationships[this.inverseKeyForImplicit]) { - record._implicitRelationships[this.inverseKeyForImplicit].removeRecord(this.record); - } - } - } - }, - - addRecordToInverse: function(record) { - if (this.inverseKey) { - record._relationships[this.inverseKey].addRecord(this.record); - } - }, - - removeRecordFromInverse: function(record) { - var inverseRelationship = record._relationships[this.inverseKey]; - //Need to check for existence, as the record might unloading at the moment - if (inverseRelationship) { - inverseRelationship.removeRecordFromOwn(this.record); - } - }, - - removeRecordFromOwn: function(record) { - this.members["delete"](record); - this.notifyRecordRelationshipRemoved(record); - this.record.updateRecordArrays(); - }, - - updateLink: function(link) { - Ember.assert("You have pushed a record of type '" + this.record.constructor.typeKey + "' with '" + this.key + "' as a link, but the value of that link is not a string.", typeof link === 'string' || link === null); - if (link !== this.link) { - this.link = link; - this.linkPromise = null; - this.record.notifyPropertyChange(this.key); - } - }, - - findLink: function() { - if (this.linkPromise) { - return this.linkPromise; - } else { - var promise = this.fetchLink(); - this.linkPromise = promise; - return promise.then(function(result) { - return result; - }); - } - }, - - updateRecordsFromAdapter: function(records) { - //TODO Once we have adapter support, we need to handle updated and canonical changes - this.computeChanges(records); - }, - - notifyRecordRelationshipAdded: Ember.K, - notifyRecordRelationshipRemoved: Ember.K - }; - - var ManyRelationship = function(store, record, inverseKey, relationshipMeta) { - this._super$constructor(store, record, inverseKey, relationshipMeta); - this.belongsToType = relationshipMeta.type; - this.manyArray = store.recordArrayManager.createManyArray(this.belongsToType, Ember.A()); - this.manyArray.relationship = this; - this.isPolymorphic = relationshipMeta.options.polymorphic; - this.manyArray.isPolymorphic = this.isPolymorphic; - }; - - ManyRelationship.prototype = Ember.create(Relationship.prototype); - ManyRelationship.prototype.constructor = ManyRelationship; - ManyRelationship.prototype._super$constructor = Relationship; - - ManyRelationship.prototype.destroy = function() { - this.manyArray.destroy(); - }; - - ManyRelationship.prototype.notifyRecordRelationshipAdded = function(record, idx) { - Ember.assert("You cannot add '" + record.constructor.typeKey + "' records to this relationship (only '" + this.belongsToType.typeKey + "' allowed)", !this.belongsToType || record instanceof this.belongsToType); - this.record.notifyHasManyAdded(this.key, record, idx); - }; - - ManyRelationship.prototype.notifyRecordRelationshipRemoved = function(record) { - this.record.notifyHasManyRemoved(this.key, record); - }; - - ManyRelationship.prototype.reload = function() { - var self = this; - if (this.link) { - return this.fetchLink(); - } else { - return this.store.scheduleFetchMany(this.manyArray.toArray()).then(function() { - //Goes away after the manyArray refactor - self.manyArray.set('isLoaded', true); - return self.manyArray; - }); - } - }; - - ManyRelationship.prototype.computeChanges = function(records) { - var members = this.members; - var recordsToRemove = []; - var length; - var record; - var i; - - records = setForArray(records); - - members.forEach(function(member) { - if (records.has(member)) return; - - recordsToRemove.push(member); - }); - this.removeRecords(recordsToRemove); - - var hasManyArray = this.manyArray; - - // Using records.toArray() since currently using - // removeRecord can modify length, messing stuff up - // forEach since it directly looks at "length" each - // iteration - records = records.toArray(); - length = records.length; - for (i = 0; i < length; i++){ - record = records[i]; - //Need to preserve the order of incoming records - if (hasManyArray.objectAt(i) === record ) { - continue; - } - this.removeRecord(record); - this.addRecord(record, i); - } - }; - - ManyRelationship.prototype.fetchLink = function() { - var self = this; - return this.store.findHasMany(this.record, this.link, this.relationshipMeta).then(function(records){ - self.updateRecordsFromAdapter(records); - return self.manyArray; - }); - }; - - ManyRelationship.prototype.findRecords = function() { - var manyArray = this.manyArray; - return this.store.findMany(manyArray.toArray()).then(function(){ - //Goes away after the manyArray refactor - manyArray.set('isLoaded', true); - return manyArray; - }); - }; - - ManyRelationship.prototype.getRecords = function() { - if (this.isAsync) { - var self = this; - var promise; - if (this.link) { - promise = this.findLink().then(function() { - return self.findRecords(); - }); - } else { - promise = this.findRecords(); - } - return PromiseManyArray.create({ - content: this.manyArray, - promise: promise - }); - } else { - Ember.assert("You looked up the '" + this.key + "' relationship on a '" + this.record.constructor.typeKey + "' with id " + this.record.get('id') + " but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (`DS.hasMany({ async: true })`)", this.manyArray.isEvery('isEmpty', false)); - - if (!this.manyArray.get('isDestroyed')) { - this.manyArray.set('isLoaded', true); - } - return this.manyArray; - } - }; - - var BelongsToRelationship = function(store, record, inverseKey, relationshipMeta) { - this._super$constructor(store, record, inverseKey, relationshipMeta); - this.record = record; - this.key = relationshipMeta.key; - this.inverseRecord = null; - }; - - BelongsToRelationship.prototype = Ember.create(Relationship.prototype); - BelongsToRelationship.prototype.constructor = BelongsToRelationship; - BelongsToRelationship.prototype._super$constructor = Relationship; - - BelongsToRelationship.prototype.setRecord = function(newRecord) { - if (newRecord) { - this.addRecord(newRecord); - } else if (this.inverseRecord) { - this.removeRecord(this.inverseRecord); - } - }; - - BelongsToRelationship.prototype._super$addRecord = Relationship.prototype.addRecord; - BelongsToRelationship.prototype.addRecord = function(newRecord) { - if (this.members.has(newRecord)){ return;} - var type = this.relationshipMeta.type; - Ember.assert("You can only add a '" + type.typeKey + "' record to this relationship", newRecord instanceof type); - - if (this.inverseRecord) { - this.removeRecord(this.inverseRecord); - } - - this.inverseRecord = newRecord; - this._super$addRecord(newRecord); - }; - - BelongsToRelationship.prototype.setRecordPromise = function(newPromise) { - var content = newPromise.get && newPromise.get('content'); - Ember.assert("You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo or hasMany relationship to the get call.", content !== undefined); - this.setRecord(content); - }; - - BelongsToRelationship.prototype.notifyRecordRelationshipAdded = function(newRecord) { - this.record.notifyBelongsToAdded(this.key, this); - }; - - BelongsToRelationship.prototype.notifyRecordRelationshipRemoved = function(record) { - this.record.notifyBelongsToRemoved(this.key, this); - }; - - BelongsToRelationship.prototype._super$removeRecordFromOwn = Relationship.prototype.removeRecordFromOwn; - BelongsToRelationship.prototype.removeRecordFromOwn = function(record) { - if (!this.members.has(record)) { return; } - this.inverseRecord = null; - this._super$removeRecordFromOwn(record); - }; - - BelongsToRelationship.prototype.findRecord = function() { - if (this.inverseRecord) { - return this.store._findByRecord(this.inverseRecord); - } else { - return Ember.RSVP.Promise.resolve(null); - } - }; - - BelongsToRelationship.prototype.fetchLink = function() { - var self = this; - return this.store.findBelongsTo(this.record, this.link, this.relationshipMeta).then(function(record){ - if (record) { - self.addRecord(record); - } - return record; - }); - }; - - BelongsToRelationship.prototype.getRecord = function() { - if (this.isAsync) { - var promise; - if (this.link){ - var self = this; - promise = this.findLink().then(function() { - return self.findRecord(); - }); - } else { - promise = this.findRecord(); - } - - return PromiseObject.create({ - promise: promise, - content: this.inverseRecord - }); - } else { - Ember.assert("You looked up the '" + this.key + "' relationship on a '" + this.record.constructor.typeKey + "' with id " + this.record.get('id') + " but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (`DS.belongsTo({ async: true })`)", this.inverseRecord === null || !this.inverseRecord.get('isEmpty')); - return this.inverseRecord; - } - }; - - function setForArray(array) { - var set = new OrderedSet(); - - if (array) { - for (var i=0, l=array.length; i<l; i++) { - set.add(array[i]); - } - } - - return set; - } - - var createRelationshipFor = function(record, relationshipMeta, store){ - var inverseKey; - var inverse = record.constructor.inverseFor(relationshipMeta.key); - - if (inverse) { - inverseKey = inverse.name; - } - - if (relationshipMeta.kind === 'hasMany'){ - return new ManyRelationship(store, record, inverseKey, relationshipMeta); - } - else { - return new BelongsToRelationship(store, record, inverseKey, relationshipMeta); - } - }; - - - __exports__.Relationship = Relationship; - __exports__.ManyRelationship = ManyRelationship; - __exports__.BelongsToRelationship = BelongsToRelationship; - __exports__.createRelationshipFor = createRelationshipFor; - }); -enifed("ember-data/system/store", - ["ember-data/system/adapter","ember-inflector/system/string","ember-data/system/map","ember-data/system/promise_proxies","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) { - "use strict"; - /*globals Ember*/ - /*jshint eqnull:true*/ - - /** - @module ember-data - */ - - var InvalidError = __dependency1__.InvalidError; - var Adapter = __dependency1__.Adapter; - var singularize = __dependency2__.singularize; - var Map = __dependency3__.Map; - - var promiseArray = __dependency4__.promiseArray; - var promiseObject = __dependency4__.promiseObject; - - - var get = Ember.get; - var set = Ember.set; - var once = Ember.run.once; - var isNone = Ember.isNone; - var forEach = Ember.EnumerableUtils.forEach; - var indexOf = Ember.EnumerableUtils.indexOf; - var map = Ember.EnumerableUtils.map; - var Promise = Ember.RSVP.Promise; - var copy = Ember.copy; - var Store, RecordArrayManager, Model; - - var camelize = Ember.String.camelize; - - // Implementors Note: - // - // The variables in this file are consistently named according to the following - // scheme: - // - // * +id+ means an identifier managed by an external source, provided inside - // the data provided by that source. These are always coerced to be strings - // before being used internally. - // * +clientId+ means a transient numerical identifier generated at runtime by - // the data store. It is important primarily because newly created objects may - // not yet have an externally generated id. - // * +reference+ means a record reference object, which holds metadata about a - // record, even if it has not yet been fully materialized. - // * +type+ means a subclass of DS.Model. - - // Used by the store to normalize IDs entering the store. Despite the fact - // that developers may provide IDs as numbers (e.g., `store.find(Person, 1)`), - // it is important that internally we use strings, since IDs may be serialized - // and lose type information. For example, Ember's router may put a record's - // ID into the URL, and if we later try to deserialize that URL and find the - // corresponding record, we will not know if it is a string or a number. - function coerceId(id) { - return id == null ? null : id+''; - } - - /** - The store contains all of the data for records loaded from the server. - It is also responsible for creating instances of `DS.Model` that wrap - the individual data for a record, so that they can be bound to in your - Handlebars templates. - - Define your application's store like this: - - ```javascript - MyApp.Store = DS.Store.extend(); - ``` - - Most Ember.js applications will only have a single `DS.Store` that is - automatically created by their `Ember.Application`. - - You can retrieve models from the store in several ways. To retrieve a record - for a specific id, use `DS.Store`'s `find()` method: - - ```javascript - store.find('person', 123).then(function (person) { - }); - ``` - - By default, the store will talk to your backend using a standard - REST mechanism. You can customize how the store talks to your - backend by specifying a custom adapter: - - ```javascript - MyApp.ApplicationAdapter = MyApp.CustomAdapter - ``` - - You can learn more about writing a custom adapter by reading the `DS.Adapter` - documentation. - - ### Store createRecord() vs. push() vs. pushPayload() vs. update() - - The store provides multiple ways to create new record objects. They have - some subtle differences in their use which are detailed below: - - [createRecord](#method_createRecord) is used for creating new - records on the client side. This will return a new record in the - `created.uncommitted` state. In order to persist this record to the - backend you will need to call `record.save()`. - - [push](#method_push) is used to notify Ember Data's store of new or - updated records that exist in the backend. This will return a record - in the `loaded.saved` state. The primary use-case for `store#push` is - to notify Ember Data about record updates that happen - outside of the normal adapter methods (for example - [SSE](http://dev.w3.org/html5/eventsource/) or [Web - Sockets](http://www.w3.org/TR/2009/WD-websockets-20091222/)). - - [pushPayload](#method_pushPayload) is a convenience wrapper for - `store#push` that will deserialize payloads if the - Serializer implements a `pushPayload` method. - - [update](#method_update) works like `push`, except it can handle - partial attributes without overwriting the existing record - properties. - - Note: When creating a new record using any of the above methods - Ember Data will update `DS.RecordArray`s such as those returned by - `store#all()`, `store#findAll()` or `store#filter()`. This means any - data bindings or computed properties that depend on the RecordArray - will automatically be synced to include the new or updated record - values. - - @class Store - @namespace DS - @extends Ember.Object - */ - Store = Ember.Object.extend({ - - /** - @method init - @private - */ - init: function() { - // internal bookkeeping; not observable - if (!RecordArrayManager) { RecordArrayManager = requireModule("ember-data/system/record_array_manager")["default"]; } - this.typeMaps = {}; - this.recordArrayManager = RecordArrayManager.create({ - store: this - }); - this._pendingSave = []; - //Used to keep track of all the find requests that need to be coalesced - this._pendingFetch = Map.create(); - }, - - /** - The adapter to use to communicate to a backend server or other persistence layer. - - This can be specified as an instance, class, or string. - - If you want to specify `App.CustomAdapter` as a string, do: - - ```js - adapter: 'custom' - ``` - - @property adapter - @default DS.RESTAdapter - @type {DS.Adapter|String} - */ - adapter: '-rest', - - /** - Returns a JSON representation of the record using a custom - type-specific serializer, if one exists. - - The available options are: - - * `includeId`: `true` if the record's ID should be included in - the JSON representation - - @method serialize - @private - @param {DS.Model} record the record to serialize - @param {Object} options an options hash - */ - serialize: function(record, options) { - return this.serializerFor(record.constructor.typeKey).serialize(record, options); - }, - - /** - This property returns the adapter, after resolving a possible - string key. - - If the supplied `adapter` was a class, or a String property - path resolved to a class, this property will instantiate the - class. - - This property is cacheable, so the same instance of a specified - adapter class should be used for the lifetime of the store. - - @property defaultAdapter - @private - @return DS.Adapter - */ - defaultAdapter: Ember.computed('adapter', function() { - var adapter = get(this, 'adapter'); - - Ember.assert('You tried to set `adapter` property to an instance of `DS.Adapter`, where it should be a name or a factory', !(adapter instanceof Adapter)); - - if (typeof adapter === 'string') { - adapter = this.container.lookup('adapter:' + adapter) || this.container.lookup('adapter:application') || this.container.lookup('adapter:-rest'); - } - - if (DS.Adapter.detect(adapter)) { - adapter = adapter.create({ - container: this.container - }); - } - - return adapter; - }), - - // ..................... - // . CREATE NEW RECORD . - // ..................... - - /** - Create a new record in the current store. The properties passed - to this method are set on the newly created record. - - To create a new instance of `App.Post`: - - ```js - store.createRecord('post', { - title: "Rails is omakase" - }); - ``` - - @method createRecord - @param {String} type - @param {Object} properties a hash of properties to set on the - newly created record. - @return {DS.Model} record - */ - createRecord: function(typeName, inputProperties) { - var type = this.modelFor(typeName); - var properties = copy(inputProperties) || {}; - - // If the passed properties do not include a primary key, - // give the adapter an opportunity to generate one. Typically, - // client-side ID generators will use something like uuid.js - // to avoid conflicts. - - if (isNone(properties.id)) { - properties.id = this._generateId(type); - } - - // Coerce ID to a string - properties.id = coerceId(properties.id); - - var record = this.buildRecord(type, properties.id); - - // Move the record out of its initial `empty` state into - // the `loaded` state. - record.loadedData(); - - // Set the properties specified on the record. - record.setProperties(properties); - - return record; - }, - - /** - If possible, this method asks the adapter to generate an ID for - a newly created record. - - @method _generateId - @private - @param {String} type - @return {String} if the adapter can generate one, an ID - */ - _generateId: function(type) { - var adapter = this.adapterFor(type); - - if (adapter && adapter.generateIdForRecord) { - return adapter.generateIdForRecord(this); - } - - return null; - }, - - // ................. - // . DELETE RECORD . - // ................. - - /** - For symmetry, a record can be deleted via the store. - - Example - - ```javascript - var post = store.createRecord('post', { - title: "Rails is omakase" - }); - - store.deleteRecord(post); - ``` - - @method deleteRecord - @param {DS.Model} record - */ - deleteRecord: function(record) { - record.deleteRecord(); - }, - - /** - For symmetry, a record can be unloaded via the store. Only - non-dirty records can be unloaded. - - Example - - ```javascript - store.find('post', 1).then(function(post) { - store.unloadRecord(post); - }); - ``` - - @method unloadRecord - @param {DS.Model} record - */ - unloadRecord: function(record) { - record.unloadRecord(); - }, - - // ................ - // . FIND RECORDS . - // ................ - - /** - This is the main entry point into finding records. The first parameter to - this method is the model's name as a string. - - --- - - To find a record by ID, pass the `id` as the second parameter: - - ```javascript - store.find('person', 1); - ``` - - The `find` method will always return a **promise** that will be resolved - with the record. If the record was already in the store, the promise will - be resolved immediately. Otherwise, the store will ask the adapter's `find` - method to find the necessary data. - - The `find` method will always resolve its promise with the same object for - a given type and `id`. - - --- - - You can optionally `preload` specific attributes and relationships that you know of - by passing them as the third argument to find. - - For example, if your Ember route looks like `/posts/1/comments/2` and your API route - for the comment also looks like `/posts/1/comments/2` if you want to fetch the comment - without fetching the post you can pass in the post to the `find` call: - - ```javascript - store.find('comment', 2, {post: 1}); - ``` - - If you have access to the post model you can also pass the model itself: - - ```javascript - store.find('post', 1).then(function (myPostModel) { - store.find('comment', 2, {post: myPostModel}); - }); - ``` - - This way, your adapter's `find` or `buildURL` method will be able to look up the - relationship on the record and construct the nested URL without having to first - fetch the post. - - --- - - To find all records for a type, call `find` with no additional parameters: - - ```javascript - store.find('person'); - ``` - - This will ask the adapter's `findAll` method to find the records for the - given type, and return a promise that will be resolved once the server - returns the values. - - --- - - To find a record by a query, call `find` with a hash as the second - parameter: - - ```javascript - store.find('person', { page: 1 }); - ``` - - This will ask the adapter's `findQuery` method to find the records for - the query, and return a promise that will be resolved once the server - responds. - - @method find - @param {String or subclass of DS.Model} type - @param {Object|String|Integer|null} id - @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models - @return {Promise} promise - */ - find: function(type, id, preload) { - Ember.assert("You need to pass a type to the store's find method", arguments.length >= 1); - Ember.assert("You may not pass `" + id + "` as id to the store's find method", arguments.length === 1 || !Ember.isNone(id)); - - if (arguments.length === 1) { - return this.findAll(type); - } - - // We are passed a query instead of an id. - if (Ember.typeOf(id) === 'object') { - return this.findQuery(type, id); - } - - return this.findById(type, coerceId(id), preload); - }, - - /** - This method returns a fresh record for a given type and id combination. - - If a record is available for the given type/id combination, then it will fetch this record from the store then reload it. If there's no record corresponding in the store it will simply call store.find. - - @method fetch - @param {String or subclass of DS.Model} type - @param {Object|String|Integer|null} id - @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models - @return {Promise} promise - */ - fetch: function(type, id, preload) { - if (this.hasRecordForId(type, id)) { - return this.getById(type, id).reload(); - } else { - return this.find(type, id, preload); - } - }, - - /** - This method returns a record for a given type and id combination. - - @method findById - @private - @param {String or subclass of DS.Model} type - @param {String|Integer} id - @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models - @return {Promise} promise - */ - findById: function(typeName, id, preload) { - - var type = this.modelFor(typeName); - var record = this.recordForId(type, id); - - return this._findByRecord(record, preload); - }, - - _findByRecord: function(record, preload) { - var fetchedRecord; - - if (preload) { - record._preloadData(preload); - } - - if (get(record, 'isEmpty')) { - fetchedRecord = this.scheduleFetch(record); - //TODO double check about reloading - } else if (get(record, 'isLoading')){ - fetchedRecord = record._loadingPromise; - } - - return promiseObject(fetchedRecord || record, "DS: Store#findByRecord " + record.typeKey + " with id: " + get(record, 'id')); - }, - - /** - This method makes a series of requests to the adapter's `find` method - and returns a promise that resolves once they are all loaded. - - @private - @method findByIds - @param {String} type - @param {Array} ids - @return {Promise} promise - */ - findByIds: function(type, ids) { - var store = this; - - return promiseArray(Ember.RSVP.all(map(ids, function(id) { - return store.findById(type, id); - })).then(Ember.A, null, "DS: Store#findByIds of " + type + " complete")); - }, - - /** - This method is called by `findById` if it discovers that a particular - type/id pair hasn't been loaded yet to kick off a request to the - adapter. - - @method fetchRecord - @private - @param {DS.Model} record - @return {Promise} promise - */ - fetchRecord: function(record) { - var type = record.constructor; - var id = get(record, 'id'); - var adapter = this.adapterFor(type); - - Ember.assert("You tried to find a record but you have no adapter (for " + type + ")", adapter); - Ember.assert("You tried to find a record but your adapter (for " + type + ") does not implement 'find'", typeof adapter.find === 'function'); - - var promise = _find(adapter, this, type, id, record); - return promise; - }, - - scheduleFetchMany: function(records) { - return Promise.all(map(records, this.scheduleFetch, this)); - }, - - scheduleFetch: function(record) { - var type = record.constructor; - if (isNone(record)) { return null; } - if (record._loadingPromise) { return record._loadingPromise; } - - var resolver = Ember.RSVP.defer('Fetching ' + type + 'with id: ' + record.get('id')); - var recordResolverPair = { - record: record, - resolver: resolver - }; - var promise = resolver.promise; - - record.loadingData(promise); - - if (!this._pendingFetch.get(type)){ - this._pendingFetch.set(type, [recordResolverPair]); - } else { - this._pendingFetch.get(type).push(recordResolverPair); - } - Ember.run.scheduleOnce('afterRender', this, this.flushAllPendingFetches); - - return promise; - }, - - flushAllPendingFetches: function(){ - if (this.isDestroyed || this.isDestroying) { - return; - } - - this._pendingFetch.forEach(this._flushPendingFetchForType, this); - this._pendingFetch = Map.create(); - }, - - _flushPendingFetchForType: function (recordResolverPairs, type) { - var store = this; - var adapter = store.adapterFor(type); - var shouldCoalesce = !!adapter.findMany && adapter.coalesceFindRequests; - var records = Ember.A(recordResolverPairs).mapBy('record'); - - function _fetchRecord(recordResolverPair) { - recordResolverPair.resolver.resolve(store.fetchRecord(recordResolverPair.record)); - } - - function resolveFoundRecords(records) { - forEach(records, function(record){ - var pair = Ember.A(recordResolverPairs).findBy('record', record); - if (pair){ - var resolver = pair.resolver; - resolver.resolve(record); - } - }); - } - - function makeMissingRecordsRejector(requestedRecords) { - return function rejectMissingRecords(resolvedRecords) { - var missingRecords = requestedRecords.without(resolvedRecords); - rejectRecords(missingRecords); - }; - } - - function makeRecordsRejector(records) { - return function (error) { - rejectRecords(records, error); - }; - } - - function rejectRecords(records, error) { - forEach(records, function(record){ - var pair = Ember.A(recordResolverPairs).findBy('record', record); - if (pair){ - var resolver = pair.resolver; - resolver.reject(error); - } - }); - } - - if (recordResolverPairs.length === 1) { - _fetchRecord(recordResolverPairs[0]); - } else if (shouldCoalesce) { - var groups = adapter.groupRecordsForFindMany(this, records); - forEach(groups, function (groupOfRecords) { - var requestedRecords = Ember.A(groupOfRecords); - var ids = requestedRecords.mapBy('id'); - if (ids.length > 1) { - _findMany(adapter, store, type, ids, requestedRecords). - then(resolveFoundRecords). - then(makeMissingRecordsRejector(requestedRecords)). - then(null, makeRecordsRejector(requestedRecords)); - } else if (ids.length === 1) { - var pair = Ember.A(recordResolverPairs).findBy('record', groupOfRecords[0]); - _fetchRecord(pair); - } else { - Ember.assert("You cannot return an empty array from adapter's method groupRecordsForFindMany", false); - } - }); - } else { - forEach(recordResolverPairs, _fetchRecord); - } - }, - - /** - Get a record by a given type and ID without triggering a fetch. - - This method will synchronously return the record if it is available in the store, - otherwise it will return `null`. A record is available if it has been fetched earlier, or - pushed manually into the store. - - _Note: This is an synchronous method and does not return a promise._ - - ```js - var post = store.getById('post', 1); - - post.get('id'); // 1 - ``` - - @method getById - @param {String or subclass of DS.Model} type - @param {String|Integer} id - @return {DS.Model|null} record - */ - getById: function(type, id) { - if (this.hasRecordForId(type, id)) { - return this.recordForId(type, id); - } else { - return null; - } - }, - - /** - This method is called by the record's `reload` method. - - This method calls the adapter's `find` method, which returns a promise. When - **that** promise resolves, `reloadRecord` will resolve the promise returned - by the record's `reload`. - - @method reloadRecord - @private - @param {DS.Model} record - @return {Promise} promise - */ - reloadRecord: function(record) { - var type = record.constructor; - var adapter = this.adapterFor(type); - var id = get(record, 'id'); - - Ember.assert("You cannot reload a record without an ID", id); - Ember.assert("You tried to reload a record but you have no adapter (for " + type + ")", adapter); - Ember.assert("You tried to reload a record but your adapter does not implement `find`", typeof adapter.find === 'function'); - - return this.scheduleFetch(record); - }, - - /** - Returns true if a record for a given type and ID is already loaded. - - @method hasRecordForId - @param {String or subclass of DS.Model} type - @param {String|Integer} id - @return {Boolean} - */ - hasRecordForId: function(typeName, inputId) { - var type = this.modelFor(typeName); - var id = coerceId(inputId); - return !!this.typeMapFor(type).idToRecord[id]; - }, - - /** - Returns id record for a given type and ID. If one isn't already loaded, - it builds a new record and leaves it in the `empty` state. - - @method recordForId - @private - @param {String or subclass of DS.Model} type - @param {String|Integer} id - @return {DS.Model} record - */ - recordForId: function(typeName, inputId) { - var type = this.modelFor(typeName); - var id = coerceId(inputId); - var idToRecord = this.typeMapFor(type).idToRecord; - var record = idToRecord[id]; - - if (!record || !idToRecord[id]) { - record = this.buildRecord(type, id); - } - - return record; - }, - - /** - @method findMany - @private - @param {DS.Model} owner - @param {Array} records - @param {String or subclass of DS.Model} type - @param {Resolver} resolver - @return {DS.ManyArray} records - */ - findMany: function(records) { - var store = this; - return Promise.all(map(records, function(record) { - return store._findByRecord(record); - })); - }, - - - /** - If a relationship was originally populated by the adapter as a link - (as opposed to a list of IDs), this method is called when the - relationship is fetched. - - The link (which is usually a URL) is passed through unchanged, so the - adapter can make whatever request it wants. - - The usual use-case is for the server to register a URL as a link, and - then use that URL in the future to make a request for the relationship. - - @method findHasMany - @private - @param {DS.Model} owner - @param {any} link - @param {String or subclass of DS.Model} type - @return {Promise} promise - */ - findHasMany: function(owner, link, type) { - var adapter = this.adapterFor(owner.constructor); - - Ember.assert("You tried to load a hasMany relationship but you have no adapter (for " + owner.constructor + ")", adapter); - Ember.assert("You tried to load a hasMany relationship from a specified `link` in the original payload but your adapter does not implement `findHasMany`", typeof adapter.findHasMany === 'function'); - - return _findHasMany(adapter, this, owner, link, type); - }, - - /** - @method findBelongsTo - @private - @param {DS.Model} owner - @param {any} link - @param {Relationship} relationship - @return {Promise} promise - */ - findBelongsTo: function(owner, link, relationship) { - var adapter = this.adapterFor(owner.constructor); - - Ember.assert("You tried to load a belongsTo relationship but you have no adapter (for " + owner.constructor + ")", adapter); - Ember.assert("You tried to load a belongsTo relationship from a specified `link` in the original payload but your adapter does not implement `findBelongsTo`", typeof adapter.findBelongsTo === 'function'); - - return _findBelongsTo(adapter, this, owner, link, relationship); - }, - - /** - This method delegates a query to the adapter. This is the one place where - adapter-level semantics are exposed to the application. - - Exposing queries this way seems preferable to creating an abstract query - language for all server-side queries, and then require all adapters to - implement them. - - This method returns a promise, which is resolved with a `RecordArray` - once the server returns. - - @method findQuery - @private - @param {String or subclass of DS.Model} type - @param {any} query an opaque query to be used by the adapter - @return {Promise} promise - */ - findQuery: function(typeName, query) { - var type = this.modelFor(typeName); - var array = this.recordArrayManager - .createAdapterPopulatedRecordArray(type, query); - - var adapter = this.adapterFor(type); - - Ember.assert("You tried to load a query but you have no adapter (for " + type + ")", adapter); - Ember.assert("You tried to load a query but your adapter does not implement `findQuery`", typeof adapter.findQuery === 'function'); - - return promiseArray(_findQuery(adapter, this, type, query, array)); - }, - - /** - This method returns an array of all records adapter can find. - It triggers the adapter's `findAll` method to give it an opportunity to populate - the array with records of that type. - - @method findAll - @private - @param {String or subclass of DS.Model} type - @return {DS.AdapterPopulatedRecordArray} - */ - findAll: function(typeName) { - var type = this.modelFor(typeName); - - return this.fetchAll(type, this.all(type)); - }, - - /** - @method fetchAll - @private - @param {DS.Model} type - @param {DS.RecordArray} array - @return {Promise} promise - */ - fetchAll: function(type, array) { - var adapter = this.adapterFor(type); - var sinceToken = this.typeMapFor(type).metadata.since; - - set(array, 'isUpdating', true); - - Ember.assert("You tried to load all records but you have no adapter (for " + type + ")", adapter); - Ember.assert("You tried to load all records but your adapter does not implement `findAll`", typeof adapter.findAll === 'function'); - - return promiseArray(_findAll(adapter, this, type, sinceToken)); - }, - - /** - @method didUpdateAll - @param {DS.Model} type - */ - didUpdateAll: function(type) { - var findAllCache = this.typeMapFor(type).findAllCache; - set(findAllCache, 'isUpdating', false); - }, - - /** - This method returns a filtered array that contains all of the - known records for a given type in the store. - - Note that because it's just a filter, the result will contain any - locally created records of the type, however, it will not make a - request to the backend to retrieve additional records. If you - would like to request all the records from the backend please use - [store.find](#method_find). - - Also note that multiple calls to `all` for a given type will always - return the same `RecordArray`. - - Example - - ```javascript - var localPosts = store.all('post'); - ``` - - @method all - @param {String or subclass of DS.Model} type - @return {DS.RecordArray} - */ - all: function(typeName) { - var type = this.modelFor(typeName); - var typeMap = this.typeMapFor(type); - var findAllCache = typeMap.findAllCache; - - if (findAllCache) { return findAllCache; } - - var array = this.recordArrayManager.createRecordArray(type); - - typeMap.findAllCache = array; - return array; - }, - - - /** - This method unloads all of the known records for a given type. - - ```javascript - store.unloadAll('post'); - ``` - - @method unloadAll - @param {String or subclass of DS.Model} type - */ - unloadAll: function(type) { - var modelType = this.modelFor(type); - var typeMap = this.typeMapFor(modelType); - var records = typeMap.records.slice(); - var record; - - for (var i = 0; i < records.length; i++) { - record = records[i]; - record.unloadRecord(); - record.destroy(); // maybe within unloadRecord - } - - typeMap.findAllCache = null; - }, - - /** - Takes a type and filter function, and returns a live RecordArray that - remains up to date as new records are loaded into the store or created - locally. - - The filter function takes a materialized record, and returns true - if the record should be included in the filter and false if it should - not. - - Example - - ```javascript - store.filter('post', function(post) { - return post.get('unread'); - }); - ``` - - The filter function is called once on all records for the type when - it is created, and then once on each newly loaded or created record. - - If any of a record's properties change, or if it changes state, the - filter function will be invoked again to determine whether it should - still be in the array. - - Optionally you can pass a query, which is the equivalent of calling - [find](#method_find) with that same query, to fetch additional records - from the server. The results returned by the server could then appear - in the filter if they match the filter function. - - The query itself is not used to filter records, it's only sent to your - server for you to be able to do server-side filtering. The filter - function will be applied on the returned results regardless. - - Example - - ```javascript - store.filter('post', { unread: true }, function(post) { - return post.get('unread'); - }).then(function(unreadPosts) { - unreadPosts.get('length'); // 5 - var unreadPost = unreadPosts.objectAt(0); - unreadPost.set('unread', false); - unreadPosts.get('length'); // 4 - }); - ``` - - @method filter - @param {String or subclass of DS.Model} type - @param {Object} query optional query - @param {Function} filter - @return {DS.PromiseArray} - */ - filter: function(type, query, filter) { - var promise; - var length = arguments.length; - var array; - var hasQuery = length === 3; - - // allow an optional server query - if (hasQuery) { - promise = this.findQuery(type, query); - } else if (arguments.length === 2) { - filter = query; - } - - type = this.modelFor(type); - - if (hasQuery) { - array = this.recordArrayManager.createFilteredRecordArray(type, filter, query); - } else { - array = this.recordArrayManager.createFilteredRecordArray(type, filter); - } - - promise = promise || Promise.cast(array); - - - return promiseArray(promise.then(function() { - return array; - }, null, "DS: Store#filter of " + type)); - }, - - /** - This method returns if a certain record is already loaded - in the store. Use this function to know beforehand if a find() - will result in a request or that it will be a cache hit. - - Example - - ```javascript - store.recordIsLoaded('post', 1); // false - store.find('post', 1).then(function() { - store.recordIsLoaded('post', 1); // true - }); - ``` - - @method recordIsLoaded - @param {String or subclass of DS.Model} type - @param {string} id - @return {boolean} - */ - recordIsLoaded: function(type, id) { - if (!this.hasRecordForId(type, id)) { return false; } - return !get(this.recordForId(type, id), 'isEmpty'); - }, - - /** - This method returns the metadata for a specific type. - - @method metadataFor - @param {String or subclass of DS.Model} type - @return {object} - */ - metadataFor: function(type) { - type = this.modelFor(type); - return this.typeMapFor(type).metadata; - }, - - // ............ - // . UPDATING . - // ............ - - /** - If the adapter updates attributes or acknowledges creation - or deletion, the record will notify the store to update its - membership in any filters. - To avoid thrashing, this method is invoked only once per - - run loop per record. - - @method dataWasUpdated - @private - @param {Class} type - @param {DS.Model} record - */ - dataWasUpdated: function(type, record) { - this.recordArrayManager.recordDidChange(record); - }, - - // .............. - // . PERSISTING . - // .............. - - /** - This method is called by `record.save`, and gets passed a - resolver for the promise that `record.save` returns. - - It schedules saving to happen at the end of the run loop. - - @method scheduleSave - @private - @param {DS.Model} record - @param {Resolver} resolver - */ - scheduleSave: function(record, resolver) { - record.adapterWillCommit(); - this._pendingSave.push([record, resolver]); - once(this, 'flushPendingSave'); - }, - - /** - This method is called at the end of the run loop, and - flushes any records passed into `scheduleSave` - - @method flushPendingSave - @private - */ - flushPendingSave: function() { - var pending = this._pendingSave.slice(); - this._pendingSave = []; - - forEach(pending, function(tuple) { - var record = tuple[0], resolver = tuple[1]; - var adapter = this.adapterFor(record.constructor); - var operation; - - if (get(record, 'currentState.stateName') === 'root.deleted.saved') { - return resolver.resolve(record); - } else if (get(record, 'isNew')) { - operation = 'createRecord'; - } else if (get(record, 'isDeleted')) { - operation = 'deleteRecord'; - } else { - operation = 'updateRecord'; - } - - resolver.resolve(_commit(adapter, this, operation, record)); - }, this); - }, - - /** - This method is called once the promise returned by an - adapter's `createRecord`, `updateRecord` or `deleteRecord` - is resolved. - - If the data provides a server-generated ID, it will - update the record and the store's indexes. - - @method didSaveRecord - @private - @param {DS.Model} record the in-flight record - @param {Object} data optional data (see above) - */ - didSaveRecord: function(record, data) { - if (data) { - // normalize relationship IDs into records - data = normalizeRelationships(this, record.constructor, data, record); - setupRelationships(this, record, data); - - this.updateId(record, data); - } - - record.adapterDidCommit(data); - }, - - /** - This method is called once the promise returned by an - adapter's `createRecord`, `updateRecord` or `deleteRecord` - is rejected with a `DS.InvalidError`. - - @method recordWasInvalid - @private - @param {DS.Model} record - @param {Object} errors - */ - recordWasInvalid: function(record, errors) { - record.adapterDidInvalidate(errors); - }, - - /** - This method is called once the promise returned by an - adapter's `createRecord`, `updateRecord` or `deleteRecord` - is rejected (with anything other than a `DS.InvalidError`). - - @method recordWasError - @private - @param {DS.Model} record - */ - recordWasError: function(record) { - record.adapterDidError(); - }, - - /** - When an adapter's `createRecord`, `updateRecord` or `deleteRecord` - resolves with data, this method extracts the ID from the supplied - data. - - @method updateId - @private - @param {DS.Model} record - @param {Object} data - */ - updateId: function(record, data) { - var oldId = get(record, 'id'); - var id = coerceId(data.id); - - Ember.assert("An adapter cannot assign a new id to a record that already has an id. " + record + " had id: " + oldId + " and you tried to update it with " + id + ". This likely happened because your server returned data in response to a find or update that had a different id than the one you sent.", oldId === null || id === oldId); - - this.typeMapFor(record.constructor).idToRecord[id] = record; - - set(record, 'id', id); - }, - - /** - Returns a map of IDs to client IDs for a given type. - - @method typeMapFor - @private - @param {subclass of DS.Model} type - @return {Object} typeMap - */ - typeMapFor: function(type) { - var typeMaps = get(this, 'typeMaps'); - var guid = Ember.guidFor(type); - var typeMap; - - typeMap = typeMaps[guid]; - - if (typeMap) { return typeMap; } - - typeMap = { - idToRecord: Ember.create(null), - records: [], - metadata: Ember.create(null), - type: type - }; - - typeMaps[guid] = typeMap; - - return typeMap; - }, - - // ................ - // . LOADING DATA . - // ................ - - /** - This internal method is used by `push`. - - @method _load - @private - @param {String or subclass of DS.Model} type - @param {Object} data - @param {Boolean} partial the data should be merged into - the existing data, not replace it. - */ - _load: function(type, data, partial) { - var id = coerceId(data.id); - var record = this.recordForId(type, id); - - record.setupData(data, partial); - this.recordArrayManager.recordDidChange(record); - - return record; - }, - - /** - Returns a model class for a particular key. Used by - methods that take a type key (like `find`, `createRecord`, - etc.) - - @method modelFor - @param {String or subclass of DS.Model} key - @return {subclass of DS.Model} - */ - modelFor: function(key) { - var factory; - - if (typeof key === 'string') { - factory = this.modelFactoryFor(key); - if (!factory) { - throw new Ember.Error("No model was found for '" + key + "'"); - } - factory.typeKey = factory.typeKey || this._normalizeTypeKey(key); - } else { - // A factory already supplied. Ensure it has a normalized key. - factory = key; - if (factory.typeKey) { - factory.typeKey = this._normalizeTypeKey(factory.typeKey); - } - } - - factory.store = this; - return factory; - }, - - modelFactoryFor: function(key){ - return this.container.lookupFactory('model:' + key); - }, - - /** - Push some data for a given type into the store. - - This method expects normalized data: - - * The ID is a key named `id` (an ID is mandatory) - * The names of attributes are the ones you used in - your model's `DS.attr`s. - * Your relationships must be: - * represented as IDs or Arrays of IDs - * represented as model instances - * represented as URLs, under the `links` key - - For this model: - - ```js - App.Person = DS.Model.extend({ - firstName: DS.attr(), - lastName: DS.attr(), - - children: DS.hasMany('person') - }); - ``` - - To represent the children as IDs: - - ```js - { - id: 1, - firstName: "Tom", - lastName: "Dale", - children: [1, 2, 3] - } - ``` - - To represent the children relationship as a URL: - - ```js - { - id: 1, - firstName: "Tom", - lastName: "Dale", - links: { - children: "/people/1/children" - } - } - ``` - - If you're streaming data or implementing an adapter, - make sure that you have converted the incoming data - into this form. - - This method can be used both to push in brand new - records, as well as to update existing records. - - @method push - @param {String or subclass of DS.Model} type - @param {Object} data - @return {DS.Model} the record that was created or - updated. - */ - push: function(typeName, data, _partial) { - // _partial is an internal param used by `update`. - // If passed, it means that the data should be - // merged into the existing data, not replace it. - Ember.assert("Expected an object as `data` in a call to `push`/`update` for " + typeName + " , but was " + data, Ember.typeOf(data) === 'object'); - Ember.assert("You must include an `id` for " + typeName + " in an object passed to `push`/`update`", data.id != null && data.id !== ''); - - var type = this.modelFor(typeName); - var filter = Ember.EnumerableUtils.filter; - - // If the payload contains relationships that are specified as - // IDs, normalizeRelationships will convert them into DS.Model instances - // (possibly unloaded) before we push the payload into the - // store. - - data = normalizeRelationships(this, type, data); - - Ember.warn("The payload for '" + typeName + "' contains these unknown keys: " + - Ember.inspect(filter(Ember.keys(data), function(key) { - return !get(type, 'fields').has(key) && key !== 'id' && key !== 'links'; - })) + ". Make sure they've been defined in your model.", - filter(Ember.keys(data), function(key) { - return !get(type, 'fields').has(key) && key !== 'id' && key !== 'links'; - }).length === 0 - ); - - // Actually load the record into the store. - - this._load(type, data, _partial); - - var record = this.recordForId(type, data.id); - - // Now that the pushed record as well as any related records - // are in the store, create the data structures used to track - // relationships. - setupRelationships(this, record, data); - - return record; - }, - - /** - Push some raw data into the store. - - This method can be used both to push in brand new - records, as well as to update existing records. You - can push in more than one type of object at once. - All objects should be in the format expected by the - serializer. - - ```js - App.ApplicationSerializer = DS.ActiveModelSerializer; - - var pushData = { - posts: [ - {id: 1, post_title: "Great post", comment_ids: [2]} - ], - comments: [ - {id: 2, comment_body: "Insightful comment"} - ] - } - - store.pushPayload(pushData); - ``` - - By default, the data will be deserialized using a default - serializer (the application serializer if it exists). - - Alternatively, `pushPayload` will accept a model type which - will determine which serializer will process the payload. - However, the serializer itself (processing this data via - `normalizePayload`) will not know which model it is - deserializing. - - ```js - App.ApplicationSerializer = DS.ActiveModelSerializer; - App.PostSerializer = DS.JSONSerializer; - store.pushPayload('comment', pushData); // Will use the ApplicationSerializer - store.pushPayload('post', pushData); // Will use the PostSerializer - ``` - - @method pushPayload - @param {String} type Optionally, a model used to determine which serializer will be used - @param {Object} payload - */ - pushPayload: function (type, inputPayload) { - var serializer; - var payload; - if (!inputPayload) { - payload = type; - serializer = defaultSerializer(this.container); - Ember.assert("You cannot use `store#pushPayload` without a type unless your default serializer defines `pushPayload`", typeof serializer.pushPayload === 'function'); - } else { - payload = inputPayload; - serializer = this.serializerFor(type); - } - serializer.pushPayload(this, payload); - }, - - /** - `normalize` converts a json payload into the normalized form that - [push](#method_push) expects. - - Example - - ```js - socket.on('message', function(message) { - var modelName = message.model; - var data = message.data; - store.push(modelName, store.normalize(modelName, data)); - }); - ``` - - @method normalize - @param {String} type The name of the model type for this payload - @param {Object} payload - @return {Object} The normalized payload - */ - normalize: function (type, payload) { - var serializer = this.serializerFor(type); - var model = this.modelFor(type); - return serializer.normalize(model, payload); - }, - - /** - Update existing records in the store. Unlike [push](#method_push), - update will merge the new data properties with the existing - properties. This makes it safe to use with a subset of record - attributes. This method expects normalized data. - - `update` is useful if your app broadcasts partial updates to - records. - - ```js - App.Person = DS.Model.extend({ - firstName: DS.attr('string'), - lastName: DS.attr('string') - }); - - store.get('person', 1).then(function(tom) { - tom.get('firstName'); // Tom - tom.get('lastName'); // Dale - - var updateEvent = {id: 1, firstName: "TomHuda"}; - store.update('person', updateEvent); - - tom.get('firstName'); // TomHuda - tom.get('lastName'); // Dale - }); - ``` - - @method update - @param {String} type - @param {Object} data - @return {DS.Model} the record that was updated. - */ - update: function(type, data) { - return this.push(type, data, true); - }, - - /** - If you have an Array of normalized data to push, - you can call `pushMany` with the Array, and it will - call `push` repeatedly for you. - - @method pushMany - @param {String or subclass of DS.Model} type - @param {Array} datas - @return {Array} - */ - pushMany: function(type, datas) { - var length = datas.length; - var result = new Array(length); - - for (var i = 0; i < length; i++) { - result[i] = this.push(type, datas[i]); - } - - return result; - }, - - /** - If you have some metadata to set for a type - you can call `metaForType`. - - @method metaForType - @param {String or subclass of DS.Model} type - @param {Object} metadata - */ - metaForType: function(typeName, metadata) { - var type = this.modelFor(typeName); - - Ember.merge(this.typeMapFor(type).metadata, metadata); - }, - - /** - Build a brand new record for a given type, ID, and - initial data. - - @method buildRecord - @private - @param {subclass of DS.Model} type - @param {String} id - @param {Object} data - @return {DS.Model} record - */ - buildRecord: function(type, id, data) { - var typeMap = this.typeMapFor(type); - var idToRecord = typeMap.idToRecord; - - Ember.assert('The id ' + id + ' has already been used with another record of type ' + type.toString() + '.', !id || !idToRecord[id]); - Ember.assert("`" + Ember.inspect(type)+ "` does not appear to be an ember-data model", (typeof type._create === 'function') ); - - // lookupFactory should really return an object that creates - // instances with the injections applied - var record = type._create({ - id: id, - store: this, - container: this.container - }); - - if (data) { - record.setupData(data); - } - - // if we're creating an item, this process will be done - // later, once the object has been persisted. - if (id) { - idToRecord[id] = record; - } - - typeMap.records.push(record); - - return record; - }, - - // ............... - // . DESTRUCTION . - // ............... - - /** - When a record is destroyed, this un-indexes it and - removes it from any record arrays so it can be GCed. - - @method dematerializeRecord - @private - @param {DS.Model} record - */ - dematerializeRecord: function(record) { - var type = record.constructor; - var typeMap = this.typeMapFor(type); - var id = get(record, 'id'); - - record.updateRecordArrays(); - - if (id) { - delete typeMap.idToRecord[id]; - } - - var loc = indexOf(typeMap.records, record); - typeMap.records.splice(loc, 1); - }, - - // ...................... - // . PER-TYPE ADAPTERS - // ...................... - - /** - Returns the adapter for a given type. - - @method adapterFor - @private - @param {subclass of DS.Model} type - @return DS.Adapter - */ - adapterFor: function(type) { - var container = this.container, adapter; - - if (container) { - adapter = container.lookup('adapter:' + type.typeKey) || container.lookup('adapter:application'); - } - - return adapter || get(this, 'defaultAdapter'); - }, - - // .............................. - // . RECORD CHANGE NOTIFICATION . - // .............................. - - /** - Returns an instance of the serializer for a given type. For - example, `serializerFor('person')` will return an instance of - `App.PersonSerializer`. - - If no `App.PersonSerializer` is found, this method will look - for an `App.ApplicationSerializer` (the default serializer for - your entire application). - - If no `App.ApplicationSerializer` is found, it will fall back - to an instance of `DS.JSONSerializer`. - - @method serializerFor - @private - @param {String} type the record to serialize - @return {DS.Serializer} - */ - serializerFor: function(type) { - type = this.modelFor(type); - var adapter = this.adapterFor(type); - - return serializerFor(this.container, type.typeKey, adapter && adapter.defaultSerializer); - }, - - willDestroy: function() { - var typeMaps = this.typeMaps; - var keys = Ember.keys(typeMaps); - - var types = map(keys, byType); - - this.recordArrayManager.destroy(); - - forEach(types, this.unloadAll, this); - - function byType(entry) { - return typeMaps[entry]['type']; - } - - }, - - /** - All typeKeys are camelCase internally. Changing this function may - require changes to other normalization hooks (such as typeForRoot). - - @method _normalizeTypeKey - @private - @param {String} type - @return {String} if the adapter can generate one, an ID - */ - _normalizeTypeKey: function(key) { - return camelize(singularize(key)); - } - }); - - - function normalizeRelationships(store, type, data, record) { - type.eachRelationship(function(key, relationship) { - var kind = relationship.kind; - var value = data[key]; - if (kind === 'belongsTo') { - deserializeRecordId(store, data, key, relationship, value); - } else if (kind === 'hasMany') { - deserializeRecordIds(store, data, key, relationship, value); - } - }); - - return data; - } - - function deserializeRecordId(store, data, key, relationship, id) { - if (!Model) { Model = requireModule("ember-data/system/model")["Model"]; } - if (isNone(id) || id instanceof Model) { - return; - } - Ember.assert("A " + relationship.parentType + " record was pushed into the store with the value of " + key + " being " + Ember.inspect(id) + ", but " + key + " is a belongsTo relationship so the value must not be an array. You should probably check your data payload or serializer.", !Ember.isArray(id)); - - var type; - - if (typeof id === 'number' || typeof id === 'string') { - type = typeFor(relationship, key, data); - data[key] = store.recordForId(type, id); - } else if (typeof id === 'object') { - // polymorphic - data[key] = store.recordForId(id.type, id.id); - } - } - - function typeFor(relationship, key, data) { - if (relationship.options.polymorphic) { - return data[key + "Type"]; - } else { - return relationship.type; - } - } - - function deserializeRecordIds(store, data, key, relationship, ids) { - if (isNone(ids)) { - return; - } - - Ember.assert("A " + relationship.parentType + " record was pushed into the store with the value of " + key + " being '" + Ember.inspect(ids) + "', but " + key + " is a hasMany relationship so the value must be an array. You should probably check your data payload or serializer.", Ember.isArray(ids)); - for (var i=0, l=ids.length; i<l; i++) { - deserializeRecordId(store, ids, i, relationship, ids[i]); - } - } - - // Delegation to the adapter and promise management - - - function serializerFor(container, type, defaultSerializer) { - return container.lookup('serializer:'+type) || - container.lookup('serializer:application') || - container.lookup('serializer:' + defaultSerializer) || - container.lookup('serializer:-default'); - } - - function defaultSerializer(container) { - return container.lookup('serializer:application') || - container.lookup('serializer:-default'); - } - - function serializerForAdapter(adapter, type) { - var serializer = adapter.serializer; - var defaultSerializer = adapter.defaultSerializer; - var container = adapter.container; - - if (container && serializer === undefined) { - serializer = serializerFor(container, type.typeKey, defaultSerializer); - } - - if (serializer === null || serializer === undefined) { - serializer = { - extract: function(store, type, payload) { return payload; } - }; - } - - return serializer; - } - - function _objectIsAlive(object) { - return !(get(object, "isDestroyed") || get(object, "isDestroying")); - } - - function _guard(promise, test) { - var guarded = promise['finally'](function() { - if (!test()) { - guarded._subscribers.length = 0; - } - }); - - return guarded; - } - - function _bind(fn) { - var args = Array.prototype.slice.call(arguments, 1); - - return function() { - return fn.apply(undefined, args); - }; - } - - function _find(adapter, store, type, id, record) { - var promise = adapter.find(store, type, id, record); - var serializer = serializerForAdapter(adapter, type); - var label = "DS: Handle Adapter#find of " + type + " with id: " + id; - - promise = Promise.cast(promise, label); - promise = _guard(promise, _bind(_objectIsAlive, store)); - - return promise.then(function(adapterPayload) { - Ember.assert("You made a request for a " + type.typeKey + " with id " + id + ", but the adapter's response did not have any data", adapterPayload); - var payload = serializer.extract(store, type, adapterPayload, id, 'find'); - - return store.push(type, payload); - }, function(error) { - var record = store.getById(type, id); - if (record) { - record.notFound(); - } - throw error; - }, "DS: Extract payload of '" + type + "'"); - } - - - function _findMany(adapter, store, type, ids, records) { - var promise = adapter.findMany(store, type, ids, records); - var serializer = serializerForAdapter(adapter, type); - var label = "DS: Handle Adapter#findMany of " + type; - - if (promise === undefined) { - throw new Error('adapter.findMany returned undefined, this was very likely a mistake'); - } - - promise = Promise.cast(promise, label); - promise = _guard(promise, _bind(_objectIsAlive, store)); - - return promise.then(function(adapterPayload) { - var payload = serializer.extract(store, type, adapterPayload, null, 'findMany'); - - Ember.assert("The response from a findMany must be an Array, not " + Ember.inspect(payload), Ember.typeOf(payload) === 'array'); - - return store.pushMany(type, payload); - }, null, "DS: Extract payload of " + type); - } - - function _findHasMany(adapter, store, record, link, relationship) { - var promise = adapter.findHasMany(store, record, link, relationship); - var serializer = serializerForAdapter(adapter, relationship.type); - var label = "DS: Handle Adapter#findHasMany of " + record + " : " + relationship.type; - - promise = Promise.cast(promise, label); - promise = _guard(promise, _bind(_objectIsAlive, store)); - promise = _guard(promise, _bind(_objectIsAlive, record)); - - return promise.then(function(adapterPayload) { - var payload = serializer.extract(store, relationship.type, adapterPayload, null, 'findHasMany'); - - Ember.assert("The response from a findHasMany must be an Array, not " + Ember.inspect(payload), Ember.typeOf(payload) === 'array'); - - var records = store.pushMany(relationship.type, payload); - return records; - }, null, "DS: Extract payload of " + record + " : hasMany " + relationship.type); - } - - function _findBelongsTo(adapter, store, record, link, relationship) { - var promise = adapter.findBelongsTo(store, record, link, relationship); - var serializer = serializerForAdapter(adapter, relationship.type); - var label = "DS: Handle Adapter#findBelongsTo of " + record + " : " + relationship.type; - - promise = Promise.cast(promise, label); - promise = _guard(promise, _bind(_objectIsAlive, store)); - promise = _guard(promise, _bind(_objectIsAlive, record)); - - return promise.then(function(adapterPayload) { - var payload = serializer.extract(store, relationship.type, adapterPayload, null, 'findBelongsTo'); - - if (!payload) { - return null; - } - - var record = store.push(relationship.type, payload); - return record; - }, null, "DS: Extract payload of " + record + " : " + relationship.type); - } - - function _findAll(adapter, store, type, sinceToken) { - var promise = adapter.findAll(store, type, sinceToken); - var serializer = serializerForAdapter(adapter, type); - var label = "DS: Handle Adapter#findAll of " + type; - - promise = Promise.cast(promise, label); - promise = _guard(promise, _bind(_objectIsAlive, store)); - - return promise.then(function(adapterPayload) { - var payload = serializer.extract(store, type, adapterPayload, null, 'findAll'); - - Ember.assert("The response from a findAll must be an Array, not " + Ember.inspect(payload), Ember.typeOf(payload) === 'array'); - - store.pushMany(type, payload); - store.didUpdateAll(type); - return store.all(type); - }, null, "DS: Extract payload of findAll " + type); - } - - function _findQuery(adapter, store, type, query, recordArray) { - var promise = adapter.findQuery(store, type, query, recordArray); - var serializer = serializerForAdapter(adapter, type); - var label = "DS: Handle Adapter#findQuery of " + type; - - promise = Promise.cast(promise, label); - promise = _guard(promise, _bind(_objectIsAlive, store)); - - return promise.then(function(adapterPayload) { - var payload = serializer.extract(store, type, adapterPayload, null, 'findQuery'); - - Ember.assert("The response from a findQuery must be an Array, not " + Ember.inspect(payload), Ember.typeOf(payload) === 'array'); - - recordArray.load(payload); - return recordArray; - }, null, "DS: Extract payload of findQuery " + type); - } - - function _commit(adapter, store, operation, record) { - var type = record.constructor; - var promise = adapter[operation](store, type, record); - var serializer = serializerForAdapter(adapter, type); - var label = "DS: Extract and notify about " + operation + " completion of " + record; - - Ember.assert("Your adapter's '" + operation + "' method must return a value, but it returned `undefined", promise !==undefined); - - promise = Promise.cast(promise, label); - promise = _guard(promise, _bind(_objectIsAlive, store)); - promise = _guard(promise, _bind(_objectIsAlive, record)); - - return promise.then(function(adapterPayload) { - var payload; - - if (adapterPayload) { - payload = serializer.extract(store, type, adapterPayload, get(record, 'id'), operation); - } else { - payload = adapterPayload; - } - - store.didSaveRecord(record, payload); - return record; - }, function(reason) { - if (reason instanceof InvalidError) { - var errors = serializer.extractErrors(store, type, reason.errors, get(record, 'id')); - store.recordWasInvalid(record, errors); - reason = new InvalidError(errors); - } else { - store.recordWasError(record, reason); - } - - throw reason; - }, label); - } - - function setupRelationships(store, record, data) { - var type = record.constructor; - - type.eachRelationship(function(key, descriptor) { - var kind = descriptor.kind; - var value = data[key]; - var relationship = record._relationships[key]; - - if (data.links && data.links[key]) { - relationship.updateLink(data.links[key]); - } - - if (kind === 'belongsTo') { - if (value === undefined) { - return; - } - relationship.setRecord(value); - } else if (kind === 'hasMany' && value) { - relationship.updateRecordsFromAdapter(value); - } - }); - } - - __exports__.Store = Store; - __exports__["default"] = Store; - }); -enifed("ember-data/transforms", - ["ember-data/transforms/base","ember-data/transforms/number","ember-data/transforms/date","ember-data/transforms/string","ember-data/transforms/boolean","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) { - "use strict"; - var Transform = __dependency1__["default"]; - var NumberTransform = __dependency2__["default"]; - var DateTransform = __dependency3__["default"]; - var StringTransform = __dependency4__["default"]; - var BooleanTransform = __dependency5__["default"]; - - __exports__.Transform = Transform; - __exports__.NumberTransform = NumberTransform; - __exports__.DateTransform = DateTransform; - __exports__.StringTransform = StringTransform; - __exports__.BooleanTransform = BooleanTransform; - }); -enifed("ember-data/transforms/base", - ["exports"], - function(__exports__) { - "use strict"; - /** - The `DS.Transform` class is used to serialize and deserialize model - attributes when they are saved or loaded from an - adapter. Subclassing `DS.Transform` is useful for creating custom - attributes. All subclasses of `DS.Transform` must implement a - `serialize` and a `deserialize` method. - - Example - - ```javascript - // Converts centigrade in the JSON to fahrenheit in the app - App.TemperatureTransform = DS.Transform.extend({ - deserialize: function(serialized) { - return (serialized * 1.8) + 32; - }, - serialize: function(deserialized) { - return (deserialized - 32) / 1.8; - } - }); - ``` - - Usage - - ```javascript - var attr = DS.attr; - App.Requirement = DS.Model.extend({ - name: attr('string'), - temperature: attr('temperature') - }); - ``` - - @class Transform - @namespace DS - */ - __exports__["default"] = Ember.Object.extend({ - /** - When given a deserialized value from a record attribute this - method must return the serialized value. - - Example - - ```javascript - serialize: function(deserialized) { - return Ember.isEmpty(deserialized) ? null : Number(deserialized); - } - ``` - - @method serialize - @param {mixed} deserialized The deserialized value - @return {mixed} The serialized value - */ - serialize: Ember.required(), - - /** - When given a serialize value from a JSON object this method must - return the deserialized value for the record attribute. - - Example - - ```javascript - deserialize: function(serialized) { - return empty(serialized) ? null : Number(serialized); - } - ``` - - @method deserialize - @param {mixed} serialized The serialized value - @return {mixed} The deserialized value - */ - deserialize: Ember.required() - }); - }); -enifed("ember-data/transforms/boolean", - ["ember-data/transforms/base","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var Transform = __dependency1__["default"]; - - /** - The `DS.BooleanTransform` class is used to serialize and deserialize - boolean attributes on Ember Data record objects. This transform is - used when `boolean` is passed as the type parameter to the - [DS.attr](../../data#method_attr) function. - - Usage - - ```javascript - var attr = DS.attr; - App.User = DS.Model.extend({ - isAdmin: attr('boolean'), - name: attr('string'), - email: attr('string') - }); - ``` - - @class BooleanTransform - @extends DS.Transform - @namespace DS - */ - __exports__["default"] = Transform.extend({ - deserialize: function(serialized) { - var type = typeof serialized; - - if (type === "boolean") { - return serialized; - } else if (type === "string") { - return serialized.match(/^true$|^t$|^1$/i) !== null; - } else if (type === "number") { - return serialized === 1; - } else { - return false; - } - }, - - serialize: function(deserialized) { - return Boolean(deserialized); - } - }); - }); -enifed("ember-data/transforms/date", - ["ember-data/transforms/base","exports"], - function(__dependency1__, __exports__) { - "use strict"; - /** - The `DS.DateTransform` class is used to serialize and deserialize - date attributes on Ember Data record objects. This transform is used - when `date` is passed as the type parameter to the - [DS.attr](../../data#method_attr) function. - - ```javascript - var attr = DS.attr; - App.Score = DS.Model.extend({ - value: attr('number'), - player: DS.belongsTo('player'), - date: attr('date') - }); - ``` - - @class DateTransform - @extends DS.Transform - @namespace DS - */ - var Transform = __dependency1__["default"]; - - // Date.prototype.toISOString shim - // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString - var toISOString = Date.prototype.toISOString || function() { - function pad(number) { - if ( number < 10 ) { - return '0' + number; - } - return number; - } - - return this.getUTCFullYear() + - '-' + pad( this.getUTCMonth() + 1 ) + - '-' + pad( this.getUTCDate() ) + - 'T' + pad( this.getUTCHours() ) + - ':' + pad( this.getUTCMinutes() ) + - ':' + pad( this.getUTCSeconds() ) + - '.' + (this.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + - 'Z'; - }; - - if (Ember.SHIM_ES5) { - if (!Date.prototype.toISOString) { - Date.prototype.toISOString = toISOString; - } - } - - __exports__["default"] = Transform.extend({ - deserialize: function(serialized) { - var type = typeof serialized; - - if (type === "string") { - return new Date(Ember.Date.parse(serialized)); - } else if (type === "number") { - return new Date(serialized); - } else if (serialized === null || serialized === undefined) { - // if the value is not present in the data, - // return undefined, not null. - return serialized; - } else { - return null; - } - }, - - serialize: function(date) { - if (date instanceof Date) { - return toISOString.call(date); - } else { - return null; - } - } - }); - }); -enifed("ember-data/transforms/number", - ["ember-data/transforms/base","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var Transform = __dependency1__["default"]; - - var empty = Ember.isEmpty; - - /** - The `DS.NumberTransform` class is used to serialize and deserialize - numeric attributes on Ember Data record objects. This transform is - used when `number` is passed as the type parameter to the - [DS.attr](../../data#method_attr) function. - - Usage - - ```javascript - var attr = DS.attr; - App.Score = DS.Model.extend({ - value: attr('number'), - player: DS.belongsTo('player'), - date: attr('date') - }); - ``` - - @class NumberTransform - @extends DS.Transform - @namespace DS - */ - __exports__["default"] = Transform.extend({ - deserialize: function(serialized) { - return empty(serialized) ? null : Number(serialized); - }, - - serialize: function(deserialized) { - return empty(deserialized) ? null : Number(deserialized); - } - }); - }); -enifed("ember-data/transforms/string", - ["ember-data/transforms/base","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var Transform = __dependency1__["default"]; - var none = Ember.isNone; - - /** - The `DS.StringTransform` class is used to serialize and deserialize - string attributes on Ember Data record objects. This transform is - used when `string` is passed as the type parameter to the - [DS.attr](../../data#method_attr) function. - - Usage - - ```javascript - var attr = DS.attr; - App.User = DS.Model.extend({ - isAdmin: attr('boolean'), - name: attr('string'), - email: attr('string') - }); - ``` - - @class StringTransform - @extends DS.Transform - @namespace DS - */ - __exports__["default"] = Transform.extend({ - deserialize: function(serialized) { - return none(serialized) ? null : String(serialized); - }, - serialize: function(deserialized) { - return none(deserialized) ? null : String(deserialized); - } - }); - }); -enifed("ember-inflector", - ["./system","./helpers","./ext/string","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __exports__) { - "use strict"; - var Inflector = __dependency1__.Inflector; - var defaultRules = __dependency1__.defaultRules; - var pluralize = __dependency1__.pluralize; - var singularize = __dependency1__.singularize; - - Inflector.defaultRules = defaultRules; - Ember.Inflector = Inflector; - - Ember.String.pluralize = pluralize; - Ember.String.singularize = singularize; - - - __exports__["default"] = Inflector; - - __exports__.pluralize = pluralize; - __exports__.singularize = singularize; - }); -enifed("ember-inflector/ext/string", - ["../system/string"], - function(__dependency1__) { - "use strict"; - var pluralize = __dependency1__.pluralize; - var singularize = __dependency1__.singularize; - - if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) { - /** - See {{#crossLink "Ember.String/pluralize"}}{{/crossLink}} - - @method pluralize - @for String - */ - String.prototype.pluralize = function() { - return pluralize(this); - }; - - /** - See {{#crossLink "Ember.String/singularize"}}{{/crossLink}} - - @method singularize - @for String - */ - String.prototype.singularize = function() { - return singularize(this); - }; - } - }); -enifed("ember-inflector/helpers", - ["./system/string"], - function(__dependency1__) { - "use strict"; - var singularize = __dependency1__.singularize; - var pluralize = __dependency1__.pluralize; - - /** - * - * If you have Ember Inflector (such as if Ember Data is present), - * singularize a word. For example, turn "oxen" into "ox". - * - * Example: - * - * {{singularize myProperty}} - * {{singularize "oxen"}} - * - * @for Ember.Handlebars.helpers - * @method singularize - * @param {String|Property} word word to singularize - */ - Ember.Handlebars.helper('singularize', singularize); - - /** - * - * If you have Ember Inflector (such as if Ember Data is present), - * pluralize a word. For example, turn "ox" into "oxen". - * - * Example: - * - * {{pluralize myProperty}} - * {{pluralize "oxen"}} - * - * @for Ember.Handlebars.helpers - * @method pluralize - * @param {String|Property} word word to pluralize - */ - Ember.Handlebars.helper('pluralize', pluralize); - }); -enifed("ember-inflector/system", - ["./system/inflector","./system/string","./system/inflections","exports"], - function(__dependency1__, __dependency2__, __dependency3__, __exports__) { - "use strict"; - var Inflector = __dependency1__["default"]; - - var pluralize = __dependency2__.pluralize; - var singularize = __dependency2__.singularize; - - var defaultRules = __dependency3__["default"]; - - - Inflector.inflector = new Inflector(defaultRules); - - __exports__.Inflector = Inflector; - __exports__.singularize = singularize; - __exports__.pluralize = pluralize; - __exports__.defaultRules = defaultRules; - }); -enifed("ember-inflector/system/inflections", - ["exports"], - function(__exports__) { - "use strict"; - __exports__["default"] = { - plurals: [ - [/$/, 's'], - [/s$/i, 's'], - [/^(ax|test)is$/i, '$1es'], - [/(octop|vir)us$/i, '$1i'], - [/(octop|vir)i$/i, '$1i'], - [/(alias|status)$/i, '$1es'], - [/(bu)s$/i, '$1ses'], - [/(buffal|tomat)o$/i, '$1oes'], - [/([ti])um$/i, '$1a'], - [/([ti])a$/i, '$1a'], - [/sis$/i, 'ses'], - [/(?:([^f])fe|([lr])f)$/i, '$1$2ves'], - [/(hive)$/i, '$1s'], - [/([^aeiouy]|qu)y$/i, '$1ies'], - [/(x|ch|ss|sh)$/i, '$1es'], - [/(matr|vert|ind)(?:ix|ex)$/i, '$1ices'], - [/^(m|l)ouse$/i, '$1ice'], - [/^(m|l)ice$/i, '$1ice'], - [/^(ox)$/i, '$1en'], - [/^(oxen)$/i, '$1'], - [/(quiz)$/i, '$1zes'] - ], - - singular: [ - [/s$/i, ''], - [/(ss)$/i, '$1'], - [/(n)ews$/i, '$1ews'], - [/([ti])a$/i, '$1um'], - [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '$1sis'], - [/(^analy)(sis|ses)$/i, '$1sis'], - [/([^f])ves$/i, '$1fe'], - [/(hive)s$/i, '$1'], - [/(tive)s$/i, '$1'], - [/([lr])ves$/i, '$1f'], - [/([^aeiouy]|qu)ies$/i, '$1y'], - [/(s)eries$/i, '$1eries'], - [/(m)ovies$/i, '$1ovie'], - [/(x|ch|ss|sh)es$/i, '$1'], - [/^(m|l)ice$/i, '$1ouse'], - [/(bus)(es)?$/i, '$1'], - [/(o)es$/i, '$1'], - [/(shoe)s$/i, '$1'], - [/(cris|test)(is|es)$/i, '$1is'], - [/^(a)x[ie]s$/i, '$1xis'], - [/(octop|vir)(us|i)$/i, '$1us'], - [/(alias|status)(es)?$/i, '$1'], - [/^(ox)en/i, '$1'], - [/(vert|ind)ices$/i, '$1ex'], - [/(matr)ices$/i, '$1ix'], - [/(quiz)zes$/i, '$1'], - [/(database)s$/i, '$1'] - ], - - irregularPairs: [ - ['person', 'people'], - ['man', 'men'], - ['child', 'children'], - ['sex', 'sexes'], - ['move', 'moves'], - ['cow', 'kine'], - ['zombie', 'zombies'] - ], - - uncountable: [ - 'equipment', - 'information', - 'rice', - 'money', - 'species', - 'series', - 'fish', - 'sheep', - 'jeans', - 'police' - ] - }; - }); -enifed("ember-inflector/system/inflector", - ["exports"], - function(__exports__) { - "use strict"; - var BLANK_REGEX = /^\s*$/; - var LAST_WORD_DASHED_REGEX = /(\w+[_-])([a-z\d]+$)/; - var LAST_WORD_CAMELIZED_REGEX = /(\w+)([A-Z][a-z\d]*$)/; - var CAMELIZED_REGEX = /[A-Z][a-z\d]*$/; - - function loadUncountable(rules, uncountable) { - for (var i = 0, length = uncountable.length; i < length; i++) { - rules.uncountable[uncountable[i].toLowerCase()] = true; - } - } - - function loadIrregular(rules, irregularPairs) { - var pair; - - for (var i = 0, length = irregularPairs.length; i < length; i++) { - pair = irregularPairs[i]; - - //pluralizing - rules.irregular[pair[0].toLowerCase()] = pair[1]; - rules.irregular[pair[1].toLowerCase()] = pair[1]; - - //singularizing - rules.irregularInverse[pair[1].toLowerCase()] = pair[0]; - rules.irregularInverse[pair[0].toLowerCase()] = pair[0]; - } - } - - /** - Inflector.Ember provides a mechanism for supplying inflection rules for your - application. Ember includes a default set of inflection rules, and provides an - API for providing additional rules. - - Examples: - - Creating an inflector with no rules. - - ```js - var inflector = new Ember.Inflector(); - ``` - - Creating an inflector with the default ember ruleset. - - ```js - var inflector = new Ember.Inflector(Ember.Inflector.defaultRules); - - inflector.pluralize('cow'); //=> 'kine' - inflector.singularize('kine'); //=> 'cow' - ``` - - Creating an inflector and adding rules later. - - ```javascript - var inflector = Ember.Inflector.inflector; - - inflector.pluralize('advice'); // => 'advices' - inflector.uncountable('advice'); - inflector.pluralize('advice'); // => 'advice' - - inflector.pluralize('formula'); // => 'formulas' - inflector.irregular('formula', 'formulae'); - inflector.pluralize('formula'); // => 'formulae' - - // you would not need to add these as they are the default rules - inflector.plural(/$/, 's'); - inflector.singular(/s$/i, ''); - ``` - - Creating an inflector with a nondefault ruleset. - - ```javascript - var rules = { - plurals: [ /$/, 's' ], - singular: [ /\s$/, '' ], - irregularPairs: [ - [ 'cow', 'kine' ] - ], - uncountable: [ 'fish' ] - }; - - var inflector = new Ember.Inflector(rules); - ``` - - @class Inflector - @namespace Ember - */ - function Inflector(ruleSet) { - ruleSet = ruleSet || {}; - ruleSet.uncountable = ruleSet.uncountable || makeDictionary(); - ruleSet.irregularPairs = ruleSet.irregularPairs || makeDictionary(); - - var rules = this.rules = { - plurals: ruleSet.plurals || [], - singular: ruleSet.singular || [], - irregular: makeDictionary(), - irregularInverse: makeDictionary(), - uncountable: makeDictionary() - }; - - loadUncountable(rules, ruleSet.uncountable); - loadIrregular(rules, ruleSet.irregularPairs); - - this.enableCache(); - } - - if (!Object.create && !Object.create(null).hasOwnProperty) { - throw new Error("This browser does not support Object.create(null), please polyfil with es5-sham: http://git.io/yBU2rg"); - } - - function makeDictionary() { - var cache = Object.create(null); - cache['_dict'] = null; - delete cache['_dict']; - return cache; - } - - Inflector.prototype = { - /** - @public - - As inflections can be costly, and commonly the same subset of words are repeatedly - inflected an optional cache is provided. - - @method enableCache - */ - enableCache: function() { - this.purgeCache(); - - this.singularize = function(word) { - this._cacheUsed = true; - return this._sCache[word] || (this._sCache[word] = this._singularize(word)); - }; - - this.pluralize = function(word) { - this._cacheUsed = true; - return this._pCache[word] || (this._pCache[word] = this._pluralize(word)); - }; - }, - - /** - @public - - @method purgedCache - */ - purgeCache: function() { - this._cacheUsed = false; - this._sCache = makeDictionary(); - this._pCache = makeDictionary(); - }, - - /** - @public - disable caching - - @method disableCache; - */ - disableCache: function() { - this._sCache = null; - this._pCache = null; - this.singularize = function(word) { - return this._singularize(word); - }; - - this.pluralize = function(word) { - return this._pluralize(word); - }; - }, - - /** - @method plural - @param {RegExp} regex - @param {String} string - */ - plural: function(regex, string) { - if (this._cacheUsed) { this.purgeCache(); } - this.rules.plurals.push([regex, string.toLowerCase()]); - }, - - /** - @method singular - @param {RegExp} regex - @param {String} string - */ - singular: function(regex, string) { - if (this._cacheUsed) { this.purgeCache(); } - this.rules.singular.push([regex, string.toLowerCase()]); - }, - - /** - @method uncountable - @param {String} regex - */ - uncountable: function(string) { - if (this._cacheUsed) { this.purgeCache(); } - loadUncountable(this.rules, [string.toLowerCase()]); - }, - - /** - @method irregular - @param {String} singular - @param {String} plural - */ - irregular: function (singular, plural) { - if (this._cacheUsed) { this.purgeCache(); } - loadIrregular(this.rules, [[singular, plural]]); - }, - - /** - @method pluralize - @param {String} word - */ - pluralize: function(word) { - return this._pluralize(word); - }, - - _pluralize: function(word) { - return this.inflect(word, this.rules.plurals, this.rules.irregular); - }, - /** - @method singularize - @param {String} word - */ - singularize: function(word) { - return this._singularize(word); - }, - - _singularize: function(word) { - return this.inflect(word, this.rules.singular, this.rules.irregularInverse); - }, - - /** - @protected - - @method inflect - @param {String} word - @param {Object} typeRules - @param {Object} irregular - */ - inflect: function(word, typeRules, irregular) { - var inflection, substitution, result, lowercase, wordSplit, - firstPhrase, lastWord, isBlank, isCamelized, isUncountable, - isIrregular, isIrregularInverse, rule; - - isBlank = BLANK_REGEX.test(word); - isCamelized = CAMELIZED_REGEX.test(word); - firstPhrase = ""; - - if (isBlank) { - return word; - } - - lowercase = word.toLowerCase(); - wordSplit = LAST_WORD_DASHED_REGEX.exec(word) || LAST_WORD_CAMELIZED_REGEX.exec(word); - if (wordSplit){ - firstPhrase = wordSplit[1]; - lastWord = wordSplit[2].toLowerCase(); - } - - isUncountable = this.rules.uncountable[lowercase] || this.rules.uncountable[lastWord]; - - if (isUncountable) { - return word; - } - - isIrregular = irregular && (irregular[lowercase] || irregular[lastWord]); - - if (isIrregular) { - if (irregular[lowercase]){ - return isIrregular; - } - else { - isIrregular = (isCamelized) ? isIrregular.capitalize() : isIrregular; - return firstPhrase + isIrregular; - } - } - - for (var i = typeRules.length, min = 0; i > min; i--) { - inflection = typeRules[i-1]; - rule = inflection[0]; - - if (rule.test(word)) { - break; - } - } - - inflection = inflection || []; - - rule = inflection[0]; - substitution = inflection[1]; - - result = word.replace(rule, substitution); - - return result; - } - }; - - __exports__["default"] = Inflector; - }); -enifed("ember-inflector/system/string", - ["./inflector","exports"], - function(__dependency1__, __exports__) { - "use strict"; - var Inflector = __dependency1__["default"]; - - function pluralize(word) { - return Inflector.inflector.pluralize(word); - } - - function singularize(word) { - return Inflector.inflector.singularize(word); - } - - __exports__.pluralize = pluralize; - __exports__.singularize = singularize; - }); - global.DS = requireModule('ember-data')['default']; - })(this);
\ No newline at end of file |