define("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;

});

define("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){

};

});

define("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;

});

define("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) {

},

/**

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) {

}

});

__exports__["default"] = ActiveModelAdapter;

});

define("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) {

},

/*

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) {

},

// 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) {

},

/**

Convert `snake_cased` links to `camelCase`

@method normalizeLinks

@param {Object} data

*/

normalizeLinks: function(data){

},

/**

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) {

}

});

__exports__["default"] = ActiveModelSerializer;

});

define("ember-data",

["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__, __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 = __dependency1__["default"];

var PromiseArray = __dependency3__.PromiseArray;

var PromiseObject = __dependency3__.PromiseObject;

var Store = __dependency4__.Store;

var Model = __dependency5__.Model;

var Errors = __dependency5__.Errors;

var RootState = __dependency5__.RootState;

var attr = __dependency5__.attr;

var InvalidError = __dependency6__.InvalidError;

var Adapter = __dependency6__.Adapter;

var DebugAdapter = __dependency7__["default"];

var RecordArray = __dependency8__.RecordArray;

var FilteredRecordArray = __dependency8__.FilteredRecordArray;

var AdapterPopulatedRecordArray = __dependency8__.AdapterPopulatedRecordArray;

var ManyArray = __dependency8__.ManyArray;

var RecordArrayManager = __dependency9__["default"];

var RESTAdapter = __dependency10__.RESTAdapter;

var FixtureAdapter = __dependency10__.FixtureAdapter;

var JSONSerializer = __dependency11__["default"];

var RESTSerializer = __dependency12__["default"];

var EmbeddedRecordsMixin = __dependency14__["default"];

var ActiveModelAdapter = __dependency15__.ActiveModelAdapter;

var ActiveModelSerializer = __dependency15__.ActiveModelSerializer;

var Transform = __dependency16__.Transform;

var DateTransform = __dependency16__.DateTransform;

var NumberTransform = __dependency16__.NumberTransform;

var StringTransform = __dependency16__.StringTransform;

var BooleanTransform = __dependency16__.BooleanTransform;

var hasMany = __dependency17__.hasMany;

var belongsTo = __dependency17__.belongsTo;

var setupContainer = __dependency19__["default"];

var ContainerProxy = __dependency20__["default"];

var Relationship = __dependency21__.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;

});

define("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;

});

define("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) {

},

/**

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) {

},

/**

@method updateFixtures

@param {Subclass of DS.Model} type

@param {Array} fixture

*/

updateFixtures: function(type, 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) {

},

/**

@method findMany

@param {DS.Store} store

@param {subclass of DS.Model} type

@param {Array} ids

@return {Promise} promise

*/

findMany: function(store, type, ids) {

},

/**

@private

@method findAll

@param {DS.Store} store

@param {subclass of DS.Model} type

@param {String} sinceToken

@return {Promise} promise

*/

findAll: function(store, type) {

},

/**

@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) {

},

/**

@method createRecord

@param {DS.Store} store

@param {subclass of DS.Model} type

@param {DS.Model} record

@return {Promise} promise

*/

createRecord: function(store, type, 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) {

},

/**

@method deleteRecord

@param {DS.Store} store

@param {subclass of DS.Model} type

@param {DS.Model} record

@return {Promise} promise

*/

deleteRecord: function(store, type, record) {

},

/*

@method deleteLoadedFixture

@private

@param type

@param record

*/

deleteLoadedFixture: function(type, record) {

},

/*

@method findExistingFixture

@private

@param type

@param record

*/

findExistingFixture: function(type, record) {

},

/*

@method findFixtureById

@private

@param fixtures

@param id

*/

findFixtureById: function(fixtures, id) {

},

/*

@method simulateRemoteCall

@private

@param callback

@param context

*/

simulateRemoteCall: function(callback, context) {

}

});

});

define("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"