ember-rails 0.5.0 → 0.6.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/README.md +1 -1
 - data/lib/ember/handlebars/assets/ember-precompiler.js +13 -12
 - data/lib/ember/handlebars/source.rb +8 -2
 - data/lib/ember/handlebars/version.rb +1 -1
 - data/lib/ember/rails/engine.rb +10 -2
 - data/lib/ember/rails/version.rb +1 -1
 - data/lib/ember/version.rb +1 -1
 - data/lib/ember_rails.rb +29 -25
 - data/lib/generators/ember/bootstrap_generator.rb +28 -3
 - data/lib/generators/ember/install_generator.rb +3 -37
 - data/lib/generators/ember/model_generator.rb +8 -8
 - data/lib/generators/ember/resource_override.rb +32 -0
 - data/lib/generators/ember/view_generator.rb +8 -7
 - data/lib/generators/templates/app.js +6 -8
 - data/lib/generators/templates/application.handlebars +3 -0
 - data/lib/generators/templates/array_controller.js +1 -1
 - data/lib/generators/templates/controller.js +1 -1
 - data/lib/generators/templates/router.js +15 -0
 - data/lib/generators/templates/store.js +5 -0
 - data/lib/generators/templates/view.handlebars +3 -1
 - data/lib/generators/templates/view.js +2 -3
 - data/vendor/ember/development/ember-data.js +6 -4
 - data/vendor/ember/development/handlebars-runtime.js +229 -0
 - data/vendor/ember/development/handlebars.js +1895 -0
 - data/vendor/ember/production/ember-data.js +7 -3741
 - data/vendor/ember/production/handlebars-runtime.js +2 -0
 - data/vendor/ember/production/handlebars.js +2 -0
 - metadata +12 -5
 - data/lib/generators/templates/states.js +0 -18
 
| 
         @@ -1,3744 +1,10 @@ 
     | 
|
| 
       1 
     | 
    
         
            -
             
     | 
| 
       2 
     | 
    
         
            -
             
     | 
| 
       3 
     | 
    
         
            -
             
     | 
| 
       4 
     | 
    
         
            -
             
     | 
| 
      
 1 
     | 
    
         
            +
            // ==========================================================================
         
     | 
| 
      
 2 
     | 
    
         
            +
            // Project:  Ember Data
         
     | 
| 
      
 3 
     | 
    
         
            +
            // Copyright: ©2011 Living Social Inc. and contributors.
         
     | 
| 
      
 4 
     | 
    
         
            +
            // License:   Licensed under MIT license (see license.js)
         
     | 
| 
      
 5 
     | 
    
         
            +
            // ==========================================================================
         
     | 
| 
       5 
6 
     | 
    
         | 
| 
       6 
     | 
    
         
            -
            })();
         
     | 
| 
       7 
7 
     | 
    
         | 
| 
       8 
8 
     | 
    
         | 
| 
       9 
     | 
    
         
            -
             
     | 
| 
       10 
     | 
    
         
            -
            (function() {
         
     | 
| 
       11 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set;
         
     | 
| 
       12 
     | 
    
         
            -
             
     | 
| 
       13 
     | 
    
         
            -
            /**
         
     | 
| 
       14 
     | 
    
         
            -
              A record array is an array that contains records of a certain type. The record
         
     | 
| 
       15 
     | 
    
         
            -
              array materializes records as needed when they are retrieved for the first
         
     | 
| 
       16 
     | 
    
         
            -
              time. You should not create record arrays yourself. Instead, an instance of
         
     | 
| 
       17 
     | 
    
         
            -
              DS.RecordArray or its subclasses will be returned by your application's store
         
     | 
| 
       18 
     | 
    
         
            -
              in response to queries.
         
     | 
| 
       19 
     | 
    
         
            -
            */
         
     | 
| 
       20 
     | 
    
         
            -
             
     | 
| 
       21 
     | 
    
         
            -
            DS.RecordArray = Ember.ArrayProxy.extend({
         
     | 
| 
       22 
     | 
    
         
            -
             
     | 
| 
       23 
     | 
    
         
            -
              /**
         
     | 
| 
       24 
     | 
    
         
            -
                The model type contained by this record array.
         
     | 
| 
       25 
     | 
    
         
            -
             
     | 
| 
       26 
     | 
    
         
            -
                @type DS.Model
         
     | 
| 
       27 
     | 
    
         
            -
              */
         
     | 
| 
       28 
     | 
    
         
            -
              type: null,
         
     | 
| 
       29 
     | 
    
         
            -
             
     | 
| 
       30 
     | 
    
         
            -
              // The array of client ids backing the record array. When a
         
     | 
| 
       31 
     | 
    
         
            -
              // record is requested from the record array, the record
         
     | 
| 
       32 
     | 
    
         
            -
              // for the client id at the same index is materialized, if
         
     | 
| 
       33 
     | 
    
         
            -
              // necessary, by the store.
         
     | 
| 
       34 
     | 
    
         
            -
              content: null,
         
     | 
| 
       35 
     | 
    
         
            -
             
     | 
| 
       36 
     | 
    
         
            -
              // The store that created this record array.
         
     | 
| 
       37 
     | 
    
         
            -
              store: null,
         
     | 
| 
       38 
     | 
    
         
            -
             
     | 
| 
       39 
     | 
    
         
            -
              init: function() {
         
     | 
| 
       40 
     | 
    
         
            -
                set(this, 'recordCache', Ember.A([]));
         
     | 
| 
       41 
     | 
    
         
            -
                this._super();
         
     | 
| 
       42 
     | 
    
         
            -
              },
         
     | 
| 
       43 
     | 
    
         
            -
             
     | 
| 
       44 
     | 
    
         
            -
              arrayDidChange: function(array, index, removed, added) {
         
     | 
| 
       45 
     | 
    
         
            -
                var recordCache = get(this, 'recordCache');
         
     | 
| 
       46 
     | 
    
         
            -
                recordCache.replace(index, 0, new Array(added));
         
     | 
| 
       47 
     | 
    
         
            -
             
     | 
| 
       48 
     | 
    
         
            -
                this._super(array, index, removed, added);
         
     | 
| 
       49 
     | 
    
         
            -
              },
         
     | 
| 
       50 
     | 
    
         
            -
             
     | 
| 
       51 
     | 
    
         
            -
              arrayWillChange: function(array, index, removed, added) {
         
     | 
| 
       52 
     | 
    
         
            -
                this._super(array, index, removed, added);
         
     | 
| 
       53 
     | 
    
         
            -
             
     | 
| 
       54 
     | 
    
         
            -
                var recordCache = get(this, 'recordCache');
         
     | 
| 
       55 
     | 
    
         
            -
                recordCache.replace(index, removed);
         
     | 
| 
       56 
     | 
    
         
            -
              },
         
     | 
| 
       57 
     | 
    
         
            -
             
     | 
| 
       58 
     | 
    
         
            -
              objectAtContent: function(index) {
         
     | 
| 
       59 
     | 
    
         
            -
                var recordCache = get(this, 'recordCache');
         
     | 
| 
       60 
     | 
    
         
            -
                var record = recordCache.objectAt(index);
         
     | 
| 
       61 
     | 
    
         
            -
             
     | 
| 
       62 
     | 
    
         
            -
                if (!record) {
         
     | 
| 
       63 
     | 
    
         
            -
                  var store = get(this, 'store');
         
     | 
| 
       64 
     | 
    
         
            -
                  var content = get(this, 'content');
         
     | 
| 
       65 
     | 
    
         
            -
             
     | 
| 
       66 
     | 
    
         
            -
                  var contentObject = content.objectAt(index);
         
     | 
| 
       67 
     | 
    
         
            -
             
     | 
| 
       68 
     | 
    
         
            -
                  if (contentObject !== undefined) {
         
     | 
| 
       69 
     | 
    
         
            -
                    record = store.findByClientId(get(this, 'type'), contentObject);
         
     | 
| 
       70 
     | 
    
         
            -
                    recordCache.replace(index, 1, [record]);
         
     | 
| 
       71 
     | 
    
         
            -
                  }
         
     | 
| 
       72 
     | 
    
         
            -
                }
         
     | 
| 
       73 
     | 
    
         
            -
             
     | 
| 
       74 
     | 
    
         
            -
                return record;
         
     | 
| 
       75 
     | 
    
         
            -
              }
         
     | 
| 
       76 
     | 
    
         
            -
            });
         
     | 
| 
       77 
     | 
    
         
            -
             
     | 
| 
       78 
     | 
    
         
            -
            })();
         
     | 
| 
       79 
     | 
    
         
            -
             
     | 
| 
       80 
     | 
    
         
            -
             
     | 
| 
       81 
     | 
    
         
            -
             
     | 
| 
       82 
     | 
    
         
            -
            (function() {
         
     | 
| 
       83 
     | 
    
         
            -
            var get = Ember.get;
         
     | 
| 
       84 
     | 
    
         
            -
             
     | 
| 
       85 
     | 
    
         
            -
            DS.FilteredRecordArray = DS.RecordArray.extend({
         
     | 
| 
       86 
     | 
    
         
            -
              filterFunction: null,
         
     | 
| 
       87 
     | 
    
         
            -
             
     | 
| 
       88 
     | 
    
         
            -
              replace: function() {
         
     | 
| 
       89 
     | 
    
         
            -
                var type = get(this, 'type').toString();
         
     | 
| 
       90 
     | 
    
         
            -
                throw new Error("The result of a client-side filter (on " + type + ") is immutable.");
         
     | 
| 
       91 
     | 
    
         
            -
              },
         
     | 
| 
       92 
     | 
    
         
            -
             
     | 
| 
       93 
     | 
    
         
            -
              updateFilter: Ember.observer(function() {
         
     | 
| 
       94 
     | 
    
         
            -
                var store = get(this, 'store');
         
     | 
| 
       95 
     | 
    
         
            -
                store.updateRecordArrayFilter(this, get(this, 'type'), get(this, 'filterFunction'));
         
     | 
| 
       96 
     | 
    
         
            -
              }, 'filterFunction')
         
     | 
| 
       97 
     | 
    
         
            -
            });
         
     | 
| 
       98 
     | 
    
         
            -
             
     | 
| 
       99 
     | 
    
         
            -
            })();
         
     | 
| 
       100 
     | 
    
         
            -
             
     | 
| 
       101 
     | 
    
         
            -
             
     | 
| 
       102 
     | 
    
         
            -
             
     | 
| 
       103 
     | 
    
         
            -
            (function() {
         
     | 
| 
       104 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set;
         
     | 
| 
       105 
     | 
    
         
            -
             
     | 
| 
       106 
     | 
    
         
            -
            DS.AdapterPopulatedRecordArray = DS.RecordArray.extend({
         
     | 
| 
       107 
     | 
    
         
            -
              query: null,
         
     | 
| 
       108 
     | 
    
         
            -
              isLoaded: false,
         
     | 
| 
       109 
     | 
    
         
            -
             
     | 
| 
       110 
     | 
    
         
            -
              replace: function() {
         
     | 
| 
       111 
     | 
    
         
            -
                var type = get(this, 'type').toString();
         
     | 
| 
       112 
     | 
    
         
            -
                throw new Error("The result of a server query (on " + type + ") is immutable.");
         
     | 
| 
       113 
     | 
    
         
            -
              },
         
     | 
| 
       114 
     | 
    
         
            -
             
     | 
| 
       115 
     | 
    
         
            -
              load: function(array) {
         
     | 
| 
       116 
     | 
    
         
            -
                var store = get(this, 'store'), type = get(this, 'type');
         
     | 
| 
       117 
     | 
    
         
            -
             
     | 
| 
       118 
     | 
    
         
            -
                var clientIds = store.loadMany(type, array).clientIds;
         
     | 
| 
       119 
     | 
    
         
            -
             
     | 
| 
       120 
     | 
    
         
            -
                this.beginPropertyChanges();
         
     | 
| 
       121 
     | 
    
         
            -
                set(this, 'content', Ember.A(clientIds));
         
     | 
| 
       122 
     | 
    
         
            -
                set(this, 'isLoaded', true);
         
     | 
| 
       123 
     | 
    
         
            -
                this.endPropertyChanges();
         
     | 
| 
       124 
     | 
    
         
            -
              }
         
     | 
| 
       125 
     | 
    
         
            -
            });
         
     | 
| 
       126 
     | 
    
         
            -
             
     | 
| 
       127 
     | 
    
         
            -
             
     | 
| 
       128 
     | 
    
         
            -
            })();
         
     | 
| 
       129 
     | 
    
         
            -
             
     | 
| 
       130 
     | 
    
         
            -
             
     | 
| 
       131 
     | 
    
         
            -
             
     | 
| 
       132 
     | 
    
         
            -
            (function() {
         
     | 
| 
       133 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor;
         
     | 
| 
       134 
     | 
    
         
            -
             
     | 
| 
       135 
     | 
    
         
            -
            var Set = function() {
         
     | 
| 
       136 
     | 
    
         
            -
              this.hash = {};
         
     | 
| 
       137 
     | 
    
         
            -
              this.list = [];
         
     | 
| 
       138 
     | 
    
         
            -
            };
         
     | 
| 
       139 
     | 
    
         
            -
             
     | 
| 
       140 
     | 
    
         
            -
            Set.prototype = {
         
     | 
| 
       141 
     | 
    
         
            -
              add: function(item) {
         
     | 
| 
       142 
     | 
    
         
            -
                var hash = this.hash,
         
     | 
| 
       143 
     | 
    
         
            -
                    guid = guidFor(item);
         
     | 
| 
       144 
     | 
    
         
            -
             
     | 
| 
       145 
     | 
    
         
            -
                if (hash.hasOwnProperty(guid)) { return; }
         
     | 
| 
       146 
     | 
    
         
            -
             
     | 
| 
       147 
     | 
    
         
            -
                hash[guid] = true;
         
     | 
| 
       148 
     | 
    
         
            -
                this.list.push(item);
         
     | 
| 
       149 
     | 
    
         
            -
              },
         
     | 
| 
       150 
     | 
    
         
            -
             
     | 
| 
       151 
     | 
    
         
            -
              remove: function(item) {
         
     | 
| 
       152 
     | 
    
         
            -
                var hash = this.hash,
         
     | 
| 
       153 
     | 
    
         
            -
                    guid = guidFor(item);
         
     | 
| 
       154 
     | 
    
         
            -
             
     | 
| 
       155 
     | 
    
         
            -
                if (!hash.hasOwnProperty(guid)) { return; }
         
     | 
| 
       156 
     | 
    
         
            -
             
     | 
| 
       157 
     | 
    
         
            -
                delete hash[guid];
         
     | 
| 
       158 
     | 
    
         
            -
                var list = this.list,
         
     | 
| 
       159 
     | 
    
         
            -
                    index = Ember.ArrayUtils.indexOf(this, item);
         
     | 
| 
       160 
     | 
    
         
            -
             
     | 
| 
       161 
     | 
    
         
            -
                list.splice(index, 1);
         
     | 
| 
       162 
     | 
    
         
            -
              },
         
     | 
| 
       163 
     | 
    
         
            -
             
     | 
| 
       164 
     | 
    
         
            -
              isEmpty: function() {
         
     | 
| 
       165 
     | 
    
         
            -
                return this.list.length === 0;
         
     | 
| 
       166 
     | 
    
         
            -
              }
         
     | 
| 
       167 
     | 
    
         
            -
            };
         
     | 
| 
       168 
     | 
    
         
            -
             
     | 
| 
       169 
     | 
    
         
            -
            var ManyArrayState = Ember.State.extend({
         
     | 
| 
       170 
     | 
    
         
            -
              recordWasAdded: function(manager, record) {
         
     | 
| 
       171 
     | 
    
         
            -
                var dirty = manager.dirty, observer;
         
     | 
| 
       172 
     | 
    
         
            -
                dirty.add(record);
         
     | 
| 
       173 
     | 
    
         
            -
             
     | 
| 
       174 
     | 
    
         
            -
                observer = function() {
         
     | 
| 
       175 
     | 
    
         
            -
                  if (!get(record, 'isDirty')) {
         
     | 
| 
       176 
     | 
    
         
            -
                    record.removeObserver('isDirty', observer);
         
     | 
| 
       177 
     | 
    
         
            -
                    manager.send('childWasSaved', record);
         
     | 
| 
       178 
     | 
    
         
            -
                  }
         
     | 
| 
       179 
     | 
    
         
            -
                };
         
     | 
| 
       180 
     | 
    
         
            -
             
     | 
| 
       181 
     | 
    
         
            -
                record.addObserver('isDirty', observer);
         
     | 
| 
       182 
     | 
    
         
            -
              },
         
     | 
| 
       183 
     | 
    
         
            -
             
     | 
| 
       184 
     | 
    
         
            -
              recordWasRemoved: function(manager, record) {
         
     | 
| 
       185 
     | 
    
         
            -
                var dirty = manager.dirty, observer;
         
     | 
| 
       186 
     | 
    
         
            -
                dirty.add(record);
         
     | 
| 
       187 
     | 
    
         
            -
             
     | 
| 
       188 
     | 
    
         
            -
                observer = function() {
         
     | 
| 
       189 
     | 
    
         
            -
                  record.removeObserver('isDirty', observer);
         
     | 
| 
       190 
     | 
    
         
            -
                  if (!get(record, 'isDirty')) { manager.send('childWasSaved', record); }
         
     | 
| 
       191 
     | 
    
         
            -
                };
         
     | 
| 
       192 
     | 
    
         
            -
             
     | 
| 
       193 
     | 
    
         
            -
                record.addObserver('isDirty', observer);
         
     | 
| 
       194 
     | 
    
         
            -
              }
         
     | 
| 
       195 
     | 
    
         
            -
            });
         
     | 
| 
       196 
     | 
    
         
            -
             
     | 
| 
       197 
     | 
    
         
            -
            var states = {
         
     | 
| 
       198 
     | 
    
         
            -
              clean: ManyArrayState.create({
         
     | 
| 
       199 
     | 
    
         
            -
                isDirty: false,
         
     | 
| 
       200 
     | 
    
         
            -
             
     | 
| 
       201 
     | 
    
         
            -
                recordWasAdded: function(manager, record) {
         
     | 
| 
       202 
     | 
    
         
            -
                  this._super(manager, record);
         
     | 
| 
       203 
     | 
    
         
            -
                  manager.goToState('dirty');
         
     | 
| 
       204 
     | 
    
         
            -
                },
         
     | 
| 
       205 
     | 
    
         
            -
             
     | 
| 
       206 
     | 
    
         
            -
                update: function(manager, clientIds) {
         
     | 
| 
       207 
     | 
    
         
            -
                  var manyArray = manager.manyArray;
         
     | 
| 
       208 
     | 
    
         
            -
                  set(manyArray, 'content', clientIds);
         
     | 
| 
       209 
     | 
    
         
            -
                }
         
     | 
| 
       210 
     | 
    
         
            -
              }),
         
     | 
| 
       211 
     | 
    
         
            -
             
     | 
| 
       212 
     | 
    
         
            -
              dirty: ManyArrayState.create({
         
     | 
| 
       213 
     | 
    
         
            -
                isDirty: true,
         
     | 
| 
       214 
     | 
    
         
            -
             
     | 
| 
       215 
     | 
    
         
            -
                childWasSaved: function(manager, child) {
         
     | 
| 
       216 
     | 
    
         
            -
                  var dirty = manager.dirty;
         
     | 
| 
       217 
     | 
    
         
            -
                  dirty.remove(child);
         
     | 
| 
       218 
     | 
    
         
            -
             
     | 
| 
       219 
     | 
    
         
            -
                  if (dirty.isEmpty()) { manager.send('arrayBecameSaved'); }
         
     | 
| 
       220 
     | 
    
         
            -
                },
         
     | 
| 
       221 
     | 
    
         
            -
             
     | 
| 
       222 
     | 
    
         
            -
                arrayBecameSaved: function(manager) {
         
     | 
| 
       223 
     | 
    
         
            -
                  manager.goToState('clean');
         
     | 
| 
       224 
     | 
    
         
            -
                }
         
     | 
| 
       225 
     | 
    
         
            -
              }) 
         
     | 
| 
       226 
     | 
    
         
            -
            };
         
     | 
| 
       227 
     | 
    
         
            -
             
     | 
| 
       228 
     | 
    
         
            -
            DS.ManyArrayStateManager = Ember.StateManager.extend({
         
     | 
| 
       229 
     | 
    
         
            -
              manyArray: null,
         
     | 
| 
       230 
     | 
    
         
            -
              initialState: 'clean',
         
     | 
| 
       231 
     | 
    
         
            -
              states: states,
         
     | 
| 
       232 
     | 
    
         
            -
             
     | 
| 
       233 
     | 
    
         
            -
              init: function() {
         
     | 
| 
       234 
     | 
    
         
            -
                this._super();
         
     | 
| 
       235 
     | 
    
         
            -
                this.dirty = new Set();
         
     | 
| 
       236 
     | 
    
         
            -
              }
         
     | 
| 
       237 
     | 
    
         
            -
            });
         
     | 
| 
       238 
     | 
    
         
            -
             
     | 
| 
       239 
     | 
    
         
            -
            })();
         
     | 
| 
       240 
     | 
    
         
            -
             
     | 
| 
       241 
     | 
    
         
            -
             
     | 
| 
       242 
     | 
    
         
            -
             
     | 
| 
       243 
     | 
    
         
            -
            (function() {
         
     | 
| 
       244 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
         
     | 
| 
       245 
     | 
    
         
            -
             
     | 
| 
       246 
     | 
    
         
            -
            DS.ManyArray = DS.RecordArray.extend({
         
     | 
| 
       247 
     | 
    
         
            -
              init: function() {
         
     | 
| 
       248 
     | 
    
         
            -
                set(this, 'stateManager', DS.ManyArrayStateManager.create({ manyArray: this }));
         
     | 
| 
       249 
     | 
    
         
            -
             
     | 
| 
       250 
     | 
    
         
            -
                return this._super();
         
     | 
| 
       251 
     | 
    
         
            -
              },
         
     | 
| 
       252 
     | 
    
         
            -
             
     | 
| 
       253 
     | 
    
         
            -
              parentRecord: null,
         
     | 
| 
       254 
     | 
    
         
            -
             
     | 
| 
       255 
     | 
    
         
            -
              isDirty: Ember.computed(function() {
         
     | 
| 
       256 
     | 
    
         
            -
                return getPath(this, 'stateManager.currentState.isDirty');
         
     | 
| 
       257 
     | 
    
         
            -
              }).property('stateManager.currentState').cacheable(),
         
     | 
| 
       258 
     | 
    
         
            -
             
     | 
| 
       259 
     | 
    
         
            -
              fetch: function() {
         
     | 
| 
       260 
     | 
    
         
            -
                var clientIds = get(this, 'content'),
         
     | 
| 
       261 
     | 
    
         
            -
                    store = get(this, 'store'),
         
     | 
| 
       262 
     | 
    
         
            -
                    type = get(this, 'type');
         
     | 
| 
       263 
     | 
    
         
            -
             
     | 
| 
       264 
     | 
    
         
            -
                var ids = clientIds.map(function(clientId) {
         
     | 
| 
       265 
     | 
    
         
            -
                  return store.clientIdToId[clientId];
         
     | 
| 
       266 
     | 
    
         
            -
                });
         
     | 
| 
       267 
     | 
    
         
            -
             
     | 
| 
       268 
     | 
    
         
            -
                store.fetchMany(type, ids);
         
     | 
| 
       269 
     | 
    
         
            -
              },
         
     | 
| 
       270 
     | 
    
         
            -
             
     | 
| 
       271 
     | 
    
         
            -
              // Overrides Ember.Array's replace method to implement
         
     | 
| 
       272 
     | 
    
         
            -
              replace: function(index, removed, added) {
         
     | 
| 
       273 
     | 
    
         
            -
                var parentRecord = get(this, 'parentRecord');
         
     | 
| 
       274 
     | 
    
         
            -
                var pendingParent = parentRecord && !get(parentRecord, 'id');
         
     | 
| 
       275 
     | 
    
         
            -
                var stateManager = get(this, 'stateManager');
         
     | 
| 
       276 
     | 
    
         
            -
             
     | 
| 
       277 
     | 
    
         
            -
                // Map the array of record objects into an array of  client ids.
         
     | 
| 
       278 
     | 
    
         
            -
                added = added.map(function(record) {
         
     | 
| 
       279 
     | 
    
         
            -
             
     | 
| 
       280 
     | 
    
         
            -
             
     | 
| 
       281 
     | 
    
         
            -
                  // If the record to which this many array belongs does not yet
         
     | 
| 
       282 
     | 
    
         
            -
                  // have an id, notify the newly-added record that it must wait
         
     | 
| 
       283 
     | 
    
         
            -
                  // for the parent to receive an id before the child can be
         
     | 
| 
       284 
     | 
    
         
            -
                  // saved.
         
     | 
| 
       285 
     | 
    
         
            -
                  if (pendingParent) {
         
     | 
| 
       286 
     | 
    
         
            -
                    record.send('waitingOn', parentRecord);
         
     | 
| 
       287 
     | 
    
         
            -
                  }
         
     | 
| 
       288 
     | 
    
         
            -
             
     | 
| 
       289 
     | 
    
         
            -
                  this.assignInverse(record, parentRecord);
         
     | 
| 
       290 
     | 
    
         
            -
             
     | 
| 
       291 
     | 
    
         
            -
                  stateManager.send('recordWasAdded', record);
         
     | 
| 
       292 
     | 
    
         
            -
             
     | 
| 
       293 
     | 
    
         
            -
                  return record.get('clientId');
         
     | 
| 
       294 
     | 
    
         
            -
                }, this);
         
     | 
| 
       295 
     | 
    
         
            -
             
     | 
| 
       296 
     | 
    
         
            -
                var store = this.store;
         
     | 
| 
       297 
     | 
    
         
            -
             
     | 
| 
       298 
     | 
    
         
            -
                var len = index+removed, record;
         
     | 
| 
       299 
     | 
    
         
            -
                for (var i = index; i < len; i++) {
         
     | 
| 
       300 
     | 
    
         
            -
                  // TODO: null out inverse FK
         
     | 
| 
       301 
     | 
    
         
            -
                  record = this.objectAt(i);
         
     | 
| 
       302 
     | 
    
         
            -
                  this.assignInverse(record, parentRecord, true);
         
     | 
| 
       303 
     | 
    
         
            -
             
     | 
| 
       304 
     | 
    
         
            -
                  // If we put the child record into a pending state because
         
     | 
| 
       305 
     | 
    
         
            -
                  // we were waiting on the parent record to get an id, we
         
     | 
| 
       306 
     | 
    
         
            -
                  // can tell the child it no longer needs to wait.
         
     | 
| 
       307 
     | 
    
         
            -
                  if (pendingParent) {
         
     | 
| 
       308 
     | 
    
         
            -
                    record.send('doneWaitingOn', parentRecord);
         
     | 
| 
       309 
     | 
    
         
            -
                  }
         
     | 
| 
       310 
     | 
    
         
            -
             
     | 
| 
       311 
     | 
    
         
            -
                  stateManager.send('recordWasAdded', record);
         
     | 
| 
       312 
     | 
    
         
            -
                }
         
     | 
| 
       313 
     | 
    
         
            -
             
     | 
| 
       314 
     | 
    
         
            -
                this._super(index, removed, added);
         
     | 
| 
       315 
     | 
    
         
            -
              },
         
     | 
| 
       316 
     | 
    
         
            -
             
     | 
| 
       317 
     | 
    
         
            -
              assignInverse: function(record, parentRecord, remove) {
         
     | 
| 
       318 
     | 
    
         
            -
                var associationMap = get(record.constructor, 'associations'),
         
     | 
| 
       319 
     | 
    
         
            -
                    possibleAssociations = associationMap.get(parentRecord.constructor),
         
     | 
| 
       320 
     | 
    
         
            -
                    possible, actual;
         
     | 
| 
       321 
     | 
    
         
            -
             
     | 
| 
       322 
     | 
    
         
            -
                if (!possibleAssociations) { return; }
         
     | 
| 
       323 
     | 
    
         
            -
             
     | 
| 
       324 
     | 
    
         
            -
                for (var i = 0, l = possibleAssociations.length; i < l; i++) {
         
     | 
| 
       325 
     | 
    
         
            -
                  possible = possibleAssociations[i];
         
     | 
| 
       326 
     | 
    
         
            -
             
     | 
| 
       327 
     | 
    
         
            -
                  if (possible.kind === 'belongsTo') {
         
     | 
| 
       328 
     | 
    
         
            -
                    actual = possible;
         
     | 
| 
       329 
     | 
    
         
            -
                    break;
         
     | 
| 
       330 
     | 
    
         
            -
                  }
         
     | 
| 
       331 
     | 
    
         
            -
                }
         
     | 
| 
       332 
     | 
    
         
            -
             
     | 
| 
       333 
     | 
    
         
            -
                if (actual) {
         
     | 
| 
       334 
     | 
    
         
            -
                  set(record, actual.name, remove ? null : parentRecord);
         
     | 
| 
       335 
     | 
    
         
            -
                }
         
     | 
| 
       336 
     | 
    
         
            -
              },
         
     | 
| 
       337 
     | 
    
         
            -
             
     | 
| 
       338 
     | 
    
         
            -
              // Create a child record within the parentRecord
         
     | 
| 
       339 
     | 
    
         
            -
              createRecord: function(hash, transaction) {
         
     | 
| 
       340 
     | 
    
         
            -
                var parentRecord = get(this, 'parentRecord'),
         
     | 
| 
       341 
     | 
    
         
            -
                    store = get(parentRecord, 'store'),
         
     | 
| 
       342 
     | 
    
         
            -
                    type = get(this, 'type'),
         
     | 
| 
       343 
     | 
    
         
            -
                    record;
         
     | 
| 
       344 
     | 
    
         
            -
             
     | 
| 
       345 
     | 
    
         
            -
                transaction = transaction || get(parentRecord, 'transaction');
         
     | 
| 
       346 
     | 
    
         
            -
             
     | 
| 
       347 
     | 
    
         
            -
                record = store.createRecord.call(store, type, hash, transaction);
         
     | 
| 
       348 
     | 
    
         
            -
                this.pushObject(record);
         
     | 
| 
       349 
     | 
    
         
            -
             
     | 
| 
       350 
     | 
    
         
            -
                return record;
         
     | 
| 
       351 
     | 
    
         
            -
              }
         
     | 
| 
       352 
     | 
    
         
            -
            });
         
     | 
| 
       353 
     | 
    
         
            -
             
     | 
| 
       354 
     | 
    
         
            -
            })();
         
     | 
| 
       355 
     | 
    
         
            -
             
     | 
| 
       356 
     | 
    
         
            -
             
     | 
| 
       357 
     | 
    
         
            -
             
     | 
| 
       358 
     | 
    
         
            -
            (function() {
         
     | 
| 
       359 
     | 
    
         
            -
             
     | 
| 
       360 
     | 
    
         
            -
            })();
         
     | 
| 
       361 
     | 
    
         
            -
             
     | 
| 
       362 
     | 
    
         
            -
             
     | 
| 
       363 
     | 
    
         
            -
             
     | 
| 
       364 
     | 
    
         
            -
            (function() {
         
     | 
| 
       365 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set, getPath = Ember.getPath, fmt = Ember.String.fmt;
         
     | 
| 
       366 
     | 
    
         
            -
             
     | 
| 
       367 
     | 
    
         
            -
            /**
         
     | 
| 
       368 
     | 
    
         
            -
              A transaction allows you to collect multiple records into a unit of work
         
     | 
| 
       369 
     | 
    
         
            -
              that can be committed or rolled back as a group.
         
     | 
| 
       370 
     | 
    
         
            -
             
     | 
| 
       371 
     | 
    
         
            -
              For example, if a record has local modifications that have not yet
         
     | 
| 
       372 
     | 
    
         
            -
              been saved, calling `commit()` on its transaction will cause those
         
     | 
| 
       373 
     | 
    
         
            -
              modifications to be sent to the adapter to be saved. Calling
         
     | 
| 
       374 
     | 
    
         
            -
              `rollback()` on its transaction would cause all of the modifications to
         
     | 
| 
       375 
     | 
    
         
            -
              be discarded and the record to return to the last known state before
         
     | 
| 
       376 
     | 
    
         
            -
              changes were made.
         
     | 
| 
       377 
     | 
    
         
            -
             
     | 
| 
       378 
     | 
    
         
            -
              If a newly created record's transaction is rolled back, it will
         
     | 
| 
       379 
     | 
    
         
            -
              immediately transition to the deleted state.
         
     | 
| 
       380 
     | 
    
         
            -
             
     | 
| 
       381 
     | 
    
         
            -
              If you do not explicitly create a transaction, a record is assigned to
         
     | 
| 
       382 
     | 
    
         
            -
              an implicit transaction called the default transaction. In these cases,
         
     | 
| 
       383 
     | 
    
         
            -
              you can treat your application's instance of `DS.Store` as a transaction
         
     | 
| 
       384 
     | 
    
         
            -
              and call the `commit()` and `rollback()` methods on the store itself. 
         
     | 
| 
       385 
     | 
    
         
            -
             
     | 
| 
       386 
     | 
    
         
            -
              Once a record has been successfully committed or rolled back, it will
         
     | 
| 
       387 
     | 
    
         
            -
              be moved back to the implicit transaction. Because it will now be in
         
     | 
| 
       388 
     | 
    
         
            -
              a clean state, it can be moved to a new transaction if you wish.
         
     | 
| 
       389 
     | 
    
         
            -
             
     | 
| 
       390 
     | 
    
         
            -
              ### Creating a Transaction
         
     | 
| 
       391 
     | 
    
         
            -
             
     | 
| 
       392 
     | 
    
         
            -
              To create a new transaction, call the `transaction()` method of your
         
     | 
| 
       393 
     | 
    
         
            -
              application's `DS.Store` instance:
         
     | 
| 
       394 
     | 
    
         
            -
             
     | 
| 
       395 
     | 
    
         
            -
                  var transaction = App.store.transaction();
         
     | 
| 
       396 
     | 
    
         
            -
             
     | 
| 
       397 
     | 
    
         
            -
              This will return a new instance of `DS.Transaction` with no records
         
     | 
| 
       398 
     | 
    
         
            -
              yet assigned to it.
         
     | 
| 
       399 
     | 
    
         
            -
             
     | 
| 
       400 
     | 
    
         
            -
              ### Adding Existing Records
         
     | 
| 
       401 
     | 
    
         
            -
             
     | 
| 
       402 
     | 
    
         
            -
              Add records to a transaction using the `add()` method:
         
     | 
| 
       403 
     | 
    
         
            -
             
     | 
| 
       404 
     | 
    
         
            -
                  record = App.store.find(Person, 1);
         
     | 
| 
       405 
     | 
    
         
            -
                  transaction.add(record);
         
     | 
| 
       406 
     | 
    
         
            -
             
     | 
| 
       407 
     | 
    
         
            -
              Note that only records whose `isDirty` flag is `false` may be added
         
     | 
| 
       408 
     | 
    
         
            -
              to a transaction. Once modifications to a record have been made
         
     | 
| 
       409 
     | 
    
         
            -
              (its `isDirty` flag is `true`), it is not longer able to be added to
         
     | 
| 
       410 
     | 
    
         
            -
              a transaction.
         
     | 
| 
       411 
     | 
    
         
            -
             
     | 
| 
       412 
     | 
    
         
            -
              ### Creating New Records
         
     | 
| 
       413 
     | 
    
         
            -
             
     | 
| 
       414 
     | 
    
         
            -
              Because newly created records are dirty from the time they are created,
         
     | 
| 
       415 
     | 
    
         
            -
              and because dirty records can not be added to a transaction, you must
         
     | 
| 
       416 
     | 
    
         
            -
              use the `createRecord()` method to assign new records to a transaction.
         
     | 
| 
       417 
     | 
    
         
            -
             
     | 
| 
       418 
     | 
    
         
            -
              For example, instead of this:
         
     | 
| 
       419 
     | 
    
         
            -
             
     | 
| 
       420 
     | 
    
         
            -
                var transaction = store.transaction();
         
     | 
| 
       421 
     | 
    
         
            -
                var person = Person.createRecord({ name: "Steve" });
         
     | 
| 
       422 
     | 
    
         
            -
             
     | 
| 
       423 
     | 
    
         
            -
                // won't work because person is dirty
         
     | 
| 
       424 
     | 
    
         
            -
                transaction.add(person);
         
     | 
| 
       425 
     | 
    
         
            -
             
     | 
| 
       426 
     | 
    
         
            -
              Call `createRecord()` on the transaction directly:
         
     | 
| 
       427 
     | 
    
         
            -
             
     | 
| 
       428 
     | 
    
         
            -
                var transaction = store.transaction();
         
     | 
| 
       429 
     | 
    
         
            -
                transaction.createRecord(Person, { name: "Steve" });
         
     | 
| 
       430 
     | 
    
         
            -
             
     | 
| 
       431 
     | 
    
         
            -
              ### Asynchronous Commits
         
     | 
| 
       432 
     | 
    
         
            -
             
     | 
| 
       433 
     | 
    
         
            -
              Typically, all of the records in a transaction will be committed
         
     | 
| 
       434 
     | 
    
         
            -
              together. However, new records that have a dependency on other new
         
     | 
| 
       435 
     | 
    
         
            -
              records need to wait for their parent record to be saved and assigned an
         
     | 
| 
       436 
     | 
    
         
            -
              ID. In that case, the child record will continue to live in the
         
     | 
| 
       437 
     | 
    
         
            -
              transaction until its parent is saved, at which time the transaction will
         
     | 
| 
       438 
     | 
    
         
            -
              attempt to commit again.
         
     | 
| 
       439 
     | 
    
         
            -
             
     | 
| 
       440 
     | 
    
         
            -
              For this reason, you should not re-use transactions once you have committed
         
     | 
| 
       441 
     | 
    
         
            -
              them. Always make a new transaction and move the desired records to it before
         
     | 
| 
       442 
     | 
    
         
            -
              calling commit.
         
     | 
| 
       443 
     | 
    
         
            -
            */
         
     | 
| 
       444 
     | 
    
         
            -
             
     | 
| 
       445 
     | 
    
         
            -
            DS.Transaction = Ember.Object.extend({
         
     | 
| 
       446 
     | 
    
         
            -
              /**
         
     | 
| 
       447 
     | 
    
         
            -
                @private
         
     | 
| 
       448 
     | 
    
         
            -
             
     | 
| 
       449 
     | 
    
         
            -
                Creates the bucket data structure used to segregate records by
         
     | 
| 
       450 
     | 
    
         
            -
                type.
         
     | 
| 
       451 
     | 
    
         
            -
              */
         
     | 
| 
       452 
     | 
    
         
            -
              init: function() {
         
     | 
| 
       453 
     | 
    
         
            -
                set(this, 'buckets', {
         
     | 
| 
       454 
     | 
    
         
            -
                  clean:    Ember.Map.create(),
         
     | 
| 
       455 
     | 
    
         
            -
                  created:  Ember.Map.create(),
         
     | 
| 
       456 
     | 
    
         
            -
                  updated:  Ember.Map.create(),
         
     | 
| 
       457 
     | 
    
         
            -
                  deleted:  Ember.Map.create(),
         
     | 
| 
       458 
     | 
    
         
            -
                  inflight: Ember.Map.create()
         
     | 
| 
       459 
     | 
    
         
            -
                });
         
     | 
| 
       460 
     | 
    
         
            -
              },
         
     | 
| 
       461 
     | 
    
         
            -
             
     | 
| 
       462 
     | 
    
         
            -
              /**
         
     | 
| 
       463 
     | 
    
         
            -
                Creates a new record of the given type and assigns it to the transaction
         
     | 
| 
       464 
     | 
    
         
            -
                on which the method was called.
         
     | 
| 
       465 
     | 
    
         
            -
             
     | 
| 
       466 
     | 
    
         
            -
                This is useful as only clean records can be added to a transaction and
         
     | 
| 
       467 
     | 
    
         
            -
                new records created using other methods immediately become dirty.
         
     | 
| 
       468 
     | 
    
         
            -
             
     | 
| 
       469 
     | 
    
         
            -
                @param {DS.Model} type the model type to create
         
     | 
| 
       470 
     | 
    
         
            -
                @param {Object} hash the data hash to assign the new record
         
     | 
| 
       471 
     | 
    
         
            -
              */
         
     | 
| 
       472 
     | 
    
         
            -
              createRecord: function(type, hash) {
         
     | 
| 
       473 
     | 
    
         
            -
                var store = get(this, 'store');
         
     | 
| 
       474 
     | 
    
         
            -
             
     | 
| 
       475 
     | 
    
         
            -
                return store.createRecord(type, hash, this);
         
     | 
| 
       476 
     | 
    
         
            -
              },
         
     | 
| 
       477 
     | 
    
         
            -
             
     | 
| 
       478 
     | 
    
         
            -
              /**
         
     | 
| 
       479 
     | 
    
         
            -
                Adds an existing record to this transaction. Only records without
         
     | 
| 
       480 
     | 
    
         
            -
                modficiations (i.e., records whose `isDirty` property is `false`)
         
     | 
| 
       481 
     | 
    
         
            -
                can be added to a transaction.
         
     | 
| 
       482 
     | 
    
         
            -
             
     | 
| 
       483 
     | 
    
         
            -
                @param {DS.Model} record the record to add to the transaction
         
     | 
| 
       484 
     | 
    
         
            -
              */
         
     | 
| 
       485 
     | 
    
         
            -
              add: function(record) {
         
     | 
| 
       486 
     | 
    
         
            -
                // we could probably make this work if someone has a valid use case. Do you?
         
     | 
| 
       487 
     | 
    
         
            -
             
     | 
| 
       488 
     | 
    
         
            -
             
     | 
| 
       489 
     | 
    
         
            -
                var recordTransaction = get(record, 'transaction'),
         
     | 
| 
       490 
     | 
    
         
            -
                    defaultTransaction = getPath(this, 'store.defaultTransaction');
         
     | 
| 
       491 
     | 
    
         
            -
             
     | 
| 
       492 
     | 
    
         
            -
             
     | 
| 
       493 
     | 
    
         
            -
                this.adoptRecord(record);
         
     | 
| 
       494 
     | 
    
         
            -
              },
         
     | 
| 
       495 
     | 
    
         
            -
             
     | 
| 
       496 
     | 
    
         
            -
              /**
         
     | 
| 
       497 
     | 
    
         
            -
                Commits the transaction, which causes all of the modified records that
         
     | 
| 
       498 
     | 
    
         
            -
                belong to the transaction to be sent to the adapter to be saved.
         
     | 
| 
       499 
     | 
    
         
            -
             
     | 
| 
       500 
     | 
    
         
            -
                Once you call `commit()` on a transaction, you should not re-use it.
         
     | 
| 
       501 
     | 
    
         
            -
             
     | 
| 
       502 
     | 
    
         
            -
                When a record is saved, it will be removed from this transaction and
         
     | 
| 
       503 
     | 
    
         
            -
                moved back to the store's default transaction.
         
     | 
| 
       504 
     | 
    
         
            -
              */
         
     | 
| 
       505 
     | 
    
         
            -
              commit: function() {
         
     | 
| 
       506 
     | 
    
         
            -
                var self = this,
         
     | 
| 
       507 
     | 
    
         
            -
                    iterate;
         
     | 
| 
       508 
     | 
    
         
            -
             
     | 
| 
       509 
     | 
    
         
            -
                iterate = function(bucketType, fn, binding) {
         
     | 
| 
       510 
     | 
    
         
            -
                  var dirty = self.bucketForType(bucketType);
         
     | 
| 
       511 
     | 
    
         
            -
             
     | 
| 
       512 
     | 
    
         
            -
                  dirty.forEach(function(type, records) {
         
     | 
| 
       513 
     | 
    
         
            -
                    if (records.isEmpty()) { return; }
         
     | 
| 
       514 
     | 
    
         
            -
             
     | 
| 
       515 
     | 
    
         
            -
                    var array = [];
         
     | 
| 
       516 
     | 
    
         
            -
             
     | 
| 
       517 
     | 
    
         
            -
                    records.forEach(function(record) {
         
     | 
| 
       518 
     | 
    
         
            -
                      record.send('willCommit');
         
     | 
| 
       519 
     | 
    
         
            -
             
     | 
| 
       520 
     | 
    
         
            -
                      if (get(record, 'isPending') === false) {
         
     | 
| 
       521 
     | 
    
         
            -
                        array.push(record);
         
     | 
| 
       522 
     | 
    
         
            -
                      }
         
     | 
| 
       523 
     | 
    
         
            -
                    });
         
     | 
| 
       524 
     | 
    
         
            -
             
     | 
| 
       525 
     | 
    
         
            -
                    fn.call(binding, type, array);
         
     | 
| 
       526 
     | 
    
         
            -
                  });
         
     | 
| 
       527 
     | 
    
         
            -
                };
         
     | 
| 
       528 
     | 
    
         
            -
             
     | 
| 
       529 
     | 
    
         
            -
                var commitDetails = {
         
     | 
| 
       530 
     | 
    
         
            -
                  updated: {
         
     | 
| 
       531 
     | 
    
         
            -
                    eachType: function(fn, binding) { iterate('updated', fn, binding); }
         
     | 
| 
       532 
     | 
    
         
            -
                  },
         
     | 
| 
       533 
     | 
    
         
            -
             
     | 
| 
       534 
     | 
    
         
            -
                  created: {
         
     | 
| 
       535 
     | 
    
         
            -
                    eachType: function(fn, binding) { iterate('created', fn, binding); }
         
     | 
| 
       536 
     | 
    
         
            -
                  },
         
     | 
| 
       537 
     | 
    
         
            -
             
     | 
| 
       538 
     | 
    
         
            -
                  deleted: {
         
     | 
| 
       539 
     | 
    
         
            -
                    eachType: function(fn, binding) { iterate('deleted', fn, binding); }
         
     | 
| 
       540 
     | 
    
         
            -
                  }
         
     | 
| 
       541 
     | 
    
         
            -
                };
         
     | 
| 
       542 
     | 
    
         
            -
             
     | 
| 
       543 
     | 
    
         
            -
                var store = get(this, 'store');
         
     | 
| 
       544 
     | 
    
         
            -
                var adapter = get(store, '_adapter');
         
     | 
| 
       545 
     | 
    
         
            -
             
     | 
| 
       546 
     | 
    
         
            -
                this.removeCleanRecords();
         
     | 
| 
       547 
     | 
    
         
            -
             
     | 
| 
       548 
     | 
    
         
            -
                if (adapter && adapter.commit) { adapter.commit(store, commitDetails); }
         
     | 
| 
       549 
     | 
    
         
            -
                else { throw fmt("Adapter is either null or does not implement `commit` method", this); }
         
     | 
| 
       550 
     | 
    
         
            -
              },
         
     | 
| 
       551 
     | 
    
         
            -
             
     | 
| 
       552 
     | 
    
         
            -
              /**
         
     | 
| 
       553 
     | 
    
         
            -
                Rolling back a transaction resets the records that belong to
         
     | 
| 
       554 
     | 
    
         
            -
                that transaction.
         
     | 
| 
       555 
     | 
    
         
            -
             
     | 
| 
       556 
     | 
    
         
            -
                Updated records have their properties reset to the last known
         
     | 
| 
       557 
     | 
    
         
            -
                value from the persistence layer. Deleted records are reverted
         
     | 
| 
       558 
     | 
    
         
            -
                to a clean, non-deleted state. Newly created records immediately
         
     | 
| 
       559 
     | 
    
         
            -
                become deleted, and are not sent to the adapter to be persisted.
         
     | 
| 
       560 
     | 
    
         
            -
             
     | 
| 
       561 
     | 
    
         
            -
                After the transaction is rolled back, any records that belong
         
     | 
| 
       562 
     | 
    
         
            -
                to it will return to the store's default transaction, and the
         
     | 
| 
       563 
     | 
    
         
            -
                current transaction should not be used again.
         
     | 
| 
       564 
     | 
    
         
            -
              */
         
     | 
| 
       565 
     | 
    
         
            -
              rollback: function() {
         
     | 
| 
       566 
     | 
    
         
            -
                var store = get(this, 'store'),
         
     | 
| 
       567 
     | 
    
         
            -
                    dirty;
         
     | 
| 
       568 
     | 
    
         
            -
             
     | 
| 
       569 
     | 
    
         
            -
                // Loop through all of the records in each of the dirty states
         
     | 
| 
       570 
     | 
    
         
            -
                // and initiate a rollback on them. As a side effect of telling
         
     | 
| 
       571 
     | 
    
         
            -
                // the record to roll back, it should also move itself out of
         
     | 
| 
       572 
     | 
    
         
            -
                // the dirty bucket and into the clean bucket.
         
     | 
| 
       573 
     | 
    
         
            -
                ['created', 'updated', 'deleted', 'inflight'].forEach(function(bucketType) {
         
     | 
| 
       574 
     | 
    
         
            -
                  dirty = this.bucketForType(bucketType);
         
     | 
| 
       575 
     | 
    
         
            -
             
     | 
| 
       576 
     | 
    
         
            -
                  dirty.forEach(function(type, records) {
         
     | 
| 
       577 
     | 
    
         
            -
                    records.forEach(function(record) {
         
     | 
| 
       578 
     | 
    
         
            -
                      record.send('rollback');
         
     | 
| 
       579 
     | 
    
         
            -
                    });
         
     | 
| 
       580 
     | 
    
         
            -
                  });
         
     | 
| 
       581 
     | 
    
         
            -
                }, this);
         
     | 
| 
       582 
     | 
    
         
            -
             
     | 
| 
       583 
     | 
    
         
            -
                // Now that all records in the transaction are guaranteed to be
         
     | 
| 
       584 
     | 
    
         
            -
                // clean, migrate them all to the store's default transaction.
         
     | 
| 
       585 
     | 
    
         
            -
                this.removeCleanRecords();
         
     | 
| 
       586 
     | 
    
         
            -
              },
         
     | 
| 
       587 
     | 
    
         
            -
             
     | 
| 
       588 
     | 
    
         
            -
              /**
         
     | 
| 
       589 
     | 
    
         
            -
                @private
         
     | 
| 
       590 
     | 
    
         
            -
             
     | 
| 
       591 
     | 
    
         
            -
                Removes a record from this transaction and back to the store's
         
     | 
| 
       592 
     | 
    
         
            -
                default transaction.
         
     | 
| 
       593 
     | 
    
         
            -
             
     | 
| 
       594 
     | 
    
         
            -
                Note: This method is private for now, but should probably be exposed
         
     | 
| 
       595 
     | 
    
         
            -
                in the future once we have stricter error checking (for example, in the
         
     | 
| 
       596 
     | 
    
         
            -
                case of the record being dirty).
         
     | 
| 
       597 
     | 
    
         
            -
             
     | 
| 
       598 
     | 
    
         
            -
                @param {DS.Model} record
         
     | 
| 
       599 
     | 
    
         
            -
              */
         
     | 
| 
       600 
     | 
    
         
            -
              remove: function(record) {
         
     | 
| 
       601 
     | 
    
         
            -
                var defaultTransaction = getPath(this, 'store.defaultTransaction');
         
     | 
| 
       602 
     | 
    
         
            -
                defaultTransaction.adoptRecord(record);
         
     | 
| 
       603 
     | 
    
         
            -
              },
         
     | 
| 
       604 
     | 
    
         
            -
             
     | 
| 
       605 
     | 
    
         
            -
              /**
         
     | 
| 
       606 
     | 
    
         
            -
                @private
         
     | 
| 
       607 
     | 
    
         
            -
             
     | 
| 
       608 
     | 
    
         
            -
                Removes all of the records in the transaction's clean bucket.
         
     | 
| 
       609 
     | 
    
         
            -
              */
         
     | 
| 
       610 
     | 
    
         
            -
              removeCleanRecords: function() {
         
     | 
| 
       611 
     | 
    
         
            -
                var clean = this.bucketForType('clean'),
         
     | 
| 
       612 
     | 
    
         
            -
                    self = this;
         
     | 
| 
       613 
     | 
    
         
            -
             
     | 
| 
       614 
     | 
    
         
            -
                clean.forEach(function(type, records) {
         
     | 
| 
       615 
     | 
    
         
            -
                  records.forEach(function(record) {
         
     | 
| 
       616 
     | 
    
         
            -
                    self.remove(record);
         
     | 
| 
       617 
     | 
    
         
            -
                  });
         
     | 
| 
       618 
     | 
    
         
            -
                });
         
     | 
| 
       619 
     | 
    
         
            -
              },
         
     | 
| 
       620 
     | 
    
         
            -
             
     | 
| 
       621 
     | 
    
         
            -
              /**
         
     | 
| 
       622 
     | 
    
         
            -
                @private
         
     | 
| 
       623 
     | 
    
         
            -
             
     | 
| 
       624 
     | 
    
         
            -
                Returns the bucket for the given bucket type. For example, you might call
         
     | 
| 
       625 
     | 
    
         
            -
                `this.bucketForType('updated')` to get the `Ember.Map` that contains all
         
     | 
| 
       626 
     | 
    
         
            -
                of the records that have changes pending.
         
     | 
| 
       627 
     | 
    
         
            -
             
     | 
| 
       628 
     | 
    
         
            -
                @param {String} bucketType the type of bucket
         
     | 
| 
       629 
     | 
    
         
            -
                @returns Ember.Map
         
     | 
| 
       630 
     | 
    
         
            -
              */
         
     | 
| 
       631 
     | 
    
         
            -
              bucketForType: function(bucketType) {
         
     | 
| 
       632 
     | 
    
         
            -
                var buckets = get(this, 'buckets');
         
     | 
| 
       633 
     | 
    
         
            -
             
     | 
| 
       634 
     | 
    
         
            -
                return get(buckets, bucketType);
         
     | 
| 
       635 
     | 
    
         
            -
              },
         
     | 
| 
       636 
     | 
    
         
            -
             
     | 
| 
       637 
     | 
    
         
            -
              /**
         
     | 
| 
       638 
     | 
    
         
            -
                @private
         
     | 
| 
       639 
     | 
    
         
            -
             
     | 
| 
       640 
     | 
    
         
            -
                This method moves a record into a different transaction without the normal
         
     | 
| 
       641 
     | 
    
         
            -
                checks that ensure that the user is not doing something weird, like moving
         
     | 
| 
       642 
     | 
    
         
            -
                a dirty record into a new transaction.
         
     | 
| 
       643 
     | 
    
         
            -
             
     | 
| 
       644 
     | 
    
         
            -
                It is designed for internal use, such as when we are moving a clean record
         
     | 
| 
       645 
     | 
    
         
            -
                into a new transaction when the transaction is committed.
         
     | 
| 
       646 
     | 
    
         
            -
             
     | 
| 
       647 
     | 
    
         
            -
                This method must not be called unless the record is clean.
         
     | 
| 
       648 
     | 
    
         
            -
             
     | 
| 
       649 
     | 
    
         
            -
                @param {DS.Model} record
         
     | 
| 
       650 
     | 
    
         
            -
              */
         
     | 
| 
       651 
     | 
    
         
            -
              adoptRecord: function(record) {
         
     | 
| 
       652 
     | 
    
         
            -
                var oldTransaction = get(record, 'transaction');
         
     | 
| 
       653 
     | 
    
         
            -
             
     | 
| 
       654 
     | 
    
         
            -
                if (oldTransaction) {
         
     | 
| 
       655 
     | 
    
         
            -
                  oldTransaction.removeFromBucket('clean', record);
         
     | 
| 
       656 
     | 
    
         
            -
                }
         
     | 
| 
       657 
     | 
    
         
            -
             
     | 
| 
       658 
     | 
    
         
            -
                this.addToBucket('clean', record);
         
     | 
| 
       659 
     | 
    
         
            -
                set(record, 'transaction', this);
         
     | 
| 
       660 
     | 
    
         
            -
              },
         
     | 
| 
       661 
     | 
    
         
            -
             
     | 
| 
       662 
     | 
    
         
            -
              /**
         
     | 
| 
       663 
     | 
    
         
            -
                @private
         
     | 
| 
       664 
     | 
    
         
            -
             
     | 
| 
       665 
     | 
    
         
            -
                Adds a record to the named bucket.
         
     | 
| 
       666 
     | 
    
         
            -
             
     | 
| 
       667 
     | 
    
         
            -
                @param {String} bucketType one of `clean`, `created`, `updated`, or `deleted`
         
     | 
| 
       668 
     | 
    
         
            -
              */
         
     | 
| 
       669 
     | 
    
         
            -
              addToBucket: function(bucketType, record) {
         
     | 
| 
       670 
     | 
    
         
            -
                var bucket = this.bucketForType(bucketType),
         
     | 
| 
       671 
     | 
    
         
            -
                    type = record.constructor;
         
     | 
| 
       672 
     | 
    
         
            -
             
     | 
| 
       673 
     | 
    
         
            -
                var records = bucket.get(type);
         
     | 
| 
       674 
     | 
    
         
            -
             
     | 
| 
       675 
     | 
    
         
            -
                if (!records) {
         
     | 
| 
       676 
     | 
    
         
            -
                  records = Ember.OrderedSet.create();
         
     | 
| 
       677 
     | 
    
         
            -
                  bucket.set(type, records);
         
     | 
| 
       678 
     | 
    
         
            -
                }
         
     | 
| 
       679 
     | 
    
         
            -
             
     | 
| 
       680 
     | 
    
         
            -
                records.add(record);
         
     | 
| 
       681 
     | 
    
         
            -
              },
         
     | 
| 
       682 
     | 
    
         
            -
             
     | 
| 
       683 
     | 
    
         
            -
              /**
         
     | 
| 
       684 
     | 
    
         
            -
                @private
         
     | 
| 
       685 
     | 
    
         
            -
             
     | 
| 
       686 
     | 
    
         
            -
                Removes a record from the named bucket.
         
     | 
| 
       687 
     | 
    
         
            -
             
     | 
| 
       688 
     | 
    
         
            -
                @param {String} bucketType one of `clean`, `created`, `updated`, or `deleted`
         
     | 
| 
       689 
     | 
    
         
            -
              */
         
     | 
| 
       690 
     | 
    
         
            -
              removeFromBucket: function(bucketType, record) {
         
     | 
| 
       691 
     | 
    
         
            -
                var bucket = this.bucketForType(bucketType),
         
     | 
| 
       692 
     | 
    
         
            -
                    type = record.constructor;
         
     | 
| 
       693 
     | 
    
         
            -
             
     | 
| 
       694 
     | 
    
         
            -
                var records = bucket.get(type);
         
     | 
| 
       695 
     | 
    
         
            -
                records.remove(record);
         
     | 
| 
       696 
     | 
    
         
            -
              },
         
     | 
| 
       697 
     | 
    
         
            -
             
     | 
| 
       698 
     | 
    
         
            -
              /**
         
     | 
| 
       699 
     | 
    
         
            -
                @private
         
     | 
| 
       700 
     | 
    
         
            -
             
     | 
| 
       701 
     | 
    
         
            -
                Called by a record's state manager to indicate that the record has entered
         
     | 
| 
       702 
     | 
    
         
            -
                a dirty state. The record will be moved from the `clean` bucket and into
         
     | 
| 
       703 
     | 
    
         
            -
                the appropriate dirty bucket.
         
     | 
| 
       704 
     | 
    
         
            -
             
     | 
| 
       705 
     | 
    
         
            -
                @param {String} bucketType one of `created`, `updated`, or `deleted`
         
     | 
| 
       706 
     | 
    
         
            -
              */
         
     | 
| 
       707 
     | 
    
         
            -
              recordBecameDirty: function(bucketType, record) {
         
     | 
| 
       708 
     | 
    
         
            -
                this.removeFromBucket('clean', record);
         
     | 
| 
       709 
     | 
    
         
            -
                this.addToBucket(bucketType, record);
         
     | 
| 
       710 
     | 
    
         
            -
              },
         
     | 
| 
       711 
     | 
    
         
            -
             
     | 
| 
       712 
     | 
    
         
            -
              /**
         
     | 
| 
       713 
     | 
    
         
            -
                @private
         
     | 
| 
       714 
     | 
    
         
            -
             
     | 
| 
       715 
     | 
    
         
            -
                Called by a record's state manager to indicate that the record has entered
         
     | 
| 
       716 
     | 
    
         
            -
                inflight state. The record will be moved from its current dirty bucket and into
         
     | 
| 
       717 
     | 
    
         
            -
                the `inflight` bucket.
         
     | 
| 
       718 
     | 
    
         
            -
             
     | 
| 
       719 
     | 
    
         
            -
                @param {String} bucketType one of `created`, `updated`, or `deleted`
         
     | 
| 
       720 
     | 
    
         
            -
              */
         
     | 
| 
       721 
     | 
    
         
            -
              recordBecameInFlight: function(kind, record) {
         
     | 
| 
       722 
     | 
    
         
            -
                this.removeFromBucket(kind, record);
         
     | 
| 
       723 
     | 
    
         
            -
                this.addToBucket('inflight', record);
         
     | 
| 
       724 
     | 
    
         
            -
              },
         
     | 
| 
       725 
     | 
    
         
            -
             
     | 
| 
       726 
     | 
    
         
            -
              /**
         
     | 
| 
       727 
     | 
    
         
            -
                @private
         
     | 
| 
       728 
     | 
    
         
            -
             
     | 
| 
       729 
     | 
    
         
            -
                Called by a record's state manager to indicate that the record has entered
         
     | 
| 
       730 
     | 
    
         
            -
                a clean state. The record will be moved from its current dirty or inflight bucket and into
         
     | 
| 
       731 
     | 
    
         
            -
                the `clean` bucket.
         
     | 
| 
       732 
     | 
    
         
            -
             
     | 
| 
       733 
     | 
    
         
            -
                @param {String} bucketType one of `created`, `updated`, or `deleted`
         
     | 
| 
       734 
     | 
    
         
            -
              */
         
     | 
| 
       735 
     | 
    
         
            -
              recordBecameClean: function(kind, record) {
         
     | 
| 
       736 
     | 
    
         
            -
                this.removeFromBucket(kind, record);
         
     | 
| 
       737 
     | 
    
         
            -
             
     | 
| 
       738 
     | 
    
         
            -
                this.remove(record);
         
     | 
| 
       739 
     | 
    
         
            -
              }
         
     | 
| 
       740 
     | 
    
         
            -
            });
         
     | 
| 
       741 
     | 
    
         
            -
             
     | 
| 
       742 
     | 
    
         
            -
            })();
         
     | 
| 
       743 
     | 
    
         
            -
             
     | 
| 
       744 
     | 
    
         
            -
             
     | 
| 
       745 
     | 
    
         
            -
             
     | 
| 
       746 
     | 
    
         
            -
            (function() {
         
     | 
| 
       747 
     | 
    
         
            -
            /*globals Ember*/
         
     | 
| 
       748 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set, getPath = Ember.getPath, fmt = Ember.String.fmt;
         
     | 
| 
       749 
     | 
    
         
            -
             
     | 
| 
       750 
     | 
    
         
            -
            var DATA_PROXY = {
         
     | 
| 
       751 
     | 
    
         
            -
              get: function(name) {
         
     | 
| 
       752 
     | 
    
         
            -
                return this.savedData[name];
         
     | 
| 
       753 
     | 
    
         
            -
              }
         
     | 
| 
       754 
     | 
    
         
            -
            };
         
     | 
| 
       755 
     | 
    
         
            -
             
     | 
| 
       756 
     | 
    
         
            -
            // These values are used in the data cache when clientIds are
         
     | 
| 
       757 
     | 
    
         
            -
            // needed but the underlying data has not yet been loaded by
         
     | 
| 
       758 
     | 
    
         
            -
            // the server.
         
     | 
| 
       759 
     | 
    
         
            -
            var UNLOADED = 'unloaded';
         
     | 
| 
       760 
     | 
    
         
            -
            var LOADING = 'loading';
         
     | 
| 
       761 
     | 
    
         
            -
             
     | 
| 
       762 
     | 
    
         
            -
            // Implementors Note:
         
     | 
| 
       763 
     | 
    
         
            -
            //
         
     | 
| 
       764 
     | 
    
         
            -
            //   The variables in this file are consistently named according to the following
         
     | 
| 
       765 
     | 
    
         
            -
            //   scheme:
         
     | 
| 
       766 
     | 
    
         
            -
            //
         
     | 
| 
       767 
     | 
    
         
            -
            //   * +id+ means an identifier managed by an external source, provided inside the
         
     | 
| 
       768 
     | 
    
         
            -
            //     data hash provided by that source.
         
     | 
| 
       769 
     | 
    
         
            -
            //   * +clientId+ means a transient numerical identifier generated at runtime by
         
     | 
| 
       770 
     | 
    
         
            -
            //     the data store. It is important primarily because newly created objects may
         
     | 
| 
       771 
     | 
    
         
            -
            //     not yet have an externally generated id.
         
     | 
| 
       772 
     | 
    
         
            -
            //   * +type+ means a subclass of DS.Model.
         
     | 
| 
       773 
     | 
    
         
            -
             
     | 
| 
       774 
     | 
    
         
            -
            /**
         
     | 
| 
       775 
     | 
    
         
            -
              The store contains all of the hashes for records loaded from the server.
         
     | 
| 
       776 
     | 
    
         
            -
              It is also responsible for creating instances of DS.Model when you request one
         
     | 
| 
       777 
     | 
    
         
            -
              of these data hashes, so that they can be bound to in your Handlebars templates.
         
     | 
| 
       778 
     | 
    
         
            -
             
     | 
| 
       779 
     | 
    
         
            -
              Create a new store like this:
         
     | 
| 
       780 
     | 
    
         
            -
             
     | 
| 
       781 
     | 
    
         
            -
                   MyApp.store = DS.Store.create();
         
     | 
| 
       782 
     | 
    
         
            -
             
     | 
| 
       783 
     | 
    
         
            -
              You can retrieve DS.Model instances from the store in several ways. To retrieve
         
     | 
| 
       784 
     | 
    
         
            -
              a record for a specific id, use the `find()` method:
         
     | 
| 
       785 
     | 
    
         
            -
             
     | 
| 
       786 
     | 
    
         
            -
                   var record = MyApp.store.find(MyApp.Contact, 123);
         
     | 
| 
       787 
     | 
    
         
            -
             
     | 
| 
       788 
     | 
    
         
            -
               By default, the store will talk to your backend using a standard REST mechanism.
         
     | 
| 
       789 
     | 
    
         
            -
               You can customize how the store talks to your backend by specifying a custom adapter:
         
     | 
| 
       790 
     | 
    
         
            -
             
     | 
| 
       791 
     | 
    
         
            -
                   MyApp.store = DS.Store.create({
         
     | 
| 
       792 
     | 
    
         
            -
                     adapter: 'MyApp.CustomAdapter'
         
     | 
| 
       793 
     | 
    
         
            -
                   });
         
     | 
| 
       794 
     | 
    
         
            -
             
     | 
| 
       795 
     | 
    
         
            -
                You can learn more about writing a custom adapter by reading the `DS.Adapter`
         
     | 
| 
       796 
     | 
    
         
            -
                documentation.
         
     | 
| 
       797 
     | 
    
         
            -
            */
         
     | 
| 
       798 
     | 
    
         
            -
            DS.Store = Ember.Object.extend({
         
     | 
| 
       799 
     | 
    
         
            -
             
     | 
| 
       800 
     | 
    
         
            -
              /**
         
     | 
| 
       801 
     | 
    
         
            -
                Many methods can be invoked without specifying which store should be used.
         
     | 
| 
       802 
     | 
    
         
            -
                In those cases, the first store created will be used as the default. If
         
     | 
| 
       803 
     | 
    
         
            -
                an application has multiple stores, it should specify which store to use
         
     | 
| 
       804 
     | 
    
         
            -
                when performing actions, such as finding records by id.
         
     | 
| 
       805 
     | 
    
         
            -
             
     | 
| 
       806 
     | 
    
         
            -
                The init method registers this store as the default if none is specified.
         
     | 
| 
       807 
     | 
    
         
            -
              */
         
     | 
| 
       808 
     | 
    
         
            -
              init: function() {
         
     | 
| 
       809 
     | 
    
         
            -
                // Enforce API revisioning. See BREAKING_CHANGES.md for more.
         
     | 
| 
       810 
     | 
    
         
            -
                var revision = get(this, 'revision');
         
     | 
| 
       811 
     | 
    
         
            -
             
     | 
| 
       812 
     | 
    
         
            -
                if (revision !== DS.CURRENT_API_REVISION && !Ember.ENV.TESTING) {
         
     | 
| 
       813 
     | 
    
         
            -
                  throw new Error("Error: The Ember Data library has had breaking API changes since the last time you updated the library. Please review the list of breaking changes at https://github.com/emberjs/data/blob/master/BREAKING_CHANGES.md, then update your store's `revision` property to " + DS.CURRENT_API_REVISION);
         
     | 
| 
       814 
     | 
    
         
            -
                }
         
     | 
| 
       815 
     | 
    
         
            -
             
     | 
| 
       816 
     | 
    
         
            -
                if (!get(DS, 'defaultStore') || get(this, 'isDefaultStore')) {
         
     | 
| 
       817 
     | 
    
         
            -
                  set(DS, 'defaultStore', this);
         
     | 
| 
       818 
     | 
    
         
            -
                }
         
     | 
| 
       819 
     | 
    
         
            -
             
     | 
| 
       820 
     | 
    
         
            -
                // internal bookkeeping; not observable
         
     | 
| 
       821 
     | 
    
         
            -
                this.typeMaps = {};
         
     | 
| 
       822 
     | 
    
         
            -
                this.recordCache = [];
         
     | 
| 
       823 
     | 
    
         
            -
                this.clientIdToId = {};
         
     | 
| 
       824 
     | 
    
         
            -
                this.recordArraysByClientId = {};
         
     | 
| 
       825 
     | 
    
         
            -
             
     | 
| 
       826 
     | 
    
         
            -
                set(this, 'defaultTransaction', this.transaction());
         
     | 
| 
       827 
     | 
    
         
            -
             
     | 
| 
       828 
     | 
    
         
            -
                return this._super();
         
     | 
| 
       829 
     | 
    
         
            -
              },
         
     | 
| 
       830 
     | 
    
         
            -
             
     | 
| 
       831 
     | 
    
         
            -
              /**
         
     | 
| 
       832 
     | 
    
         
            -
                Returns a new transaction scoped to this store.
         
     | 
| 
       833 
     | 
    
         
            -
             
     | 
| 
       834 
     | 
    
         
            -
                @see {DS.Transaction}
         
     | 
| 
       835 
     | 
    
         
            -
                @returns DS.Transaction
         
     | 
| 
       836 
     | 
    
         
            -
              */
         
     | 
| 
       837 
     | 
    
         
            -
              transaction: function() {
         
     | 
| 
       838 
     | 
    
         
            -
                return DS.Transaction.create({ store: this });
         
     | 
| 
       839 
     | 
    
         
            -
              },
         
     | 
| 
       840 
     | 
    
         
            -
             
     | 
| 
       841 
     | 
    
         
            -
              /**
         
     | 
| 
       842 
     | 
    
         
            -
                @private
         
     | 
| 
       843 
     | 
    
         
            -
             
     | 
| 
       844 
     | 
    
         
            -
                This is used only by the record's DataProxy. Do not use this directly.
         
     | 
| 
       845 
     | 
    
         
            -
              */
         
     | 
| 
       846 
     | 
    
         
            -
              dataForRecord: function(record) {
         
     | 
| 
       847 
     | 
    
         
            -
                var type = record.constructor,
         
     | 
| 
       848 
     | 
    
         
            -
                    clientId = get(record, 'clientId'),
         
     | 
| 
       849 
     | 
    
         
            -
                    typeMap = this.typeMapFor(type);
         
     | 
| 
       850 
     | 
    
         
            -
             
     | 
| 
       851 
     | 
    
         
            -
                return typeMap.cidToHash[clientId];
         
     | 
| 
       852 
     | 
    
         
            -
              },
         
     | 
| 
       853 
     | 
    
         
            -
             
     | 
| 
       854 
     | 
    
         
            -
              /**
         
     | 
| 
       855 
     | 
    
         
            -
                The adapter to use to communicate to a backend server or other persistence layer.
         
     | 
| 
       856 
     | 
    
         
            -
             
     | 
| 
       857 
     | 
    
         
            -
                This can be specified as an instance, a class, or a property path that specifies
         
     | 
| 
       858 
     | 
    
         
            -
                where the adapter can be located.
         
     | 
| 
       859 
     | 
    
         
            -
             
     | 
| 
       860 
     | 
    
         
            -
                @property {DS.Adapter|String}
         
     | 
| 
       861 
     | 
    
         
            -
              */
         
     | 
| 
       862 
     | 
    
         
            -
              adapter: null,
         
     | 
| 
       863 
     | 
    
         
            -
             
     | 
| 
       864 
     | 
    
         
            -
              /**
         
     | 
| 
       865 
     | 
    
         
            -
                @private
         
     | 
| 
       866 
     | 
    
         
            -
             
     | 
| 
       867 
     | 
    
         
            -
                This property returns the adapter, after resolving a possible String.
         
     | 
| 
       868 
     | 
    
         
            -
             
     | 
| 
       869 
     | 
    
         
            -
                @returns DS.Adapter
         
     | 
| 
       870 
     | 
    
         
            -
              */
         
     | 
| 
       871 
     | 
    
         
            -
              _adapter: Ember.computed(function() {
         
     | 
| 
       872 
     | 
    
         
            -
                var adapter = get(this, 'adapter');
         
     | 
| 
       873 
     | 
    
         
            -
                if (typeof adapter === 'string') {
         
     | 
| 
       874 
     | 
    
         
            -
                  return getPath(this, adapter, false) || getPath(window, adapter);
         
     | 
| 
       875 
     | 
    
         
            -
                }
         
     | 
| 
       876 
     | 
    
         
            -
                return adapter;
         
     | 
| 
       877 
     | 
    
         
            -
              }).property('adapter').cacheable(),
         
     | 
| 
       878 
     | 
    
         
            -
             
     | 
| 
       879 
     | 
    
         
            -
              // A monotonically increasing number to be used to uniquely identify
         
     | 
| 
       880 
     | 
    
         
            -
              // data hashes and records.
         
     | 
| 
       881 
     | 
    
         
            -
              clientIdCounter: 1,
         
     | 
| 
       882 
     | 
    
         
            -
             
     | 
| 
       883 
     | 
    
         
            -
              // .....................
         
     | 
| 
       884 
     | 
    
         
            -
              // . CREATE NEW RECORD .
         
     | 
| 
       885 
     | 
    
         
            -
              // .....................
         
     | 
| 
       886 
     | 
    
         
            -
             
     | 
| 
       887 
     | 
    
         
            -
              /**
         
     | 
| 
       888 
     | 
    
         
            -
                Create a new record in the current store. The properties passed
         
     | 
| 
       889 
     | 
    
         
            -
                to this method are set on the newly created record.
         
     | 
| 
       890 
     | 
    
         
            -
             
     | 
| 
       891 
     | 
    
         
            -
                @param {subclass of DS.Model} type
         
     | 
| 
       892 
     | 
    
         
            -
                @param {Object} properties a hash of properties to set on the
         
     | 
| 
       893 
     | 
    
         
            -
                  newly created record.
         
     | 
| 
       894 
     | 
    
         
            -
                @returns DS.Model
         
     | 
| 
       895 
     | 
    
         
            -
              */
         
     | 
| 
       896 
     | 
    
         
            -
              createRecord: function(type, properties, transaction) {
         
     | 
| 
       897 
     | 
    
         
            -
                properties = properties || {};
         
     | 
| 
       898 
     | 
    
         
            -
             
     | 
| 
       899 
     | 
    
         
            -
                // Create a new instance of the model `type` and put it
         
     | 
| 
       900 
     | 
    
         
            -
                // into the specified `transaction`. If no transaction is
         
     | 
| 
       901 
     | 
    
         
            -
                // specified, the default transaction will be used.
         
     | 
| 
       902 
     | 
    
         
            -
                //
         
     | 
| 
       903 
     | 
    
         
            -
                // NOTE: A `transaction` is specified when the
         
     | 
| 
       904 
     | 
    
         
            -
                // `transaction.createRecord` API is used.
         
     | 
| 
       905 
     | 
    
         
            -
                var record = type._create({
         
     | 
| 
       906 
     | 
    
         
            -
                  store: this
         
     | 
| 
       907 
     | 
    
         
            -
                });
         
     | 
| 
       908 
     | 
    
         
            -
             
     | 
| 
       909 
     | 
    
         
            -
                transaction = transaction || get(this, 'defaultTransaction');
         
     | 
| 
       910 
     | 
    
         
            -
                transaction.adoptRecord(record);
         
     | 
| 
       911 
     | 
    
         
            -
             
     | 
| 
       912 
     | 
    
         
            -
                // Extract the primary key from the `properties` hash,
         
     | 
| 
       913 
     | 
    
         
            -
                // based on the `primaryKey` for the model type.
         
     | 
| 
       914 
     | 
    
         
            -
                var primaryKey = get(record, 'primaryKey'),
         
     | 
| 
       915 
     | 
    
         
            -
                    id = properties[primaryKey] || null;
         
     | 
| 
       916 
     | 
    
         
            -
             
     | 
| 
       917 
     | 
    
         
            -
                // If the passed properties do not include a primary key,
         
     | 
| 
       918 
     | 
    
         
            -
                // give the adapter an opportunity to generate one.
         
     | 
| 
       919 
     | 
    
         
            -
                var adapter;
         
     | 
| 
       920 
     | 
    
         
            -
                if (Ember.none(id)) {
         
     | 
| 
       921 
     | 
    
         
            -
                  adapter = get(this, 'adapter');
         
     | 
| 
       922 
     | 
    
         
            -
                  if (adapter && adapter.generateIdForRecord) {
         
     | 
| 
       923 
     | 
    
         
            -
                    id = adapter.generateIdForRecord(this, record);
         
     | 
| 
       924 
     | 
    
         
            -
                    properties.id = id;
         
     | 
| 
       925 
     | 
    
         
            -
                  }
         
     | 
| 
       926 
     | 
    
         
            -
                }
         
     | 
| 
       927 
     | 
    
         
            -
             
     | 
| 
       928 
     | 
    
         
            -
                var hash = {}, clientId;
         
     | 
| 
       929 
     | 
    
         
            -
             
     | 
| 
       930 
     | 
    
         
            -
                // Push the hash into the store. If present, associate the
         
     | 
| 
       931 
     | 
    
         
            -
                // extracted `id` with the hash.
         
     | 
| 
       932 
     | 
    
         
            -
                clientId = this.pushHash(hash, id, type);
         
     | 
| 
       933 
     | 
    
         
            -
             
     | 
| 
       934 
     | 
    
         
            -
                record.send('didChangeData');
         
     | 
| 
       935 
     | 
    
         
            -
             
     | 
| 
       936 
     | 
    
         
            -
                var recordCache = get(this, 'recordCache');
         
     | 
| 
       937 
     | 
    
         
            -
             
     | 
| 
       938 
     | 
    
         
            -
                // Now that we have a clientId, attach it to the record we
         
     | 
| 
       939 
     | 
    
         
            -
                // just created.
         
     | 
| 
       940 
     | 
    
         
            -
                set(record, 'clientId', clientId);
         
     | 
| 
       941 
     | 
    
         
            -
             
     | 
| 
       942 
     | 
    
         
            -
                // Store the record we just created in the record cache for
         
     | 
| 
       943 
     | 
    
         
            -
                // this clientId.
         
     | 
| 
       944 
     | 
    
         
            -
                recordCache[clientId] = record;
         
     | 
| 
       945 
     | 
    
         
            -
             
     | 
| 
       946 
     | 
    
         
            -
                // Set the properties specified on the record.
         
     | 
| 
       947 
     | 
    
         
            -
                record.setProperties(properties);
         
     | 
| 
       948 
     | 
    
         
            -
             
     | 
| 
       949 
     | 
    
         
            -
                this.updateRecordArrays(type, clientId, get(record, 'data'));
         
     | 
| 
       950 
     | 
    
         
            -
             
     | 
| 
       951 
     | 
    
         
            -
                return record;
         
     | 
| 
       952 
     | 
    
         
            -
              },
         
     | 
| 
       953 
     | 
    
         
            -
             
     | 
| 
       954 
     | 
    
         
            -
              // .................
         
     | 
| 
       955 
     | 
    
         
            -
              // . DELETE RECORD .
         
     | 
| 
       956 
     | 
    
         
            -
              // .................
         
     | 
| 
       957 
     | 
    
         
            -
             
     | 
| 
       958 
     | 
    
         
            -
              /**
         
     | 
| 
       959 
     | 
    
         
            -
                For symmetry, a record can be deleted via the store.
         
     | 
| 
       960 
     | 
    
         
            -
             
     | 
| 
       961 
     | 
    
         
            -
                @param {DS.Model} record
         
     | 
| 
       962 
     | 
    
         
            -
              */
         
     | 
| 
       963 
     | 
    
         
            -
              deleteRecord: function(record) {
         
     | 
| 
       964 
     | 
    
         
            -
                record.send('deleteRecord');
         
     | 
| 
       965 
     | 
    
         
            -
              },
         
     | 
| 
       966 
     | 
    
         
            -
             
     | 
| 
       967 
     | 
    
         
            -
              // ................
         
     | 
| 
       968 
     | 
    
         
            -
              // . FIND RECORDS .
         
     | 
| 
       969 
     | 
    
         
            -
              // ................
         
     | 
| 
       970 
     | 
    
         
            -
             
     | 
| 
       971 
     | 
    
         
            -
              /**
         
     | 
| 
       972 
     | 
    
         
            -
                This is the main entry point into finding records. The first
         
     | 
| 
       973 
     | 
    
         
            -
                parameter to this method is always a subclass of `DS.Model`.
         
     | 
| 
       974 
     | 
    
         
            -
             
     | 
| 
       975 
     | 
    
         
            -
                You can use the `find` method on a subclass of `DS.Model`
         
     | 
| 
       976 
     | 
    
         
            -
                directly if your application only has one store. For
         
     | 
| 
       977 
     | 
    
         
            -
                example, instead of `store.find(App.Person, 1)`, you could
         
     | 
| 
       978 
     | 
    
         
            -
                say `App.Person.find(1)`.
         
     | 
| 
       979 
     | 
    
         
            -
             
     | 
| 
       980 
     | 
    
         
            -
                ---
         
     | 
| 
       981 
     | 
    
         
            -
             
     | 
| 
       982 
     | 
    
         
            -
                To find a record by ID, pass the `id` as the second parameter:
         
     | 
| 
       983 
     | 
    
         
            -
             
     | 
| 
       984 
     | 
    
         
            -
                    store.find(App.Person, 1);
         
     | 
| 
       985 
     | 
    
         
            -
                    App.Person.find(1);
         
     | 
| 
       986 
     | 
    
         
            -
             
     | 
| 
       987 
     | 
    
         
            -
                If the record with that `id` had not previously been loaded,
         
     | 
| 
       988 
     | 
    
         
            -
                the store will return an empty record immediately and ask
         
     | 
| 
       989 
     | 
    
         
            -
                the adapter to find the data by calling the adapter's `find`
         
     | 
| 
       990 
     | 
    
         
            -
                method.
         
     | 
| 
       991 
     | 
    
         
            -
             
     | 
| 
       992 
     | 
    
         
            -
                The `find` method will always return the same object for a
         
     | 
| 
       993 
     | 
    
         
            -
                given type and `id`. To check whether the adapter has populated
         
     | 
| 
       994 
     | 
    
         
            -
                a record, you can check its `isLoaded` property.
         
     | 
| 
       995 
     | 
    
         
            -
             
     | 
| 
       996 
     | 
    
         
            -
                ---
         
     | 
| 
       997 
     | 
    
         
            -
             
     | 
| 
       998 
     | 
    
         
            -
                To find all records for a type, call `find` with no additional
         
     | 
| 
       999 
     | 
    
         
            -
                parameters:
         
     | 
| 
       1000 
     | 
    
         
            -
             
     | 
| 
       1001 
     | 
    
         
            -
                    store.find(App.Person);
         
     | 
| 
       1002 
     | 
    
         
            -
                    App.Person.find();
         
     | 
| 
       1003 
     | 
    
         
            -
             
     | 
| 
       1004 
     | 
    
         
            -
                This will return a `RecordArray` representing all known records
         
     | 
| 
       1005 
     | 
    
         
            -
                for the given type and kick off a request to the adapter's
         
     | 
| 
       1006 
     | 
    
         
            -
                `findAll` method to load any additional records for the type.
         
     | 
| 
       1007 
     | 
    
         
            -
             
     | 
| 
       1008 
     | 
    
         
            -
                The `RecordArray` returned by `find()` is live. If any more
         
     | 
| 
       1009 
     | 
    
         
            -
                records for the type are added at a later time through any
         
     | 
| 
       1010 
     | 
    
         
            -
                mechanism, it will automatically update to reflect the change.
         
     | 
| 
       1011 
     | 
    
         
            -
             
     | 
| 
       1012 
     | 
    
         
            -
                ---
         
     | 
| 
       1013 
     | 
    
         
            -
             
     | 
| 
       1014 
     | 
    
         
            -
                To find a record by a query, call `find` with a hash as the
         
     | 
| 
       1015 
     | 
    
         
            -
                second parameter:
         
     | 
| 
       1016 
     | 
    
         
            -
             
     | 
| 
       1017 
     | 
    
         
            -
                    store.find(App.Person, { page: 1 });
         
     | 
| 
       1018 
     | 
    
         
            -
                    App.Person.find({ page: 1 });
         
     | 
| 
       1019 
     | 
    
         
            -
             
     | 
| 
       1020 
     | 
    
         
            -
                This will return a `RecordArray` immediately, but it will always
         
     | 
| 
       1021 
     | 
    
         
            -
                be an empty `RecordArray` at first. It will call the adapter's
         
     | 
| 
       1022 
     | 
    
         
            -
                `findQuery` method, which will populate the `RecordArray` once
         
     | 
| 
       1023 
     | 
    
         
            -
                the server has returned results.
         
     | 
| 
       1024 
     | 
    
         
            -
             
     | 
| 
       1025 
     | 
    
         
            -
                You can check whether a query results `RecordArray` has loaded
         
     | 
| 
       1026 
     | 
    
         
            -
                by checking its `isLoaded` property.
         
     | 
| 
       1027 
     | 
    
         
            -
              */
         
     | 
| 
       1028 
     | 
    
         
            -
              find: function(type, id, query) {
         
     | 
| 
       1029 
     | 
    
         
            -
                if (id === undefined) {
         
     | 
| 
       1030 
     | 
    
         
            -
                  return this.findAll(type);
         
     | 
| 
       1031 
     | 
    
         
            -
                }
         
     | 
| 
       1032 
     | 
    
         
            -
             
     | 
| 
       1033 
     | 
    
         
            -
                if (query !== undefined) {
         
     | 
| 
       1034 
     | 
    
         
            -
                  return this.findMany(type, id, query);
         
     | 
| 
       1035 
     | 
    
         
            -
                } else if (Ember.typeOf(id) === 'object') {
         
     | 
| 
       1036 
     | 
    
         
            -
                  return this.findQuery(type, id);
         
     | 
| 
       1037 
     | 
    
         
            -
                }
         
     | 
| 
       1038 
     | 
    
         
            -
             
     | 
| 
       1039 
     | 
    
         
            -
                if (Ember.isArray(id)) {
         
     | 
| 
       1040 
     | 
    
         
            -
                  return this.findMany(type, id);
         
     | 
| 
       1041 
     | 
    
         
            -
                }
         
     | 
| 
       1042 
     | 
    
         
            -
             
     | 
| 
       1043 
     | 
    
         
            -
                var clientId = this.typeMapFor(type).idToCid[id];
         
     | 
| 
       1044 
     | 
    
         
            -
             
     | 
| 
       1045 
     | 
    
         
            -
                return this.findByClientId(type, clientId, id);
         
     | 
| 
       1046 
     | 
    
         
            -
              },
         
     | 
| 
       1047 
     | 
    
         
            -
             
     | 
| 
       1048 
     | 
    
         
            -
              findByClientId: function(type, clientId, id) {
         
     | 
| 
       1049 
     | 
    
         
            -
                var recordCache = get(this, 'recordCache'),
         
     | 
| 
       1050 
     | 
    
         
            -
                    dataCache = this.typeMapFor(type).cidToHash,
         
     | 
| 
       1051 
     | 
    
         
            -
                    record;
         
     | 
| 
       1052 
     | 
    
         
            -
             
     | 
| 
       1053 
     | 
    
         
            -
                // If there is already a clientId assigned for this
         
     | 
| 
       1054 
     | 
    
         
            -
                // type/id combination, try to find an existing
         
     | 
| 
       1055 
     | 
    
         
            -
                // record for that id and return. Otherwise,
         
     | 
| 
       1056 
     | 
    
         
            -
                // materialize a new record and set its data to the
         
     | 
| 
       1057 
     | 
    
         
            -
                // value we already have.
         
     | 
| 
       1058 
     | 
    
         
            -
                if (clientId !== undefined) {
         
     | 
| 
       1059 
     | 
    
         
            -
                  record = recordCache[clientId];
         
     | 
| 
       1060 
     | 
    
         
            -
             
     | 
| 
       1061 
     | 
    
         
            -
                  if (!record) {
         
     | 
| 
       1062 
     | 
    
         
            -
                    // create a new instance of the model type in the
         
     | 
| 
       1063 
     | 
    
         
            -
                    // 'isLoading' state
         
     | 
| 
       1064 
     | 
    
         
            -
                    record = this.materializeRecord(type, clientId);
         
     | 
| 
       1065 
     | 
    
         
            -
             
     | 
| 
       1066 
     | 
    
         
            -
                    if (typeof dataCache[clientId] === 'object') {
         
     | 
| 
       1067 
     | 
    
         
            -
                      record.send('didChangeData');
         
     | 
| 
       1068 
     | 
    
         
            -
                    }
         
     | 
| 
       1069 
     | 
    
         
            -
                  }
         
     | 
| 
       1070 
     | 
    
         
            -
                } else {
         
     | 
| 
       1071 
     | 
    
         
            -
                  clientId = this.pushHash(LOADING, id, type);
         
     | 
| 
       1072 
     | 
    
         
            -
             
     | 
| 
       1073 
     | 
    
         
            -
                  // create a new instance of the model type in the
         
     | 
| 
       1074 
     | 
    
         
            -
                  // 'isLoading' state
         
     | 
| 
       1075 
     | 
    
         
            -
                  record = this.materializeRecord(type, clientId);
         
     | 
| 
       1076 
     | 
    
         
            -
             
     | 
| 
       1077 
     | 
    
         
            -
                  // let the adapter set the data, possibly async
         
     | 
| 
       1078 
     | 
    
         
            -
                  var adapter = get(this, '_adapter');
         
     | 
| 
       1079 
     | 
    
         
            -
                  if (adapter && adapter.find) { adapter.find(this, type, id); }
         
     | 
| 
       1080 
     | 
    
         
            -
                  else { throw fmt("Adapter is either null or does not implement `find` method", this); }
         
     | 
| 
       1081 
     | 
    
         
            -
                }
         
     | 
| 
       1082 
     | 
    
         
            -
             
     | 
| 
       1083 
     | 
    
         
            -
                return record;
         
     | 
| 
       1084 
     | 
    
         
            -
              },
         
     | 
| 
       1085 
     | 
    
         
            -
             
     | 
| 
       1086 
     | 
    
         
            -
              /**
         
     | 
| 
       1087 
     | 
    
         
            -
                @private
         
     | 
| 
       1088 
     | 
    
         
            -
             
     | 
| 
       1089 
     | 
    
         
            -
                Ask the adapter to fetch IDs that are not already loaded.
         
     | 
| 
       1090 
     | 
    
         
            -
             
     | 
| 
       1091 
     | 
    
         
            -
                This method will convert `id`s to `clientId`s, filter out
         
     | 
| 
       1092 
     | 
    
         
            -
                `clientId`s that already have a data hash present, and pass
         
     | 
| 
       1093 
     | 
    
         
            -
                the remaining `id`s to the adapter.
         
     | 
| 
       1094 
     | 
    
         
            -
             
     | 
| 
       1095 
     | 
    
         
            -
                @param {Class} type A model class
         
     | 
| 
       1096 
     | 
    
         
            -
                @param {Array} ids An array of ids
         
     | 
| 
       1097 
     | 
    
         
            -
                @param {Object} query
         
     | 
| 
       1098 
     | 
    
         
            -
             
     | 
| 
       1099 
     | 
    
         
            -
                @returns {Array} An Array of all clientIds for the
         
     | 
| 
       1100 
     | 
    
         
            -
                  specified ids.
         
     | 
| 
       1101 
     | 
    
         
            -
              */
         
     | 
| 
       1102 
     | 
    
         
            -
              fetchMany: function(type, ids, query) {
         
     | 
| 
       1103 
     | 
    
         
            -
                var typeMap = this.typeMapFor(type),
         
     | 
| 
       1104 
     | 
    
         
            -
                    idToClientIdMap = typeMap.idToCid,
         
     | 
| 
       1105 
     | 
    
         
            -
                    dataCache = typeMap.cidToHash,
         
     | 
| 
       1106 
     | 
    
         
            -
                    data = typeMap.cidToHash,
         
     | 
| 
       1107 
     | 
    
         
            -
                    needed;
         
     | 
| 
       1108 
     | 
    
         
            -
             
     | 
| 
       1109 
     | 
    
         
            -
                var clientIds = Ember.A([]);
         
     | 
| 
       1110 
     | 
    
         
            -
             
     | 
| 
       1111 
     | 
    
         
            -
                if (ids) {
         
     | 
| 
       1112 
     | 
    
         
            -
                  needed = [];
         
     | 
| 
       1113 
     | 
    
         
            -
             
     | 
| 
       1114 
     | 
    
         
            -
                  ids.forEach(function(id) {
         
     | 
| 
       1115 
     | 
    
         
            -
                    // Get the clientId for the given id
         
     | 
| 
       1116 
     | 
    
         
            -
                    var clientId = idToClientIdMap[id];
         
     | 
| 
       1117 
     | 
    
         
            -
             
     | 
| 
       1118 
     | 
    
         
            -
                    // If there is no `clientId` yet
         
     | 
| 
       1119 
     | 
    
         
            -
                    if (clientId === undefined) {
         
     | 
| 
       1120 
     | 
    
         
            -
                      // Create a new `clientId`, marking its data hash
         
     | 
| 
       1121 
     | 
    
         
            -
                      // as loading. Once the adapter returns the data
         
     | 
| 
       1122 
     | 
    
         
            -
                      // hash, it will be updated
         
     | 
| 
       1123 
     | 
    
         
            -
                      clientId = this.pushHash(LOADING, id, type);
         
     | 
| 
       1124 
     | 
    
         
            -
                      needed.push(id);
         
     | 
| 
       1125 
     | 
    
         
            -
             
     | 
| 
       1126 
     | 
    
         
            -
                    // If there is a clientId, but its data hash is
         
     | 
| 
       1127 
     | 
    
         
            -
                    // marked as unloaded (this happens when a
         
     | 
| 
       1128 
     | 
    
         
            -
                    // hasMany association creates clientIds for its
         
     | 
| 
       1129 
     | 
    
         
            -
                    // referenced ids before they were loaded)
         
     | 
| 
       1130 
     | 
    
         
            -
                    } else if (clientId && data[clientId] === UNLOADED) {
         
     | 
| 
       1131 
     | 
    
         
            -
                      // change the data hash marker to loading
         
     | 
| 
       1132 
     | 
    
         
            -
                      dataCache[clientId] = LOADING;
         
     | 
| 
       1133 
     | 
    
         
            -
                      needed.push(id);
         
     | 
| 
       1134 
     | 
    
         
            -
                    }
         
     | 
| 
       1135 
     | 
    
         
            -
             
     | 
| 
       1136 
     | 
    
         
            -
                    // this method is expected to return a list of
         
     | 
| 
       1137 
     | 
    
         
            -
                    // all of the clientIds for the specified ids,
         
     | 
| 
       1138 
     | 
    
         
            -
                    // unconditionally add it.
         
     | 
| 
       1139 
     | 
    
         
            -
                    clientIds.push(clientId);
         
     | 
| 
       1140 
     | 
    
         
            -
                  }, this);
         
     | 
| 
       1141 
     | 
    
         
            -
                } else {
         
     | 
| 
       1142 
     | 
    
         
            -
                  needed = null;
         
     | 
| 
       1143 
     | 
    
         
            -
                }
         
     | 
| 
       1144 
     | 
    
         
            -
             
     | 
| 
       1145 
     | 
    
         
            -
                // If there are any needed ids, ask the adapter to load them
         
     | 
| 
       1146 
     | 
    
         
            -
                if ((needed && get(needed, 'length') > 0) || query) {
         
     | 
| 
       1147 
     | 
    
         
            -
                  var adapter = get(this, '_adapter');
         
     | 
| 
       1148 
     | 
    
         
            -
                  if (adapter && adapter.findMany) { adapter.findMany(this, type, needed, query); }
         
     | 
| 
       1149 
     | 
    
         
            -
                  else { throw fmt("Adapter is either null or does not implement `findMany` method", this); }
         
     | 
| 
       1150 
     | 
    
         
            -
                }
         
     | 
| 
       1151 
     | 
    
         
            -
             
     | 
| 
       1152 
     | 
    
         
            -
                return clientIds;
         
     | 
| 
       1153 
     | 
    
         
            -
              },
         
     | 
| 
       1154 
     | 
    
         
            -
             
     | 
| 
       1155 
     | 
    
         
            -
              /** @private
         
     | 
| 
       1156 
     | 
    
         
            -
              */
         
     | 
| 
       1157 
     | 
    
         
            -
              findMany: function(type, ids, query) {
         
     | 
| 
       1158 
     | 
    
         
            -
                var clientIds = this.fetchMany(type, ids, query);
         
     | 
| 
       1159 
     | 
    
         
            -
             
     | 
| 
       1160 
     | 
    
         
            -
                return this.createManyArray(type, clientIds);
         
     | 
| 
       1161 
     | 
    
         
            -
              },
         
     | 
| 
       1162 
     | 
    
         
            -
             
     | 
| 
       1163 
     | 
    
         
            -
              findQuery: function(type, query) {
         
     | 
| 
       1164 
     | 
    
         
            -
                var array = DS.AdapterPopulatedRecordArray.create({ type: type, content: Ember.A([]), store: this });
         
     | 
| 
       1165 
     | 
    
         
            -
                var adapter = get(this, '_adapter');
         
     | 
| 
       1166 
     | 
    
         
            -
                if (adapter && adapter.findQuery) { adapter.findQuery(this, type, query, array); }
         
     | 
| 
       1167 
     | 
    
         
            -
                else { throw fmt("Adapter is either null or does not implement `findQuery` method", this); }
         
     | 
| 
       1168 
     | 
    
         
            -
                return array;
         
     | 
| 
       1169 
     | 
    
         
            -
              },
         
     | 
| 
       1170 
     | 
    
         
            -
             
     | 
| 
       1171 
     | 
    
         
            -
              findAll: function(type) {
         
     | 
| 
       1172 
     | 
    
         
            -
             
     | 
| 
       1173 
     | 
    
         
            -
                var typeMap = this.typeMapFor(type),
         
     | 
| 
       1174 
     | 
    
         
            -
                    findAllCache = typeMap.findAllCache;
         
     | 
| 
       1175 
     | 
    
         
            -
             
     | 
| 
       1176 
     | 
    
         
            -
                if (findAllCache) { return findAllCache; }
         
     | 
| 
       1177 
     | 
    
         
            -
             
     | 
| 
       1178 
     | 
    
         
            -
                var array = DS.RecordArray.create({ type: type, content: Ember.A([]), store: this });
         
     | 
| 
       1179 
     | 
    
         
            -
                this.registerRecordArray(array, type);
         
     | 
| 
       1180 
     | 
    
         
            -
             
     | 
| 
       1181 
     | 
    
         
            -
                var adapter = get(this, '_adapter');
         
     | 
| 
       1182 
     | 
    
         
            -
                if (adapter && adapter.findAll) { adapter.findAll(this, type); }
         
     | 
| 
       1183 
     | 
    
         
            -
             
     | 
| 
       1184 
     | 
    
         
            -
                typeMap.findAllCache = array;
         
     | 
| 
       1185 
     | 
    
         
            -
                return array;
         
     | 
| 
       1186 
     | 
    
         
            -
              },
         
     | 
| 
       1187 
     | 
    
         
            -
             
     | 
| 
       1188 
     | 
    
         
            -
              filter: function(type, query, filter) {
         
     | 
| 
       1189 
     | 
    
         
            -
                // allow an optional server query
         
     | 
| 
       1190 
     | 
    
         
            -
                if (arguments.length === 3) {
         
     | 
| 
       1191 
     | 
    
         
            -
                  this.findQuery(type, query);
         
     | 
| 
       1192 
     | 
    
         
            -
                } else if (arguments.length === 2) {
         
     | 
| 
       1193 
     | 
    
         
            -
                  filter = query;
         
     | 
| 
       1194 
     | 
    
         
            -
                }
         
     | 
| 
       1195 
     | 
    
         
            -
             
     | 
| 
       1196 
     | 
    
         
            -
                var array = DS.FilteredRecordArray.create({ type: type, content: Ember.A([]), store: this, filterFunction: filter });
         
     | 
| 
       1197 
     | 
    
         
            -
             
     | 
| 
       1198 
     | 
    
         
            -
                this.registerRecordArray(array, type, filter);
         
     | 
| 
       1199 
     | 
    
         
            -
             
     | 
| 
       1200 
     | 
    
         
            -
                return array;
         
     | 
| 
       1201 
     | 
    
         
            -
              },
         
     | 
| 
       1202 
     | 
    
         
            -
             
     | 
| 
       1203 
     | 
    
         
            -
              // ............
         
     | 
| 
       1204 
     | 
    
         
            -
              // . UPDATING .
         
     | 
| 
       1205 
     | 
    
         
            -
              // ............
         
     | 
| 
       1206 
     | 
    
         
            -
             
     | 
| 
       1207 
     | 
    
         
            -
              hashWasUpdated: function(type, clientId, record) {
         
     | 
| 
       1208 
     | 
    
         
            -
                // Because hash updates are invoked at the end of the run loop,
         
     | 
| 
       1209 
     | 
    
         
            -
                // it is possible that a record might be deleted after its hash
         
     | 
| 
       1210 
     | 
    
         
            -
                // has been modified and this method was scheduled to be called.
         
     | 
| 
       1211 
     | 
    
         
            -
                //
         
     | 
| 
       1212 
     | 
    
         
            -
                // If that's the case, the record would have already been removed
         
     | 
| 
       1213 
     | 
    
         
            -
                // from all record arrays; calling updateRecordArrays would just
         
     | 
| 
       1214 
     | 
    
         
            -
                // add it back. If the record is deleted, just bail. It shouldn't
         
     | 
| 
       1215 
     | 
    
         
            -
                // give us any more trouble after this.
         
     | 
| 
       1216 
     | 
    
         
            -
             
     | 
| 
       1217 
     | 
    
         
            -
                if (get(record, 'isDeleted')) { return; }
         
     | 
| 
       1218 
     | 
    
         
            -
                this.updateRecordArrays(type, clientId, get(record, 'data'));
         
     | 
| 
       1219 
     | 
    
         
            -
              },
         
     | 
| 
       1220 
     | 
    
         
            -
             
     | 
| 
       1221 
     | 
    
         
            -
              // ..............
         
     | 
| 
       1222 
     | 
    
         
            -
              // . PERSISTING .
         
     | 
| 
       1223 
     | 
    
         
            -
              // ..............
         
     | 
| 
       1224 
     | 
    
         
            -
             
     | 
| 
       1225 
     | 
    
         
            -
              commit: function() {
         
     | 
| 
       1226 
     | 
    
         
            -
                var defaultTransaction = get(this, 'defaultTransaction');
         
     | 
| 
       1227 
     | 
    
         
            -
                set(this, 'defaultTransaction', this.transaction());
         
     | 
| 
       1228 
     | 
    
         
            -
             
     | 
| 
       1229 
     | 
    
         
            -
                defaultTransaction.commit();
         
     | 
| 
       1230 
     | 
    
         
            -
              },
         
     | 
| 
       1231 
     | 
    
         
            -
             
     | 
| 
       1232 
     | 
    
         
            -
              didUpdateRecords: function(array, hashes) {
         
     | 
| 
       1233 
     | 
    
         
            -
                if (hashes) {
         
     | 
| 
       1234 
     | 
    
         
            -
                  array.forEach(function(record, idx) {
         
     | 
| 
       1235 
     | 
    
         
            -
                    this.didUpdateRecord(record, hashes[idx]);
         
     | 
| 
       1236 
     | 
    
         
            -
                  }, this);
         
     | 
| 
       1237 
     | 
    
         
            -
                } else {
         
     | 
| 
       1238 
     | 
    
         
            -
                  array.forEach(function(record) {
         
     | 
| 
       1239 
     | 
    
         
            -
                    this.didUpdateRecord(record);
         
     | 
| 
       1240 
     | 
    
         
            -
                  }, this);
         
     | 
| 
       1241 
     | 
    
         
            -
                }
         
     | 
| 
       1242 
     | 
    
         
            -
              },
         
     | 
| 
       1243 
     | 
    
         
            -
             
     | 
| 
       1244 
     | 
    
         
            -
              didUpdateRecord: function(record, hash) {
         
     | 
| 
       1245 
     | 
    
         
            -
                if (hash) {
         
     | 
| 
       1246 
     | 
    
         
            -
                  var clientId = get(record, 'clientId'),
         
     | 
| 
       1247 
     | 
    
         
            -
                      dataCache = this.typeMapFor(record.constructor).cidToHash;
         
     | 
| 
       1248 
     | 
    
         
            -
             
     | 
| 
       1249 
     | 
    
         
            -
                  dataCache[clientId] = hash;
         
     | 
| 
       1250 
     | 
    
         
            -
                  record.send('didChangeData');
         
     | 
| 
       1251 
     | 
    
         
            -
                  record.hashWasUpdated();
         
     | 
| 
       1252 
     | 
    
         
            -
                } else {
         
     | 
| 
       1253 
     | 
    
         
            -
                  record.send('didSaveData');
         
     | 
| 
       1254 
     | 
    
         
            -
                }
         
     | 
| 
       1255 
     | 
    
         
            -
             
     | 
| 
       1256 
     | 
    
         
            -
                record.send('didCommit');
         
     | 
| 
       1257 
     | 
    
         
            -
              },
         
     | 
| 
       1258 
     | 
    
         
            -
             
     | 
| 
       1259 
     | 
    
         
            -
              didDeleteRecords: function(array) {
         
     | 
| 
       1260 
     | 
    
         
            -
                array.forEach(function(record) {
         
     | 
| 
       1261 
     | 
    
         
            -
                  record.send('didCommit');
         
     | 
| 
       1262 
     | 
    
         
            -
                });
         
     | 
| 
       1263 
     | 
    
         
            -
              },
         
     | 
| 
       1264 
     | 
    
         
            -
             
     | 
| 
       1265 
     | 
    
         
            -
              didDeleteRecord: function(record) {
         
     | 
| 
       1266 
     | 
    
         
            -
                record.send('didCommit');
         
     | 
| 
       1267 
     | 
    
         
            -
              },
         
     | 
| 
       1268 
     | 
    
         
            -
             
     | 
| 
       1269 
     | 
    
         
            -
              _didCreateRecord: function(record, hash, typeMap, clientId, primaryKey) {
         
     | 
| 
       1270 
     | 
    
         
            -
                var recordData = get(record, 'data'), id, changes;
         
     | 
| 
       1271 
     | 
    
         
            -
             
     | 
| 
       1272 
     | 
    
         
            -
                if (hash) {
         
     | 
| 
       1273 
     | 
    
         
            -
                  typeMap.cidToHash[clientId] = hash;
         
     | 
| 
       1274 
     | 
    
         
            -
             
     | 
| 
       1275 
     | 
    
         
            -
                  // If the server returns a hash, we assume that the server's version
         
     | 
| 
       1276 
     | 
    
         
            -
                  // of the data supercedes the local changes.
         
     | 
| 
       1277 
     | 
    
         
            -
                  record.beginPropertyChanges();
         
     | 
| 
       1278 
     | 
    
         
            -
                  record.send('didChangeData');
         
     | 
| 
       1279 
     | 
    
         
            -
                  recordData.adapterDidUpdate();
         
     | 
| 
       1280 
     | 
    
         
            -
                  record.hashWasUpdated();
         
     | 
| 
       1281 
     | 
    
         
            -
                  record.endPropertyChanges();
         
     | 
| 
       1282 
     | 
    
         
            -
             
     | 
| 
       1283 
     | 
    
         
            -
                  id = hash[primaryKey];
         
     | 
| 
       1284 
     | 
    
         
            -
             
     | 
| 
       1285 
     | 
    
         
            -
                  typeMap.idToCid[id] = clientId;
         
     | 
| 
       1286 
     | 
    
         
            -
                  this.clientIdToId[clientId] = id;
         
     | 
| 
       1287 
     | 
    
         
            -
                } else {
         
     | 
| 
       1288 
     | 
    
         
            -
                  recordData.commit();
         
     | 
| 
       1289 
     | 
    
         
            -
                }
         
     | 
| 
       1290 
     | 
    
         
            -
             
     | 
| 
       1291 
     | 
    
         
            -
                record.send('didCommit');
         
     | 
| 
       1292 
     | 
    
         
            -
              },
         
     | 
| 
       1293 
     | 
    
         
            -
             
     | 
| 
       1294 
     | 
    
         
            -
             
     | 
| 
       1295 
     | 
    
         
            -
              didCreateRecords: function(type, array, hashes) {
         
     | 
| 
       1296 
     | 
    
         
            -
                var primaryKey = type.proto().primaryKey,
         
     | 
| 
       1297 
     | 
    
         
            -
                    typeMap = this.typeMapFor(type),
         
     | 
| 
       1298 
     | 
    
         
            -
                    clientId;
         
     | 
| 
       1299 
     | 
    
         
            -
             
     | 
| 
       1300 
     | 
    
         
            -
                for (var i=0, l=get(array, 'length'); i<l; i++) {
         
     | 
| 
       1301 
     | 
    
         
            -
                  var record = array[i], hash = hashes[i];
         
     | 
| 
       1302 
     | 
    
         
            -
                  clientId = get(record, 'clientId');
         
     | 
| 
       1303 
     | 
    
         
            -
             
     | 
| 
       1304 
     | 
    
         
            -
                  this._didCreateRecord(record, hash, typeMap, clientId, primaryKey);
         
     | 
| 
       1305 
     | 
    
         
            -
                }
         
     | 
| 
       1306 
     | 
    
         
            -
              },
         
     | 
| 
       1307 
     | 
    
         
            -
             
     | 
| 
       1308 
     | 
    
         
            -
              didCreateRecord: function(record, hash) {
         
     | 
| 
       1309 
     | 
    
         
            -
                var type = record.constructor,
         
     | 
| 
       1310 
     | 
    
         
            -
                    typeMap = this.typeMapFor(type),
         
     | 
| 
       1311 
     | 
    
         
            -
                    clientId, primaryKey;
         
     | 
| 
       1312 
     | 
    
         
            -
             
     | 
| 
       1313 
     | 
    
         
            -
                // The hash is optional, but if it is not provided, the client must have
         
     | 
| 
       1314 
     | 
    
         
            -
                // provided a primary key.
         
     | 
| 
       1315 
     | 
    
         
            -
             
     | 
| 
       1316 
     | 
    
         
            -
                primaryKey = type.proto().primaryKey;
         
     | 
| 
       1317 
     | 
    
         
            -
             
     | 
| 
       1318 
     | 
    
         
            -
                // TODO: Make Ember.assert more flexible
         
     | 
| 
       1319 
     | 
    
         
            -
                if (hash) {
         
     | 
| 
       1320 
     | 
    
         
            -
             
     | 
| 
       1321 
     | 
    
         
            -
                } else {
         
     | 
| 
       1322 
     | 
    
         
            -
             
     | 
| 
       1323 
     | 
    
         
            -
                }
         
     | 
| 
       1324 
     | 
    
         
            -
             
     | 
| 
       1325 
     | 
    
         
            -
                clientId = get(record, 'clientId');
         
     | 
| 
       1326 
     | 
    
         
            -
             
     | 
| 
       1327 
     | 
    
         
            -
                this._didCreateRecord(record, hash, typeMap, clientId, primaryKey);
         
     | 
| 
       1328 
     | 
    
         
            -
              },
         
     | 
| 
       1329 
     | 
    
         
            -
             
     | 
| 
       1330 
     | 
    
         
            -
              recordWasInvalid: function(record, errors) {
         
     | 
| 
       1331 
     | 
    
         
            -
                record.send('becameInvalid', errors);
         
     | 
| 
       1332 
     | 
    
         
            -
              },
         
     | 
| 
       1333 
     | 
    
         
            -
             
     | 
| 
       1334 
     | 
    
         
            -
              // .................
         
     | 
| 
       1335 
     | 
    
         
            -
              // . RECORD ARRAYS .
         
     | 
| 
       1336 
     | 
    
         
            -
              // .................
         
     | 
| 
       1337 
     | 
    
         
            -
             
     | 
| 
       1338 
     | 
    
         
            -
              registerRecordArray: function(array, type, filter) {
         
     | 
| 
       1339 
     | 
    
         
            -
                var recordArrays = this.typeMapFor(type).recordArrays;
         
     | 
| 
       1340 
     | 
    
         
            -
             
     | 
| 
       1341 
     | 
    
         
            -
                recordArrays.push(array);
         
     | 
| 
       1342 
     | 
    
         
            -
             
     | 
| 
       1343 
     | 
    
         
            -
                this.updateRecordArrayFilter(array, type, filter);
         
     | 
| 
       1344 
     | 
    
         
            -
              },
         
     | 
| 
       1345 
     | 
    
         
            -
             
     | 
| 
       1346 
     | 
    
         
            -
              createManyArray: function(type, clientIds) {
         
     | 
| 
       1347 
     | 
    
         
            -
                var array = DS.ManyArray.create({ type: type, content: clientIds, store: this });
         
     | 
| 
       1348 
     | 
    
         
            -
             
     | 
| 
       1349 
     | 
    
         
            -
                clientIds.forEach(function(clientId) {
         
     | 
| 
       1350 
     | 
    
         
            -
                  var recordArrays = this.recordArraysForClientId(clientId);
         
     | 
| 
       1351 
     | 
    
         
            -
                  recordArrays.add(array);
         
     | 
| 
       1352 
     | 
    
         
            -
                }, this);
         
     | 
| 
       1353 
     | 
    
         
            -
             
     | 
| 
       1354 
     | 
    
         
            -
                return array;
         
     | 
| 
       1355 
     | 
    
         
            -
              },
         
     | 
| 
       1356 
     | 
    
         
            -
             
     | 
| 
       1357 
     | 
    
         
            -
              updateRecordArrayFilter: function(array, type, filter) {
         
     | 
| 
       1358 
     | 
    
         
            -
                var typeMap = this.typeMapFor(type),
         
     | 
| 
       1359 
     | 
    
         
            -
                    dataCache = typeMap.cidToHash,
         
     | 
| 
       1360 
     | 
    
         
            -
                    clientIds = typeMap.clientIds,
         
     | 
| 
       1361 
     | 
    
         
            -
                    clientId, hash, proxy;
         
     | 
| 
       1362 
     | 
    
         
            -
             
     | 
| 
       1363 
     | 
    
         
            -
                var recordCache = get(this, 'recordCache'), record;
         
     | 
| 
       1364 
     | 
    
         
            -
             
     | 
| 
       1365 
     | 
    
         
            -
                for (var i=0, l=clientIds.length; i<l; i++) {
         
     | 
| 
       1366 
     | 
    
         
            -
                  clientId = clientIds[i];
         
     | 
| 
       1367 
     | 
    
         
            -
             
     | 
| 
       1368 
     | 
    
         
            -
                  hash = dataCache[clientId];
         
     | 
| 
       1369 
     | 
    
         
            -
                  if (typeof hash === 'object') {
         
     | 
| 
       1370 
     | 
    
         
            -
                    if (record = recordCache[clientId]) {
         
     | 
| 
       1371 
     | 
    
         
            -
                      proxy = get(record, 'data');
         
     | 
| 
       1372 
     | 
    
         
            -
                    } else {
         
     | 
| 
       1373 
     | 
    
         
            -
                      DATA_PROXY.savedData = hash;
         
     | 
| 
       1374 
     | 
    
         
            -
                      proxy = DATA_PROXY;
         
     | 
| 
       1375 
     | 
    
         
            -
                    }
         
     | 
| 
       1376 
     | 
    
         
            -
             
     | 
| 
       1377 
     | 
    
         
            -
                    this.updateRecordArray(array, filter, type, clientId, proxy);
         
     | 
| 
       1378 
     | 
    
         
            -
                  }
         
     | 
| 
       1379 
     | 
    
         
            -
                }
         
     | 
| 
       1380 
     | 
    
         
            -
              },
         
     | 
| 
       1381 
     | 
    
         
            -
             
     | 
| 
       1382 
     | 
    
         
            -
              updateRecordArrays: function(type, clientId, dataProxy) {
         
     | 
| 
       1383 
     | 
    
         
            -
                var recordArrays = this.typeMapFor(type).recordArrays,
         
     | 
| 
       1384 
     | 
    
         
            -
                    filter;
         
     | 
| 
       1385 
     | 
    
         
            -
             
     | 
| 
       1386 
     | 
    
         
            -
                recordArrays.forEach(function(array) {
         
     | 
| 
       1387 
     | 
    
         
            -
                  filter = get(array, 'filterFunction');
         
     | 
| 
       1388 
     | 
    
         
            -
                  this.updateRecordArray(array, filter, type, clientId, dataProxy);
         
     | 
| 
       1389 
     | 
    
         
            -
                }, this);
         
     | 
| 
       1390 
     | 
    
         
            -
              },
         
     | 
| 
       1391 
     | 
    
         
            -
             
     | 
| 
       1392 
     | 
    
         
            -
              updateRecordArray: function(array, filter, type, clientId, dataProxy) {
         
     | 
| 
       1393 
     | 
    
         
            -
                var shouldBeInArray;
         
     | 
| 
       1394 
     | 
    
         
            -
             
     | 
| 
       1395 
     | 
    
         
            -
                if (!filter) {
         
     | 
| 
       1396 
     | 
    
         
            -
                  shouldBeInArray = true;
         
     | 
| 
       1397 
     | 
    
         
            -
                } else {
         
     | 
| 
       1398 
     | 
    
         
            -
                  shouldBeInArray = filter(dataProxy);
         
     | 
| 
       1399 
     | 
    
         
            -
                }
         
     | 
| 
       1400 
     | 
    
         
            -
             
     | 
| 
       1401 
     | 
    
         
            -
                var content = get(array, 'content');
         
     | 
| 
       1402 
     | 
    
         
            -
                var alreadyInArray = content.indexOf(clientId) !== -1;
         
     | 
| 
       1403 
     | 
    
         
            -
             
     | 
| 
       1404 
     | 
    
         
            -
                var recordArrays = this.recordArraysForClientId(clientId);
         
     | 
| 
       1405 
     | 
    
         
            -
             
     | 
| 
       1406 
     | 
    
         
            -
                if (shouldBeInArray && !alreadyInArray) {
         
     | 
| 
       1407 
     | 
    
         
            -
                  recordArrays.add(array);
         
     | 
| 
       1408 
     | 
    
         
            -
                  content.pushObject(clientId);
         
     | 
| 
       1409 
     | 
    
         
            -
                } else if (!shouldBeInArray && alreadyInArray) {
         
     | 
| 
       1410 
     | 
    
         
            -
                  recordArrays.remove(array);
         
     | 
| 
       1411 
     | 
    
         
            -
                  content.removeObject(clientId);
         
     | 
| 
       1412 
     | 
    
         
            -
                }
         
     | 
| 
       1413 
     | 
    
         
            -
              },
         
     | 
| 
       1414 
     | 
    
         
            -
             
     | 
| 
       1415 
     | 
    
         
            -
              removeFromRecordArrays: function(record) {
         
     | 
| 
       1416 
     | 
    
         
            -
                var clientId = get(record, 'clientId');
         
     | 
| 
       1417 
     | 
    
         
            -
                var recordArrays = this.recordArraysForClientId(clientId);
         
     | 
| 
       1418 
     | 
    
         
            -
             
     | 
| 
       1419 
     | 
    
         
            -
                recordArrays.forEach(function(array) {
         
     | 
| 
       1420 
     | 
    
         
            -
                  var content = get(array, 'content');
         
     | 
| 
       1421 
     | 
    
         
            -
                  content.removeObject(clientId);
         
     | 
| 
       1422 
     | 
    
         
            -
                });
         
     | 
| 
       1423 
     | 
    
         
            -
              },
         
     | 
| 
       1424 
     | 
    
         
            -
             
     | 
| 
       1425 
     | 
    
         
            -
              // ............
         
     | 
| 
       1426 
     | 
    
         
            -
              // . INDEXING .
         
     | 
| 
       1427 
     | 
    
         
            -
              // ............
         
     | 
| 
       1428 
     | 
    
         
            -
             
     | 
| 
       1429 
     | 
    
         
            -
              recordArraysForClientId: function(clientId) {
         
     | 
| 
       1430 
     | 
    
         
            -
                var recordArrays = get(this, 'recordArraysByClientId');
         
     | 
| 
       1431 
     | 
    
         
            -
                var ret = recordArrays[clientId];
         
     | 
| 
       1432 
     | 
    
         
            -
             
     | 
| 
       1433 
     | 
    
         
            -
                if (!ret) {
         
     | 
| 
       1434 
     | 
    
         
            -
                  ret = recordArrays[clientId] = Ember.OrderedSet.create();
         
     | 
| 
       1435 
     | 
    
         
            -
                }
         
     | 
| 
       1436 
     | 
    
         
            -
             
     | 
| 
       1437 
     | 
    
         
            -
                return ret;
         
     | 
| 
       1438 
     | 
    
         
            -
              },
         
     | 
| 
       1439 
     | 
    
         
            -
             
     | 
| 
       1440 
     | 
    
         
            -
              typeMapFor: function(type) {
         
     | 
| 
       1441 
     | 
    
         
            -
                var typeMaps = get(this, 'typeMaps');
         
     | 
| 
       1442 
     | 
    
         
            -
                var guidForType = Ember.guidFor(type);
         
     | 
| 
       1443 
     | 
    
         
            -
             
     | 
| 
       1444 
     | 
    
         
            -
                var typeMap = typeMaps[guidForType];
         
     | 
| 
       1445 
     | 
    
         
            -
             
     | 
| 
       1446 
     | 
    
         
            -
                if (typeMap) {
         
     | 
| 
       1447 
     | 
    
         
            -
                  return typeMap;
         
     | 
| 
       1448 
     | 
    
         
            -
                } else {
         
     | 
| 
       1449 
     | 
    
         
            -
                  return (typeMaps[guidForType] =
         
     | 
| 
       1450 
     | 
    
         
            -
                    {
         
     | 
| 
       1451 
     | 
    
         
            -
                      idToCid: {},
         
     | 
| 
       1452 
     | 
    
         
            -
                      clientIds: [],
         
     | 
| 
       1453 
     | 
    
         
            -
                      cidToHash: {},
         
     | 
| 
       1454 
     | 
    
         
            -
                      recordArrays: []
         
     | 
| 
       1455 
     | 
    
         
            -
                  });
         
     | 
| 
       1456 
     | 
    
         
            -
                }
         
     | 
| 
       1457 
     | 
    
         
            -
              },
         
     | 
| 
       1458 
     | 
    
         
            -
             
     | 
| 
       1459 
     | 
    
         
            -
              /** @private
         
     | 
| 
       1460 
     | 
    
         
            -
             
     | 
| 
       1461 
     | 
    
         
            -
                For a given type and id combination, returns the client id used by the store.
         
     | 
| 
       1462 
     | 
    
         
            -
                If no client id has been assigned yet, one will be created and returned.
         
     | 
| 
       1463 
     | 
    
         
            -
             
     | 
| 
       1464 
     | 
    
         
            -
                @param {DS.Model} type
         
     | 
| 
       1465 
     | 
    
         
            -
                @param {String|Number} id
         
     | 
| 
       1466 
     | 
    
         
            -
              */
         
     | 
| 
       1467 
     | 
    
         
            -
              clientIdForId: function(type, id) {
         
     | 
| 
       1468 
     | 
    
         
            -
                var clientId = this.typeMapFor(type).idToCid[id];
         
     | 
| 
       1469 
     | 
    
         
            -
             
     | 
| 
       1470 
     | 
    
         
            -
                if (clientId !== undefined) { return clientId; }
         
     | 
| 
       1471 
     | 
    
         
            -
             
     | 
| 
       1472 
     | 
    
         
            -
                return this.pushHash(UNLOADED, id, type);
         
     | 
| 
       1473 
     | 
    
         
            -
              },
         
     | 
| 
       1474 
     | 
    
         
            -
             
     | 
| 
       1475 
     | 
    
         
            -
              // ................
         
     | 
| 
       1476 
     | 
    
         
            -
              // . LOADING DATA .
         
     | 
| 
       1477 
     | 
    
         
            -
              // ................
         
     | 
| 
       1478 
     | 
    
         
            -
             
     | 
| 
       1479 
     | 
    
         
            -
              /**
         
     | 
| 
       1480 
     | 
    
         
            -
                Load a new data hash into the store for a given id and type combination.
         
     | 
| 
       1481 
     | 
    
         
            -
                If data for that record had been loaded previously, the new information
         
     | 
| 
       1482 
     | 
    
         
            -
                overwrites the old.
         
     | 
| 
       1483 
     | 
    
         
            -
             
     | 
| 
       1484 
     | 
    
         
            -
                If the record you are loading data for has outstanding changes that have not
         
     | 
| 
       1485 
     | 
    
         
            -
                yet been saved, an exception will be thrown.
         
     | 
| 
       1486 
     | 
    
         
            -
             
     | 
| 
       1487 
     | 
    
         
            -
                @param {DS.Model} type
         
     | 
| 
       1488 
     | 
    
         
            -
                @param {String|Number} id
         
     | 
| 
       1489 
     | 
    
         
            -
                @param {Object} hash the data hash to load
         
     | 
| 
       1490 
     | 
    
         
            -
              */
         
     | 
| 
       1491 
     | 
    
         
            -
              load: function(type, id, hash) {
         
     | 
| 
       1492 
     | 
    
         
            -
                if (hash === undefined) {
         
     | 
| 
       1493 
     | 
    
         
            -
                  hash = id;
         
     | 
| 
       1494 
     | 
    
         
            -
                  var primaryKey = type.proto().primaryKey;
         
     | 
| 
       1495 
     | 
    
         
            -
             
     | 
| 
       1496 
     | 
    
         
            -
                  id = hash[primaryKey];
         
     | 
| 
       1497 
     | 
    
         
            -
                }
         
     | 
| 
       1498 
     | 
    
         
            -
             
     | 
| 
       1499 
     | 
    
         
            -
                var typeMap = this.typeMapFor(type),
         
     | 
| 
       1500 
     | 
    
         
            -
                    dataCache = typeMap.cidToHash,
         
     | 
| 
       1501 
     | 
    
         
            -
                    clientId = typeMap.idToCid[id],
         
     | 
| 
       1502 
     | 
    
         
            -
                    recordCache = get(this, 'recordCache');
         
     | 
| 
       1503 
     | 
    
         
            -
             
     | 
| 
       1504 
     | 
    
         
            -
                if (clientId !== undefined) {
         
     | 
| 
       1505 
     | 
    
         
            -
                  dataCache[clientId] = hash;
         
     | 
| 
       1506 
     | 
    
         
            -
             
     | 
| 
       1507 
     | 
    
         
            -
                  var record = recordCache[clientId];
         
     | 
| 
       1508 
     | 
    
         
            -
                  if (record) {
         
     | 
| 
       1509 
     | 
    
         
            -
                    record.send('didChangeData');
         
     | 
| 
       1510 
     | 
    
         
            -
                  }
         
     | 
| 
       1511 
     | 
    
         
            -
                } else {
         
     | 
| 
       1512 
     | 
    
         
            -
                  clientId = this.pushHash(hash, id, type);
         
     | 
| 
       1513 
     | 
    
         
            -
                }
         
     | 
| 
       1514 
     | 
    
         
            -
             
     | 
| 
       1515 
     | 
    
         
            -
                DATA_PROXY.savedData = hash;
         
     | 
| 
       1516 
     | 
    
         
            -
                this.updateRecordArrays(type, clientId, DATA_PROXY);
         
     | 
| 
       1517 
     | 
    
         
            -
             
     | 
| 
       1518 
     | 
    
         
            -
                return { id: id, clientId: clientId };
         
     | 
| 
       1519 
     | 
    
         
            -
              },
         
     | 
| 
       1520 
     | 
    
         
            -
             
     | 
| 
       1521 
     | 
    
         
            -
              loadMany: function(type, ids, hashes) {
         
     | 
| 
       1522 
     | 
    
         
            -
                var clientIds = Ember.A([]);
         
     | 
| 
       1523 
     | 
    
         
            -
             
     | 
| 
       1524 
     | 
    
         
            -
                if (hashes === undefined) {
         
     | 
| 
       1525 
     | 
    
         
            -
                  hashes = ids;
         
     | 
| 
       1526 
     | 
    
         
            -
                  ids = [];
         
     | 
| 
       1527 
     | 
    
         
            -
                  var primaryKey = type.proto().primaryKey;
         
     | 
| 
       1528 
     | 
    
         
            -
             
     | 
| 
       1529 
     | 
    
         
            -
                  ids = Ember.ArrayUtils.map(hashes, function(hash) {
         
     | 
| 
       1530 
     | 
    
         
            -
                    return hash[primaryKey];
         
     | 
| 
       1531 
     | 
    
         
            -
                  });
         
     | 
| 
       1532 
     | 
    
         
            -
                }
         
     | 
| 
       1533 
     | 
    
         
            -
             
     | 
| 
       1534 
     | 
    
         
            -
                for (var i=0, l=get(ids, 'length'); i<l; i++) {
         
     | 
| 
       1535 
     | 
    
         
            -
                  var loaded = this.load(type, ids[i], hashes[i]);
         
     | 
| 
       1536 
     | 
    
         
            -
                  clientIds.pushObject(loaded.clientId);
         
     | 
| 
       1537 
     | 
    
         
            -
                }
         
     | 
| 
       1538 
     | 
    
         
            -
             
     | 
| 
       1539 
     | 
    
         
            -
                return { clientIds: clientIds, ids: ids };
         
     | 
| 
       1540 
     | 
    
         
            -
              },
         
     | 
| 
       1541 
     | 
    
         
            -
             
     | 
| 
       1542 
     | 
    
         
            -
              /** @private
         
     | 
| 
       1543 
     | 
    
         
            -
             
     | 
| 
       1544 
     | 
    
         
            -
                Stores a data hash for the specified type and id combination and returns
         
     | 
| 
       1545 
     | 
    
         
            -
                the client id.
         
     | 
| 
       1546 
     | 
    
         
            -
             
     | 
| 
       1547 
     | 
    
         
            -
                @param {Object} hash
         
     | 
| 
       1548 
     | 
    
         
            -
                @param {String|Number} id
         
     | 
| 
       1549 
     | 
    
         
            -
                @param {DS.Model} type
         
     | 
| 
       1550 
     | 
    
         
            -
                @returns {Number}
         
     | 
| 
       1551 
     | 
    
         
            -
              */
         
     | 
| 
       1552 
     | 
    
         
            -
              pushHash: function(hash, id, type) {
         
     | 
| 
       1553 
     | 
    
         
            -
                var typeMap = this.typeMapFor(type);
         
     | 
| 
       1554 
     | 
    
         
            -
             
     | 
| 
       1555 
     | 
    
         
            -
                var idToClientIdMap = typeMap.idToCid,
         
     | 
| 
       1556 
     | 
    
         
            -
                    clientIdToIdMap = this.clientIdToId,
         
     | 
| 
       1557 
     | 
    
         
            -
                    clientIds = typeMap.clientIds,
         
     | 
| 
       1558 
     | 
    
         
            -
                    dataCache = typeMap.cidToHash;
         
     | 
| 
       1559 
     | 
    
         
            -
             
     | 
| 
       1560 
     | 
    
         
            -
                var clientId = ++this.clientIdCounter;
         
     | 
| 
       1561 
     | 
    
         
            -
             
     | 
| 
       1562 
     | 
    
         
            -
                dataCache[clientId] = hash;
         
     | 
| 
       1563 
     | 
    
         
            -
             
     | 
| 
       1564 
     | 
    
         
            -
                // if we're creating an item, this process will be done
         
     | 
| 
       1565 
     | 
    
         
            -
                // later, once the object has been persisted.
         
     | 
| 
       1566 
     | 
    
         
            -
                if (id) {
         
     | 
| 
       1567 
     | 
    
         
            -
                  idToClientIdMap[id] = clientId;
         
     | 
| 
       1568 
     | 
    
         
            -
                  clientIdToIdMap[clientId] = id;
         
     | 
| 
       1569 
     | 
    
         
            -
                }
         
     | 
| 
       1570 
     | 
    
         
            -
             
     | 
| 
       1571 
     | 
    
         
            -
                clientIds.push(clientId);
         
     | 
| 
       1572 
     | 
    
         
            -
             
     | 
| 
       1573 
     | 
    
         
            -
                return clientId;
         
     | 
| 
       1574 
     | 
    
         
            -
              },
         
     | 
| 
       1575 
     | 
    
         
            -
             
     | 
| 
       1576 
     | 
    
         
            -
              // ..........................
         
     | 
| 
       1577 
     | 
    
         
            -
              // . RECORD MATERIALIZATION .
         
     | 
| 
       1578 
     | 
    
         
            -
              // ..........................
         
     | 
| 
       1579 
     | 
    
         
            -
             
     | 
| 
       1580 
     | 
    
         
            -
              materializeRecord: function(type, clientId) {
         
     | 
| 
       1581 
     | 
    
         
            -
                var record;
         
     | 
| 
       1582 
     | 
    
         
            -
             
     | 
| 
       1583 
     | 
    
         
            -
                get(this, 'recordCache')[clientId] = record = type._create({
         
     | 
| 
       1584 
     | 
    
         
            -
                  store: this,
         
     | 
| 
       1585 
     | 
    
         
            -
                  clientId: clientId
         
     | 
| 
       1586 
     | 
    
         
            -
                });
         
     | 
| 
       1587 
     | 
    
         
            -
             
     | 
| 
       1588 
     | 
    
         
            -
                get(this, 'defaultTransaction').adoptRecord(record);
         
     | 
| 
       1589 
     | 
    
         
            -
             
     | 
| 
       1590 
     | 
    
         
            -
                record.send('loadingData');
         
     | 
| 
       1591 
     | 
    
         
            -
                return record;
         
     | 
| 
       1592 
     | 
    
         
            -
              },
         
     | 
| 
       1593 
     | 
    
         
            -
             
     | 
| 
       1594 
     | 
    
         
            -
              destroy: function() {
         
     | 
| 
       1595 
     | 
    
         
            -
                if (get(DS, 'defaultStore') === this) {
         
     | 
| 
       1596 
     | 
    
         
            -
                  set(DS, 'defaultStore', null);
         
     | 
| 
       1597 
     | 
    
         
            -
                }
         
     | 
| 
       1598 
     | 
    
         
            -
             
     | 
| 
       1599 
     | 
    
         
            -
                return this._super();
         
     | 
| 
       1600 
     | 
    
         
            -
              }
         
     | 
| 
       1601 
     | 
    
         
            -
            });
         
     | 
| 
       1602 
     | 
    
         
            -
             
     | 
| 
       1603 
     | 
    
         
            -
            })();
         
     | 
| 
       1604 
     | 
    
         
            -
             
     | 
| 
       1605 
     | 
    
         
            -
             
     | 
| 
       1606 
     | 
    
         
            -
             
     | 
| 
       1607 
     | 
    
         
            -
            (function() {
         
     | 
| 
       1608 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set, getPath = Ember.getPath, guidFor = Ember.guidFor;
         
     | 
| 
       1609 
     | 
    
         
            -
             
     | 
| 
       1610 
     | 
    
         
            -
            /**
         
     | 
| 
       1611 
     | 
    
         
            -
              This file encapsulates the various states that a record can transition
         
     | 
| 
       1612 
     | 
    
         
            -
              through during its lifecycle.
         
     | 
| 
       1613 
     | 
    
         
            -
             
     | 
| 
       1614 
     | 
    
         
            -
              ### State Manager
         
     | 
| 
       1615 
     | 
    
         
            -
             
     | 
| 
       1616 
     | 
    
         
            -
              A record's state manager explicitly tracks what state a record is in
         
     | 
| 
       1617 
     | 
    
         
            -
              at any given time. For instance, if a record is newly created and has
         
     | 
| 
       1618 
     | 
    
         
            -
              not yet been sent to the adapter to be saved, it would be in the
         
     | 
| 
       1619 
     | 
    
         
            -
              `created.uncommitted` state.  If a record has had local modifications
         
     | 
| 
       1620 
     | 
    
         
            -
              made to it that are in the process of being saved, the record would be
         
     | 
| 
       1621 
     | 
    
         
            -
              in the `updated.inFlight` state. (These state paths will be explained
         
     | 
| 
       1622 
     | 
    
         
            -
              in more detail below.)
         
     | 
| 
       1623 
     | 
    
         
            -
             
     | 
| 
       1624 
     | 
    
         
            -
              Events are sent by the record or its store to the record's state manager.
         
     | 
| 
       1625 
     | 
    
         
            -
              How the state manager reacts to these events is dependent on which state
         
     | 
| 
       1626 
     | 
    
         
            -
              it is in. In some states, certain events will be invalid and will cause
         
     | 
| 
       1627 
     | 
    
         
            -
              an exception to be raised.
         
     | 
| 
       1628 
     | 
    
         
            -
             
     | 
| 
       1629 
     | 
    
         
            -
              States are hierarchical. For example, a record can be in the
         
     | 
| 
       1630 
     | 
    
         
            -
              `deleted.start` state, then transition into the `deleted.inFlight` state.
         
     | 
| 
       1631 
     | 
    
         
            -
              If a child state does not implement an event handler, the state manager
         
     | 
| 
       1632 
     | 
    
         
            -
              will attempt to invoke the event on all parent states until the root state is
         
     | 
| 
       1633 
     | 
    
         
            -
              reached. The state hierarchy of a record is described in terms of a path
         
     | 
| 
       1634 
     | 
    
         
            -
              string. You can determine a record's current state by getting its manager's
         
     | 
| 
       1635 
     | 
    
         
            -
              current state path:
         
     | 
| 
       1636 
     | 
    
         
            -
             
     | 
| 
       1637 
     | 
    
         
            -
                    record.getPath('stateManager.currentState.path');
         
     | 
| 
       1638 
     | 
    
         
            -
                    //=> "created.uncommitted"
         
     | 
| 
       1639 
     | 
    
         
            -
             
     | 
| 
       1640 
     | 
    
         
            -
              The `DS.Model` states are themselves stateless. What we mean is that,
         
     | 
| 
       1641 
     | 
    
         
            -
              though each instance of a record also has a unique instance of a
         
     | 
| 
       1642 
     | 
    
         
            -
              `DS.StateManager`, the hierarchical states that each of *those* points
         
     | 
| 
       1643 
     | 
    
         
            -
              to is a shared data structure. For performance reasons, instead of each
         
     | 
| 
       1644 
     | 
    
         
            -
              record getting its own copy of the hierarchy of states, each state
         
     | 
| 
       1645 
     | 
    
         
            -
              manager points to this global, immutable shared instance. How does a
         
     | 
| 
       1646 
     | 
    
         
            -
              state know which record it should be acting on?  We pass a reference to
         
     | 
| 
       1647 
     | 
    
         
            -
              the current state manager as the first parameter to every method invoked
         
     | 
| 
       1648 
     | 
    
         
            -
              on a state.
         
     | 
| 
       1649 
     | 
    
         
            -
             
     | 
| 
       1650 
     | 
    
         
            -
              The state manager passed as the first parameter is where you should stash
         
     | 
| 
       1651 
     | 
    
         
            -
              state about the record if needed; you should never store data on the state
         
     | 
| 
       1652 
     | 
    
         
            -
              object itself. If you need access to the record being acted on, you can
         
     | 
| 
       1653 
     | 
    
         
            -
              retrieve the state manager's `record` property. For example, if you had
         
     | 
| 
       1654 
     | 
    
         
            -
              an event handler `myEvent`:
         
     | 
| 
       1655 
     | 
    
         
            -
             
     | 
| 
       1656 
     | 
    
         
            -
                  myEvent: function(manager) {
         
     | 
| 
       1657 
     | 
    
         
            -
                    var record = manager.get('record');
         
     | 
| 
       1658 
     | 
    
         
            -
                    record.doSomething();
         
     | 
| 
       1659 
     | 
    
         
            -
                  }
         
     | 
| 
       1660 
     | 
    
         
            -
             
     | 
| 
       1661 
     | 
    
         
            -
              For more information about state managers in general, see the Ember.js
         
     | 
| 
       1662 
     | 
    
         
            -
              documentation on `Ember.StateManager`.
         
     | 
| 
       1663 
     | 
    
         
            -
             
     | 
| 
       1664 
     | 
    
         
            -
              ### Events, Flags, and Transitions
         
     | 
| 
       1665 
     | 
    
         
            -
             
     | 
| 
       1666 
     | 
    
         
            -
              A state may implement zero or more events, flags, or transitions.
         
     | 
| 
       1667 
     | 
    
         
            -
             
     | 
| 
       1668 
     | 
    
         
            -
              #### Events
         
     | 
| 
       1669 
     | 
    
         
            -
             
     | 
| 
       1670 
     | 
    
         
            -
              Events are named functions that are invoked when sent to a record. The
         
     | 
| 
       1671 
     | 
    
         
            -
              state manager will first look for a method with the given name on the
         
     | 
| 
       1672 
     | 
    
         
            -
              current state. If no method is found, it will search the current state's
         
     | 
| 
       1673 
     | 
    
         
            -
              parent, and then its grandparent, and so on until reaching the top of
         
     | 
| 
       1674 
     | 
    
         
            -
              the hierarchy. If the root is reached without an event handler being found,
         
     | 
| 
       1675 
     | 
    
         
            -
              an exception will be raised. This can be very helpful when debugging new
         
     | 
| 
       1676 
     | 
    
         
            -
              features.
         
     | 
| 
       1677 
     | 
    
         
            -
             
     | 
| 
       1678 
     | 
    
         
            -
              Here's an example implementation of a state with a `myEvent` event handler:
         
     | 
| 
       1679 
     | 
    
         
            -
             
     | 
| 
       1680 
     | 
    
         
            -
                  aState: DS.State.create({
         
     | 
| 
       1681 
     | 
    
         
            -
                    myEvent: function(manager, param) {
         
     | 
| 
       1682 
     | 
    
         
            -
                      console.log("Received myEvent with "+param);
         
     | 
| 
       1683 
     | 
    
         
            -
                    }
         
     | 
| 
       1684 
     | 
    
         
            -
                  })
         
     | 
| 
       1685 
     | 
    
         
            -
             
     | 
| 
       1686 
     | 
    
         
            -
              To trigger this event:
         
     | 
| 
       1687 
     | 
    
         
            -
             
     | 
| 
       1688 
     | 
    
         
            -
                  record.send('myEvent', 'foo');
         
     | 
| 
       1689 
     | 
    
         
            -
                  //=> "Received myEvent with foo"
         
     | 
| 
       1690 
     | 
    
         
            -
             
     | 
| 
       1691 
     | 
    
         
            -
              Note that an optional parameter can be sent to a record's `send()` method,
         
     | 
| 
       1692 
     | 
    
         
            -
              which will be passed as the second parameter to the event handler.
         
     | 
| 
       1693 
     | 
    
         
            -
             
     | 
| 
       1694 
     | 
    
         
            -
              Events should transition to a different state if appropriate. This can be
         
     | 
| 
       1695 
     | 
    
         
            -
              done by calling the state manager's `goToState()` method with a path to the
         
     | 
| 
       1696 
     | 
    
         
            -
              desired state. The state manager will attempt to resolve the state path
         
     | 
| 
       1697 
     | 
    
         
            -
              relative to the current state. If no state is found at that path, it will
         
     | 
| 
       1698 
     | 
    
         
            -
              attempt to resolve it relative to the current state's parent, and then its
         
     | 
| 
       1699 
     | 
    
         
            -
              parent, and so on until the root is reached. For example, imagine a hierarchy
         
     | 
| 
       1700 
     | 
    
         
            -
              like this:
         
     | 
| 
       1701 
     | 
    
         
            -
             
     | 
| 
       1702 
     | 
    
         
            -
                  * created
         
     | 
| 
       1703 
     | 
    
         
            -
                    * start <-- currentState
         
     | 
| 
       1704 
     | 
    
         
            -
                    * inFlight
         
     | 
| 
       1705 
     | 
    
         
            -
                  * updated
         
     | 
| 
       1706 
     | 
    
         
            -
                    * inFlight
         
     | 
| 
       1707 
     | 
    
         
            -
             
     | 
| 
       1708 
     | 
    
         
            -
              If we are currently in the `start` state, calling
         
     | 
| 
       1709 
     | 
    
         
            -
              `goToState('inFlight')` would transition to the `created.inFlight` state,
         
     | 
| 
       1710 
     | 
    
         
            -
              while calling `goToState('updated.inFlight')` would transition to
         
     | 
| 
       1711 
     | 
    
         
            -
              the `updated.inFlight` state.
         
     | 
| 
       1712 
     | 
    
         
            -
             
     | 
| 
       1713 
     | 
    
         
            -
              Remember that *only events* should ever cause a state transition. You should
         
     | 
| 
       1714 
     | 
    
         
            -
              never call `goToState()` from outside a state's event handler. If you are
         
     | 
| 
       1715 
     | 
    
         
            -
              tempted to do so, create a new event and send that to the state manager.
         
     | 
| 
       1716 
     | 
    
         
            -
             
     | 
| 
       1717 
     | 
    
         
            -
              #### Flags
         
     | 
| 
       1718 
     | 
    
         
            -
             
     | 
| 
       1719 
     | 
    
         
            -
              Flags are Boolean values that can be used to introspect a record's current
         
     | 
| 
       1720 
     | 
    
         
            -
              state in a more user-friendly way than examining its state path. For example,
         
     | 
| 
       1721 
     | 
    
         
            -
              instead of doing this:
         
     | 
| 
       1722 
     | 
    
         
            -
             
     | 
| 
       1723 
     | 
    
         
            -
                  var statePath = record.getPath('stateManager.currentState.path');
         
     | 
| 
       1724 
     | 
    
         
            -
                  if (statePath === 'created.inFlight') {
         
     | 
| 
       1725 
     | 
    
         
            -
                    doSomething();
         
     | 
| 
       1726 
     | 
    
         
            -
                  }
         
     | 
| 
       1727 
     | 
    
         
            -
             
     | 
| 
       1728 
     | 
    
         
            -
              You can say:
         
     | 
| 
       1729 
     | 
    
         
            -
             
     | 
| 
       1730 
     | 
    
         
            -
                  if (record.get('isNew') && record.get('isSaving')) {
         
     | 
| 
       1731 
     | 
    
         
            -
                    doSomething();
         
     | 
| 
       1732 
     | 
    
         
            -
                  }
         
     | 
| 
       1733 
     | 
    
         
            -
             
     | 
| 
       1734 
     | 
    
         
            -
              If your state does not set a value for a given flag, the value will
         
     | 
| 
       1735 
     | 
    
         
            -
              be inherited from its parent (or the first place in the state hierarchy
         
     | 
| 
       1736 
     | 
    
         
            -
              where it is defined).
         
     | 
| 
       1737 
     | 
    
         
            -
             
     | 
| 
       1738 
     | 
    
         
            -
              The current set of flags are defined below. If you want to add a new flag,
         
     | 
| 
       1739 
     | 
    
         
            -
              in addition to the area below, you will also need to declare it in the
         
     | 
| 
       1740 
     | 
    
         
            -
              `DS.Model` class.
         
     | 
| 
       1741 
     | 
    
         
            -
             
     | 
| 
       1742 
     | 
    
         
            -
              #### Transitions
         
     | 
| 
       1743 
     | 
    
         
            -
             
     | 
| 
       1744 
     | 
    
         
            -
              Transitions are like event handlers but are called automatically upon
         
     | 
| 
       1745 
     | 
    
         
            -
              entering or exiting a state. To implement a transition, just call a method
         
     | 
| 
       1746 
     | 
    
         
            -
              either `enter` or `exit`:
         
     | 
| 
       1747 
     | 
    
         
            -
             
     | 
| 
       1748 
     | 
    
         
            -
                  myState: DS.State.create({
         
     | 
| 
       1749 
     | 
    
         
            -
                    // Gets called automatically when entering
         
     | 
| 
       1750 
     | 
    
         
            -
                    // this state.
         
     | 
| 
       1751 
     | 
    
         
            -
                    enter: function(manager) {
         
     | 
| 
       1752 
     | 
    
         
            -
                      console.log("Entered myState");
         
     | 
| 
       1753 
     | 
    
         
            -
                    }
         
     | 
| 
       1754 
     | 
    
         
            -
                  })
         
     | 
| 
       1755 
     | 
    
         
            -
             
     | 
| 
       1756 
     | 
    
         
            -
               Note that enter and exit events are called once per transition. If the
         
     | 
| 
       1757 
     | 
    
         
            -
               current state changes, but changes to another child state of the parent,
         
     | 
| 
       1758 
     | 
    
         
            -
               the transition event on the parent will not be triggered.
         
     | 
| 
       1759 
     | 
    
         
            -
            */
         
     | 
| 
       1760 
     | 
    
         
            -
             
     | 
| 
       1761 
     | 
    
         
            -
            var stateProperty = Ember.computed(function(key) {
         
     | 
| 
       1762 
     | 
    
         
            -
              var parent = get(this, 'parentState');
         
     | 
| 
       1763 
     | 
    
         
            -
              if (parent) {
         
     | 
| 
       1764 
     | 
    
         
            -
                return get(parent, key);
         
     | 
| 
       1765 
     | 
    
         
            -
              }
         
     | 
| 
       1766 
     | 
    
         
            -
            }).property();
         
     | 
| 
       1767 
     | 
    
         
            -
             
     | 
| 
       1768 
     | 
    
         
            -
            var isEmptyObject = function(object) {
         
     | 
| 
       1769 
     | 
    
         
            -
              for (var name in object) {
         
     | 
| 
       1770 
     | 
    
         
            -
                if (object.hasOwnProperty(name)) { return false; }
         
     | 
| 
       1771 
     | 
    
         
            -
              }
         
     | 
| 
       1772 
     | 
    
         
            -
             
     | 
| 
       1773 
     | 
    
         
            -
              return true;
         
     | 
| 
       1774 
     | 
    
         
            -
            };
         
     | 
| 
       1775 
     | 
    
         
            -
             
     | 
| 
       1776 
     | 
    
         
            -
            var hasDefinedProperties = function(object) {
         
     | 
| 
       1777 
     | 
    
         
            -
              for (var name in object) {
         
     | 
| 
       1778 
     | 
    
         
            -
                if (object.hasOwnProperty(name) && object[name]) { return true; }
         
     | 
| 
       1779 
     | 
    
         
            -
              }
         
     | 
| 
       1780 
     | 
    
         
            -
             
     | 
| 
       1781 
     | 
    
         
            -
              return false;
         
     | 
| 
       1782 
     | 
    
         
            -
            };
         
     | 
| 
       1783 
     | 
    
         
            -
             
     | 
| 
       1784 
     | 
    
         
            -
            DS.State = Ember.State.extend({
         
     | 
| 
       1785 
     | 
    
         
            -
              isLoaded: stateProperty,
         
     | 
| 
       1786 
     | 
    
         
            -
              isDirty: stateProperty,
         
     | 
| 
       1787 
     | 
    
         
            -
              isSaving: stateProperty,
         
     | 
| 
       1788 
     | 
    
         
            -
              isDeleted: stateProperty,
         
     | 
| 
       1789 
     | 
    
         
            -
              isError: stateProperty,
         
     | 
| 
       1790 
     | 
    
         
            -
              isNew: stateProperty,
         
     | 
| 
       1791 
     | 
    
         
            -
              isValid: stateProperty,
         
     | 
| 
       1792 
     | 
    
         
            -
              isPending: stateProperty,
         
     | 
| 
       1793 
     | 
    
         
            -
             
     | 
| 
       1794 
     | 
    
         
            -
              // For states that are substates of a
         
     | 
| 
       1795 
     | 
    
         
            -
              // DirtyState (updated or created), it is
         
     | 
| 
       1796 
     | 
    
         
            -
              // useful to be able to determine which
         
     | 
| 
       1797 
     | 
    
         
            -
              // type of dirty state it is.
         
     | 
| 
       1798 
     | 
    
         
            -
              dirtyType: stateProperty
         
     | 
| 
       1799 
     | 
    
         
            -
            });
         
     | 
| 
       1800 
     | 
    
         
            -
             
     | 
| 
       1801 
     | 
    
         
            -
            var setProperty = function(manager, context) {
         
     | 
| 
       1802 
     | 
    
         
            -
              var key = context.key, value = context.value;
         
     | 
| 
       1803 
     | 
    
         
            -
             
     | 
| 
       1804 
     | 
    
         
            -
              var record = get(manager, 'record'),
         
     | 
| 
       1805 
     | 
    
         
            -
                  data = get(record, 'data');
         
     | 
| 
       1806 
     | 
    
         
            -
             
     | 
| 
       1807 
     | 
    
         
            -
              set(data, key, value);
         
     | 
| 
       1808 
     | 
    
         
            -
            };
         
     | 
| 
       1809 
     | 
    
         
            -
             
     | 
| 
       1810 
     | 
    
         
            -
            var setAssociation = function(manager, context) {
         
     | 
| 
       1811 
     | 
    
         
            -
              var key = context.key, value = context.value;
         
     | 
| 
       1812 
     | 
    
         
            -
             
     | 
| 
       1813 
     | 
    
         
            -
              var record = get(manager, 'record'),
         
     | 
| 
       1814 
     | 
    
         
            -
                  data = get(record, 'data');
         
     | 
| 
       1815 
     | 
    
         
            -
             
     | 
| 
       1816 
     | 
    
         
            -
              data.setAssociation(key, value);
         
     | 
| 
       1817 
     | 
    
         
            -
            };
         
     | 
| 
       1818 
     | 
    
         
            -
             
     | 
| 
       1819 
     | 
    
         
            -
            var didChangeData = function(manager) {
         
     | 
| 
       1820 
     | 
    
         
            -
              var record = get(manager, 'record'),
         
     | 
| 
       1821 
     | 
    
         
            -
                  data = get(record, 'data');
         
     | 
| 
       1822 
     | 
    
         
            -
             
     | 
| 
       1823 
     | 
    
         
            -
              data._savedData = null;
         
     | 
| 
       1824 
     | 
    
         
            -
              record.notifyPropertyChange('data');
         
     | 
| 
       1825 
     | 
    
         
            -
            };
         
     | 
| 
       1826 
     | 
    
         
            -
             
     | 
| 
       1827 
     | 
    
         
            -
            // The waitingOn event shares common functionality
         
     | 
| 
       1828 
     | 
    
         
            -
            // between the different dirty states, but each is
         
     | 
| 
       1829 
     | 
    
         
            -
            // treated slightly differently. This method is exposed
         
     | 
| 
       1830 
     | 
    
         
            -
            // so that each implementation can invoke the common
         
     | 
| 
       1831 
     | 
    
         
            -
            // behavior, and then implement the behavior specific
         
     | 
| 
       1832 
     | 
    
         
            -
            // to the state.
         
     | 
| 
       1833 
     | 
    
         
            -
            var waitingOn = function(manager, object) {
         
     | 
| 
       1834 
     | 
    
         
            -
              var record = get(manager, 'record'),
         
     | 
| 
       1835 
     | 
    
         
            -
                  pendingQueue = get(record, 'pendingQueue'),
         
     | 
| 
       1836 
     | 
    
         
            -
                  objectGuid = guidFor(object);
         
     | 
| 
       1837 
     | 
    
         
            -
             
     | 
| 
       1838 
     | 
    
         
            -
              var observer = function() {
         
     | 
| 
       1839 
     | 
    
         
            -
                if (get(object, 'id')) {
         
     | 
| 
       1840 
     | 
    
         
            -
                  manager.send('doneWaitingOn', object);
         
     | 
| 
       1841 
     | 
    
         
            -
                  Ember.removeObserver(object, 'id', observer);
         
     | 
| 
       1842 
     | 
    
         
            -
                }
         
     | 
| 
       1843 
     | 
    
         
            -
              };
         
     | 
| 
       1844 
     | 
    
         
            -
             
     | 
| 
       1845 
     | 
    
         
            -
              pendingQueue[objectGuid] = [object, observer];
         
     | 
| 
       1846 
     | 
    
         
            -
              Ember.addObserver(object, 'id', observer);
         
     | 
| 
       1847 
     | 
    
         
            -
            };
         
     | 
| 
       1848 
     | 
    
         
            -
             
     | 
| 
       1849 
     | 
    
         
            -
            // Implementation notes:
         
     | 
| 
       1850 
     | 
    
         
            -
            //
         
     | 
| 
       1851 
     | 
    
         
            -
            // Each state has a boolean value for all of the following flags:
         
     | 
| 
       1852 
     | 
    
         
            -
            //
         
     | 
| 
       1853 
     | 
    
         
            -
            // * isLoaded: The record has a populated `data` property. When a
         
     | 
| 
       1854 
     | 
    
         
            -
            //   record is loaded via `store.find`, `isLoaded` is false
         
     | 
| 
       1855 
     | 
    
         
            -
            //   until the adapter sets it. When a record is created locally,
         
     | 
| 
       1856 
     | 
    
         
            -
            //   its `isLoaded` property is always true.
         
     | 
| 
       1857 
     | 
    
         
            -
            // * isDirty: The record has local changes that have not yet been
         
     | 
| 
       1858 
     | 
    
         
            -
            //   saved by the adapter. This includes records that have been
         
     | 
| 
       1859 
     | 
    
         
            -
            //   created (but not yet saved) or deleted.
         
     | 
| 
       1860 
     | 
    
         
            -
            // * isSaving: The record's transaction has been committed, but
         
     | 
| 
       1861 
     | 
    
         
            -
            //   the adapter has not yet acknowledged that the changes have
         
     | 
| 
       1862 
     | 
    
         
            -
            //   been persisted to the backend.
         
     | 
| 
       1863 
     | 
    
         
            -
            // * isDeleted: The record was marked for deletion. When `isDeleted`
         
     | 
| 
       1864 
     | 
    
         
            -
            //   is true and `isDirty` is true, the record is deleted locally
         
     | 
| 
       1865 
     | 
    
         
            -
            //   but the deletion was not yet persisted. When `isSaving` is
         
     | 
| 
       1866 
     | 
    
         
            -
            //   true, the change is in-flight. When both `isDirty` and
         
     | 
| 
       1867 
     | 
    
         
            -
            //   `isSaving` are false, the change has persisted.
         
     | 
| 
       1868 
     | 
    
         
            -
            // * isError: The adapter reported that it was unable to save
         
     | 
| 
       1869 
     | 
    
         
            -
            //   local changes to the backend. This may also result in the
         
     | 
| 
       1870 
     | 
    
         
            -
            //   record having its `isValid` property become false if the
         
     | 
| 
       1871 
     | 
    
         
            -
            //   adapter reported that server-side validations failed.
         
     | 
| 
       1872 
     | 
    
         
            -
            // * isNew: The record was created on the client and the adapter
         
     | 
| 
       1873 
     | 
    
         
            -
            //   did not yet report that it was successfully saved.
         
     | 
| 
       1874 
     | 
    
         
            -
            // * isValid: No client-side validations have failed and the
         
     | 
| 
       1875 
     | 
    
         
            -
            //   adapter did not report any server-side validation failures.
         
     | 
| 
       1876 
     | 
    
         
            -
            // * isPending: A record `isPending` when it belongs to an
         
     | 
| 
       1877 
     | 
    
         
            -
            //   association on another record and that record has not been
         
     | 
| 
       1878 
     | 
    
         
            -
            //   saved. A record in this state cannot be saved because it
         
     | 
| 
       1879 
     | 
    
         
            -
            //   lacks a "foreign key" that will be supplied by its parent
         
     | 
| 
       1880 
     | 
    
         
            -
            //   association when the parent record has been created. When
         
     | 
| 
       1881 
     | 
    
         
            -
            //   the adapter reports that the parent has saved, the
         
     | 
| 
       1882 
     | 
    
         
            -
            //   `isPending` property on all children will become `false`
         
     | 
| 
       1883 
     | 
    
         
            -
            //   and the transaction will try to commit the records.
         
     | 
| 
       1884 
     | 
    
         
            -
             
     | 
| 
       1885 
     | 
    
         
            -
            // This mixin is mixed into various uncommitted states. Make
         
     | 
| 
       1886 
     | 
    
         
            -
            // sure to mix it in *after* the class definition, so its
         
     | 
| 
       1887 
     | 
    
         
            -
            // super points to the class definition.
         
     | 
| 
       1888 
     | 
    
         
            -
            var Uncommitted = Ember.Mixin.create({
         
     | 
| 
       1889 
     | 
    
         
            -
              setProperty: setProperty,
         
     | 
| 
       1890 
     | 
    
         
            -
              setAssociation: setAssociation,
         
     | 
| 
       1891 
     | 
    
         
            -
            });
         
     | 
| 
       1892 
     | 
    
         
            -
             
     | 
| 
       1893 
     | 
    
         
            -
            // These mixins are mixed into substates of the concrete
         
     | 
| 
       1894 
     | 
    
         
            -
            // subclasses of DirtyState.
         
     | 
| 
       1895 
     | 
    
         
            -
             
     | 
| 
       1896 
     | 
    
         
            -
            var CreatedUncommitted = Ember.Mixin.create({
         
     | 
| 
       1897 
     | 
    
         
            -
              deleteRecord: function(manager) {
         
     | 
| 
       1898 
     | 
    
         
            -
                var record = get(manager, 'record');
         
     | 
| 
       1899 
     | 
    
         
            -
                this._super(manager);
         
     | 
| 
       1900 
     | 
    
         
            -
             
     | 
| 
       1901 
     | 
    
         
            -
                record.withTransaction(function(t) {
         
     | 
| 
       1902 
     | 
    
         
            -
                  t.recordBecameClean('created', record);
         
     | 
| 
       1903 
     | 
    
         
            -
                });
         
     | 
| 
       1904 
     | 
    
         
            -
                manager.goToState('deleted.saved');
         
     | 
| 
       1905 
     | 
    
         
            -
              }
         
     | 
| 
       1906 
     | 
    
         
            -
            });
         
     | 
| 
       1907 
     | 
    
         
            -
             
     | 
| 
       1908 
     | 
    
         
            -
            var UpdatedUncommitted = Ember.Mixin.create({
         
     | 
| 
       1909 
     | 
    
         
            -
              deleteRecord: function(manager) {
         
     | 
| 
       1910 
     | 
    
         
            -
                this._super(manager);
         
     | 
| 
       1911 
     | 
    
         
            -
             
     | 
| 
       1912 
     | 
    
         
            -
                var record = get(manager, 'record');
         
     | 
| 
       1913 
     | 
    
         
            -
             
     | 
| 
       1914 
     | 
    
         
            -
                record.withTransaction(function(t) {
         
     | 
| 
       1915 
     | 
    
         
            -
                  t.recordBecameClean('updated', record);
         
     | 
| 
       1916 
     | 
    
         
            -
                });
         
     | 
| 
       1917 
     | 
    
         
            -
             
     | 
| 
       1918 
     | 
    
         
            -
                manager.goToState('deleted');
         
     | 
| 
       1919 
     | 
    
         
            -
              }
         
     | 
| 
       1920 
     | 
    
         
            -
            });
         
     | 
| 
       1921 
     | 
    
         
            -
             
     | 
| 
       1922 
     | 
    
         
            -
            // The dirty state is a abstract state whose functionality is
         
     | 
| 
       1923 
     | 
    
         
            -
            // shared between the `created` and `updated` states.
         
     | 
| 
       1924 
     | 
    
         
            -
            //
         
     | 
| 
       1925 
     | 
    
         
            -
            // The deleted state shares the `isDirty` flag with the
         
     | 
| 
       1926 
     | 
    
         
            -
            // subclasses of `DirtyState`, but with a very different
         
     | 
| 
       1927 
     | 
    
         
            -
            // implementation.
         
     | 
| 
       1928 
     | 
    
         
            -
            var DirtyState = DS.State.extend({
         
     | 
| 
       1929 
     | 
    
         
            -
              initialState: 'uncommitted',
         
     | 
| 
       1930 
     | 
    
         
            -
             
     | 
| 
       1931 
     | 
    
         
            -
              // FLAGS
         
     | 
| 
       1932 
     | 
    
         
            -
              isDirty: true,
         
     | 
| 
       1933 
     | 
    
         
            -
             
     | 
| 
       1934 
     | 
    
         
            -
              // SUBSTATES
         
     | 
| 
       1935 
     | 
    
         
            -
             
     | 
| 
       1936 
     | 
    
         
            -
              // When a record first becomes dirty, it is `uncommitted`.
         
     | 
| 
       1937 
     | 
    
         
            -
              // This means that there are local pending changes,
         
     | 
| 
       1938 
     | 
    
         
            -
              // but they have not yet begun to be saved.
         
     | 
| 
       1939 
     | 
    
         
            -
              uncommitted: DS.State.extend({
         
     | 
| 
       1940 
     | 
    
         
            -
                // TRANSITIONS
         
     | 
| 
       1941 
     | 
    
         
            -
                enter: function(manager) {
         
     | 
| 
       1942 
     | 
    
         
            -
                  var dirtyType = get(this, 'dirtyType'),
         
     | 
| 
       1943 
     | 
    
         
            -
                      record = get(manager, 'record');
         
     | 
| 
       1944 
     | 
    
         
            -
             
     | 
| 
       1945 
     | 
    
         
            -
                  record.withTransaction(function (t) {
         
     | 
| 
       1946 
     | 
    
         
            -
                    t.recordBecameDirty(dirtyType, record);
         
     | 
| 
       1947 
     | 
    
         
            -
                  });
         
     | 
| 
       1948 
     | 
    
         
            -
                },
         
     | 
| 
       1949 
     | 
    
         
            -
             
     | 
| 
       1950 
     | 
    
         
            -
                // EVENTS
         
     | 
| 
       1951 
     | 
    
         
            -
                deleteRecord: Ember.K,
         
     | 
| 
       1952 
     | 
    
         
            -
             
     | 
| 
       1953 
     | 
    
         
            -
                waitingOn: function(manager, object) {
         
     | 
| 
       1954 
     | 
    
         
            -
                  waitingOn(manager, object);
         
     | 
| 
       1955 
     | 
    
         
            -
                  manager.goToState('pending');
         
     | 
| 
       1956 
     | 
    
         
            -
                },
         
     | 
| 
       1957 
     | 
    
         
            -
             
     | 
| 
       1958 
     | 
    
         
            -
                willCommit: function(manager) {
         
     | 
| 
       1959 
     | 
    
         
            -
                  manager.goToState('inFlight');
         
     | 
| 
       1960 
     | 
    
         
            -
                },
         
     | 
| 
       1961 
     | 
    
         
            -
             
     | 
| 
       1962 
     | 
    
         
            -
                becameInvalid: function(manager) {
         
     | 
| 
       1963 
     | 
    
         
            -
                  var dirtyType = get(this, 'dirtyType'),
         
     | 
| 
       1964 
     | 
    
         
            -
                      record = get(manager, 'record');
         
     | 
| 
       1965 
     | 
    
         
            -
             
     | 
| 
       1966 
     | 
    
         
            -
                  record.withTransaction(function (t) {
         
     | 
| 
       1967 
     | 
    
         
            -
                    t.recordBecameInFlight(dirtyType, record);
         
     | 
| 
       1968 
     | 
    
         
            -
                  });
         
     | 
| 
       1969 
     | 
    
         
            -
             
     | 
| 
       1970 
     | 
    
         
            -
                  manager.goToState('invalid');
         
     | 
| 
       1971 
     | 
    
         
            -
                },
         
     | 
| 
       1972 
     | 
    
         
            -
             
     | 
| 
       1973 
     | 
    
         
            -
                rollback: function(manager) {
         
     | 
| 
       1974 
     | 
    
         
            -
                  var record = get(manager, 'record'),
         
     | 
| 
       1975 
     | 
    
         
            -
                      dirtyType = get(this, 'dirtyType'),
         
     | 
| 
       1976 
     | 
    
         
            -
                      data = get(record, 'data');
         
     | 
| 
       1977 
     | 
    
         
            -
             
     | 
| 
       1978 
     | 
    
         
            -
                  data.rollback();
         
     | 
| 
       1979 
     | 
    
         
            -
             
     | 
| 
       1980 
     | 
    
         
            -
                  record.withTransaction(function(t) {
         
     | 
| 
       1981 
     | 
    
         
            -
                    t.recordBecameClean(dirtyType, record);
         
     | 
| 
       1982 
     | 
    
         
            -
                  });
         
     | 
| 
       1983 
     | 
    
         
            -
             
     | 
| 
       1984 
     | 
    
         
            -
                  manager.goToState('loaded');
         
     | 
| 
       1985 
     | 
    
         
            -
                }
         
     | 
| 
       1986 
     | 
    
         
            -
              }, Uncommitted),
         
     | 
| 
       1987 
     | 
    
         
            -
             
     | 
| 
       1988 
     | 
    
         
            -
              // Once a record has been handed off to the adapter to be
         
     | 
| 
       1989 
     | 
    
         
            -
              // saved, it is in the 'in flight' state. Changes to the
         
     | 
| 
       1990 
     | 
    
         
            -
              // record cannot be made during this window.
         
     | 
| 
       1991 
     | 
    
         
            -
              inFlight: DS.State.extend({
         
     | 
| 
       1992 
     | 
    
         
            -
                // FLAGS
         
     | 
| 
       1993 
     | 
    
         
            -
                isSaving: true,
         
     | 
| 
       1994 
     | 
    
         
            -
             
     | 
| 
       1995 
     | 
    
         
            -
                // TRANSITIONS
         
     | 
| 
       1996 
     | 
    
         
            -
                enter: function(manager) {
         
     | 
| 
       1997 
     | 
    
         
            -
                  var dirtyType = get(this, 'dirtyType'),
         
     | 
| 
       1998 
     | 
    
         
            -
                      record = get(manager, 'record');
         
     | 
| 
       1999 
     | 
    
         
            -
             
     | 
| 
       2000 
     | 
    
         
            -
                  record.withTransaction(function (t) {
         
     | 
| 
       2001 
     | 
    
         
            -
                    t.recordBecameInFlight(dirtyType, record);
         
     | 
| 
       2002 
     | 
    
         
            -
                  });
         
     | 
| 
       2003 
     | 
    
         
            -
                },
         
     | 
| 
       2004 
     | 
    
         
            -
             
     | 
| 
       2005 
     | 
    
         
            -
                // EVENTS
         
     | 
| 
       2006 
     | 
    
         
            -
                didCommit: function(manager) {
         
     | 
| 
       2007 
     | 
    
         
            -
                  var dirtyType = get(this, 'dirtyType'),
         
     | 
| 
       2008 
     | 
    
         
            -
                      record = get(manager, 'record');
         
     | 
| 
       2009 
     | 
    
         
            -
             
     | 
| 
       2010 
     | 
    
         
            -
                  record.withTransaction(function(t) {
         
     | 
| 
       2011 
     | 
    
         
            -
                    t.recordBecameClean('inflight', record);
         
     | 
| 
       2012 
     | 
    
         
            -
                  });
         
     | 
| 
       2013 
     | 
    
         
            -
             
     | 
| 
       2014 
     | 
    
         
            -
                  manager.goToState('loaded');
         
     | 
| 
       2015 
     | 
    
         
            -
                  manager.send('invokeLifecycleCallbacks', dirtyType);
         
     | 
| 
       2016 
     | 
    
         
            -
                },
         
     | 
| 
       2017 
     | 
    
         
            -
             
     | 
| 
       2018 
     | 
    
         
            -
                becameInvalid: function(manager, errors) {
         
     | 
| 
       2019 
     | 
    
         
            -
                  var record = get(manager, 'record');
         
     | 
| 
       2020 
     | 
    
         
            -
             
     | 
| 
       2021 
     | 
    
         
            -
                  set(record, 'errors', errors);
         
     | 
| 
       2022 
     | 
    
         
            -
             
     | 
| 
       2023 
     | 
    
         
            -
                  manager.goToState('invalid');
         
     | 
| 
       2024 
     | 
    
         
            -
                  manager.send('invokeLifecycleCallbacks');
         
     | 
| 
       2025 
     | 
    
         
            -
                },
         
     | 
| 
       2026 
     | 
    
         
            -
             
     | 
| 
       2027 
     | 
    
         
            -
                becameError: function(manager) {
         
     | 
| 
       2028 
     | 
    
         
            -
                  manager.goToState('error');
         
     | 
| 
       2029 
     | 
    
         
            -
                  manager.send('invokeLifecycleCallbacks');
         
     | 
| 
       2030 
     | 
    
         
            -
                },
         
     | 
| 
       2031 
     | 
    
         
            -
             
     | 
| 
       2032 
     | 
    
         
            -
                didChangeData: didChangeData
         
     | 
| 
       2033 
     | 
    
         
            -
              }),
         
     | 
| 
       2034 
     | 
    
         
            -
             
     | 
| 
       2035 
     | 
    
         
            -
              // If a record becomes associated with a newly created
         
     | 
| 
       2036 
     | 
    
         
            -
              // parent record, it will be `pending` until the parent
         
     | 
| 
       2037 
     | 
    
         
            -
              // record has successfully persisted. Once this happens,
         
     | 
| 
       2038 
     | 
    
         
            -
              // this record can use the parent's primary key as its
         
     | 
| 
       2039 
     | 
    
         
            -
              // foreign key.
         
     | 
| 
       2040 
     | 
    
         
            -
              //
         
     | 
| 
       2041 
     | 
    
         
            -
              // If the record's transaction had already started to
         
     | 
| 
       2042 
     | 
    
         
            -
              // commit, the record will transition to the `inFlight`
         
     | 
| 
       2043 
     | 
    
         
            -
              // state. If it had not, the record will transition to
         
     | 
| 
       2044 
     | 
    
         
            -
              // the `uncommitted` state.
         
     | 
| 
       2045 
     | 
    
         
            -
              pending: DS.State.extend({
         
     | 
| 
       2046 
     | 
    
         
            -
                initialState: 'uncommitted',
         
     | 
| 
       2047 
     | 
    
         
            -
             
     | 
| 
       2048 
     | 
    
         
            -
                // FLAGS
         
     | 
| 
       2049 
     | 
    
         
            -
                isPending: true,
         
     | 
| 
       2050 
     | 
    
         
            -
             
     | 
| 
       2051 
     | 
    
         
            -
                // SUBSTATES
         
     | 
| 
       2052 
     | 
    
         
            -
             
     | 
| 
       2053 
     | 
    
         
            -
                // A pending record whose transaction has not yet
         
     | 
| 
       2054 
     | 
    
         
            -
                // started to commit is in this state.
         
     | 
| 
       2055 
     | 
    
         
            -
                uncommitted: DS.State.extend({
         
     | 
| 
       2056 
     | 
    
         
            -
                  // EVENTS
         
     | 
| 
       2057 
     | 
    
         
            -
                  deleteRecord: function(manager) {
         
     | 
| 
       2058 
     | 
    
         
            -
                    var record = get(manager, 'record'),
         
     | 
| 
       2059 
     | 
    
         
            -
                        pendingQueue = get(record, 'pendingQueue'),
         
     | 
| 
       2060 
     | 
    
         
            -
                        tuple;
         
     | 
| 
       2061 
     | 
    
         
            -
             
     | 
| 
       2062 
     | 
    
         
            -
                    // since we are leaving the pending state, remove any
         
     | 
| 
       2063 
     | 
    
         
            -
                    // observers we have registered on other records.
         
     | 
| 
       2064 
     | 
    
         
            -
                    for (var prop in pendingQueue) {
         
     | 
| 
       2065 
     | 
    
         
            -
                      if (!pendingQueue.hasOwnProperty(prop)) { continue; }
         
     | 
| 
       2066 
     | 
    
         
            -
             
     | 
| 
       2067 
     | 
    
         
            -
                      tuple = pendingQueue[prop];
         
     | 
| 
       2068 
     | 
    
         
            -
                      Ember.removeObserver(tuple[0], 'id', tuple[1]);
         
     | 
| 
       2069 
     | 
    
         
            -
                    }
         
     | 
| 
       2070 
     | 
    
         
            -
                  },
         
     | 
| 
       2071 
     | 
    
         
            -
             
     | 
| 
       2072 
     | 
    
         
            -
                  willCommit: function(manager) {
         
     | 
| 
       2073 
     | 
    
         
            -
                    manager.goToState('committing');
         
     | 
| 
       2074 
     | 
    
         
            -
                  },
         
     | 
| 
       2075 
     | 
    
         
            -
             
     | 
| 
       2076 
     | 
    
         
            -
                  doneWaitingOn: function(manager, object) {
         
     | 
| 
       2077 
     | 
    
         
            -
                    var record = get(manager, 'record'),
         
     | 
| 
       2078 
     | 
    
         
            -
                        pendingQueue = get(record, 'pendingQueue'),
         
     | 
| 
       2079 
     | 
    
         
            -
                        objectGuid = guidFor(object);
         
     | 
| 
       2080 
     | 
    
         
            -
             
     | 
| 
       2081 
     | 
    
         
            -
                    delete pendingQueue[objectGuid];
         
     | 
| 
       2082 
     | 
    
         
            -
             
     | 
| 
       2083 
     | 
    
         
            -
                    if (isEmptyObject(pendingQueue)) {
         
     | 
| 
       2084 
     | 
    
         
            -
                      manager.send('doneWaiting');
         
     | 
| 
       2085 
     | 
    
         
            -
                    }
         
     | 
| 
       2086 
     | 
    
         
            -
                  },
         
     | 
| 
       2087 
     | 
    
         
            -
             
     | 
| 
       2088 
     | 
    
         
            -
                  doneWaiting: function(manager) {
         
     | 
| 
       2089 
     | 
    
         
            -
                    var dirtyType = get(this, 'dirtyType');
         
     | 
| 
       2090 
     | 
    
         
            -
                    manager.goToState(dirtyType + '.uncommitted');
         
     | 
| 
       2091 
     | 
    
         
            -
                  }
         
     | 
| 
       2092 
     | 
    
         
            -
                }, Uncommitted),
         
     | 
| 
       2093 
     | 
    
         
            -
             
     | 
| 
       2094 
     | 
    
         
            -
                // A pending record whose transaction has started
         
     | 
| 
       2095 
     | 
    
         
            -
                // to commit is in this state. Since it has not yet
         
     | 
| 
       2096 
     | 
    
         
            -
                // been sent to the adapter, it is not `inFlight`
         
     | 
| 
       2097 
     | 
    
         
            -
                // until all of its dependencies have been committed.
         
     | 
| 
       2098 
     | 
    
         
            -
                committing: DS.State.extend({
         
     | 
| 
       2099 
     | 
    
         
            -
                  // FLAGS
         
     | 
| 
       2100 
     | 
    
         
            -
                  isSaving: true,
         
     | 
| 
       2101 
     | 
    
         
            -
             
     | 
| 
       2102 
     | 
    
         
            -
                  // EVENTS
         
     | 
| 
       2103 
     | 
    
         
            -
                  doneWaitingOn: function(manager, object) {
         
     | 
| 
       2104 
     | 
    
         
            -
                    var record = get(manager, 'record'),
         
     | 
| 
       2105 
     | 
    
         
            -
                        pendingQueue = get(record, 'pendingQueue'),
         
     | 
| 
       2106 
     | 
    
         
            -
                        objectGuid = guidFor(object);
         
     | 
| 
       2107 
     | 
    
         
            -
             
     | 
| 
       2108 
     | 
    
         
            -
                    delete pendingQueue[objectGuid];
         
     | 
| 
       2109 
     | 
    
         
            -
             
     | 
| 
       2110 
     | 
    
         
            -
                    if (isEmptyObject(pendingQueue)) {
         
     | 
| 
       2111 
     | 
    
         
            -
                      manager.send('doneWaiting');
         
     | 
| 
       2112 
     | 
    
         
            -
                    }
         
     | 
| 
       2113 
     | 
    
         
            -
                  },
         
     | 
| 
       2114 
     | 
    
         
            -
             
     | 
| 
       2115 
     | 
    
         
            -
                  doneWaiting: function(manager) {
         
     | 
| 
       2116 
     | 
    
         
            -
                    var record = get(manager, 'record'),
         
     | 
| 
       2117 
     | 
    
         
            -
                        transaction = get(record, 'transaction');
         
     | 
| 
       2118 
     | 
    
         
            -
             
     | 
| 
       2119 
     | 
    
         
            -
                    // Now that the record is no longer pending, schedule
         
     | 
| 
       2120 
     | 
    
         
            -
                    // the transaction to commit.
         
     | 
| 
       2121 
     | 
    
         
            -
                    Ember.run.once(transaction, transaction.commit);
         
     | 
| 
       2122 
     | 
    
         
            -
                  },
         
     | 
| 
       2123 
     | 
    
         
            -
             
     | 
| 
       2124 
     | 
    
         
            -
                  willCommit: function(manager) {
         
     | 
| 
       2125 
     | 
    
         
            -
                    var record = get(manager, 'record'),
         
     | 
| 
       2126 
     | 
    
         
            -
                        pendingQueue = get(record, 'pendingQueue');
         
     | 
| 
       2127 
     | 
    
         
            -
             
     | 
| 
       2128 
     | 
    
         
            -
                    if (isEmptyObject(pendingQueue)) {
         
     | 
| 
       2129 
     | 
    
         
            -
                      var dirtyType = get(this, 'dirtyType');
         
     | 
| 
       2130 
     | 
    
         
            -
                      manager.goToState(dirtyType + '.inFlight');
         
     | 
| 
       2131 
     | 
    
         
            -
                    }
         
     | 
| 
       2132 
     | 
    
         
            -
                  }
         
     | 
| 
       2133 
     | 
    
         
            -
                })
         
     | 
| 
       2134 
     | 
    
         
            -
              }),
         
     | 
| 
       2135 
     | 
    
         
            -
             
     | 
| 
       2136 
     | 
    
         
            -
              // A record is in the `invalid` state when its client-side
         
     | 
| 
       2137 
     | 
    
         
            -
              // invalidations have failed, or if the adapter has indicated
         
     | 
| 
       2138 
     | 
    
         
            -
              // the the record failed server-side invalidations.
         
     | 
| 
       2139 
     | 
    
         
            -
              invalid: DS.State.extend({
         
     | 
| 
       2140 
     | 
    
         
            -
                // FLAGS
         
     | 
| 
       2141 
     | 
    
         
            -
                isValid: false,
         
     | 
| 
       2142 
     | 
    
         
            -
             
     | 
| 
       2143 
     | 
    
         
            -
                exit: function(manager) {
         
     | 
| 
       2144 
     | 
    
         
            -
                  var record = get(manager, 'record');
         
     | 
| 
       2145 
     | 
    
         
            -
             
     | 
| 
       2146 
     | 
    
         
            -
                  record.withTransaction(function (t) {
         
     | 
| 
       2147 
     | 
    
         
            -
                    t.recordBecameClean('inflight', record);
         
     | 
| 
       2148 
     | 
    
         
            -
                  });
         
     | 
| 
       2149 
     | 
    
         
            -
                },
         
     | 
| 
       2150 
     | 
    
         
            -
             
     | 
| 
       2151 
     | 
    
         
            -
                // EVENTS
         
     | 
| 
       2152 
     | 
    
         
            -
                deleteRecord: function(manager) {
         
     | 
| 
       2153 
     | 
    
         
            -
                  manager.goToState('deleted');
         
     | 
| 
       2154 
     | 
    
         
            -
                },
         
     | 
| 
       2155 
     | 
    
         
            -
             
     | 
| 
       2156 
     | 
    
         
            -
                setAssociation: setAssociation,
         
     | 
| 
       2157 
     | 
    
         
            -
             
     | 
| 
       2158 
     | 
    
         
            -
                setProperty: function(manager, context) {
         
     | 
| 
       2159 
     | 
    
         
            -
                  setProperty(manager, context);
         
     | 
| 
       2160 
     | 
    
         
            -
             
     | 
| 
       2161 
     | 
    
         
            -
                  var record = get(manager, 'record'),
         
     | 
| 
       2162 
     | 
    
         
            -
                      errors = get(record, 'errors'),
         
     | 
| 
       2163 
     | 
    
         
            -
                      key = context.key;
         
     | 
| 
       2164 
     | 
    
         
            -
             
     | 
| 
       2165 
     | 
    
         
            -
                  delete errors[key];
         
     | 
| 
       2166 
     | 
    
         
            -
             
     | 
| 
       2167 
     | 
    
         
            -
                  if (!hasDefinedProperties(errors)) {
         
     | 
| 
       2168 
     | 
    
         
            -
                    manager.send('becameValid');
         
     | 
| 
       2169 
     | 
    
         
            -
                  }
         
     | 
| 
       2170 
     | 
    
         
            -
                },
         
     | 
| 
       2171 
     | 
    
         
            -
             
     | 
| 
       2172 
     | 
    
         
            -
                rollback: function(manager) {
         
     | 
| 
       2173 
     | 
    
         
            -
                  manager.send('becameValid');
         
     | 
| 
       2174 
     | 
    
         
            -
                  manager.send('rollback');
         
     | 
| 
       2175 
     | 
    
         
            -
                },
         
     | 
| 
       2176 
     | 
    
         
            -
             
     | 
| 
       2177 
     | 
    
         
            -
                becameValid: function(manager) {
         
     | 
| 
       2178 
     | 
    
         
            -
                  manager.goToState('uncommitted');
         
     | 
| 
       2179 
     | 
    
         
            -
                },
         
     | 
| 
       2180 
     | 
    
         
            -
             
     | 
| 
       2181 
     | 
    
         
            -
                invokeLifecycleCallbacks: function(manager) {
         
     | 
| 
       2182 
     | 
    
         
            -
                  var record = get(manager, 'record');
         
     | 
| 
       2183 
     | 
    
         
            -
                  record.fire('becameInvalid', record);
         
     | 
| 
       2184 
     | 
    
         
            -
                }
         
     | 
| 
       2185 
     | 
    
         
            -
              })
         
     | 
| 
       2186 
     | 
    
         
            -
            });
         
     | 
| 
       2187 
     | 
    
         
            -
             
     | 
| 
       2188 
     | 
    
         
            -
            // The created and updated states are created outside the state
         
     | 
| 
       2189 
     | 
    
         
            -
            // chart so we can reopen their substates and add mixins as
         
     | 
| 
       2190 
     | 
    
         
            -
            // necessary.
         
     | 
| 
       2191 
     | 
    
         
            -
             
     | 
| 
       2192 
     | 
    
         
            -
            var createdState = DirtyState.create({
         
     | 
| 
       2193 
     | 
    
         
            -
              dirtyType: 'created',
         
     | 
| 
       2194 
     | 
    
         
            -
             
     | 
| 
       2195 
     | 
    
         
            -
              // FLAGS
         
     | 
| 
       2196 
     | 
    
         
            -
              isNew: true
         
     | 
| 
       2197 
     | 
    
         
            -
            });
         
     | 
| 
       2198 
     | 
    
         
            -
             
     | 
| 
       2199 
     | 
    
         
            -
            var updatedState = DirtyState.create({
         
     | 
| 
       2200 
     | 
    
         
            -
              dirtyType: 'updated'
         
     | 
| 
       2201 
     | 
    
         
            -
            });
         
     | 
| 
       2202 
     | 
    
         
            -
             
     | 
| 
       2203 
     | 
    
         
            -
            // The created.uncommitted state and created.pending.uncommitted share
         
     | 
| 
       2204 
     | 
    
         
            -
            // some logic defined in CreatedUncommitted.
         
     | 
| 
       2205 
     | 
    
         
            -
            createdState.states.uncommitted.reopen(CreatedUncommitted);
         
     | 
| 
       2206 
     | 
    
         
            -
            createdState.states.pending.states.uncommitted.reopen(CreatedUncommitted);
         
     | 
| 
       2207 
     | 
    
         
            -
             
     | 
| 
       2208 
     | 
    
         
            -
            // The created.uncommitted state needs to immediately transition to the
         
     | 
| 
       2209 
     | 
    
         
            -
            // deleted state if it is rolled back.
         
     | 
| 
       2210 
     | 
    
         
            -
            createdState.states.uncommitted.reopen({
         
     | 
| 
       2211 
     | 
    
         
            -
              rollback: function(manager) {
         
     | 
| 
       2212 
     | 
    
         
            -
                this._super(manager);
         
     | 
| 
       2213 
     | 
    
         
            -
                manager.goToState('deleted.saved');
         
     | 
| 
       2214 
     | 
    
         
            -
              }
         
     | 
| 
       2215 
     | 
    
         
            -
            });
         
     | 
| 
       2216 
     | 
    
         
            -
             
     | 
| 
       2217 
     | 
    
         
            -
            // The updated.uncommitted state and updated.pending.uncommitted share
         
     | 
| 
       2218 
     | 
    
         
            -
            // some logic defined in UpdatedUncommitted.
         
     | 
| 
       2219 
     | 
    
         
            -
            updatedState.states.uncommitted.reopen(UpdatedUncommitted);
         
     | 
| 
       2220 
     | 
    
         
            -
            updatedState.states.pending.states.uncommitted.reopen(UpdatedUncommitted);
         
     | 
| 
       2221 
     | 
    
         
            -
            updatedState.states.inFlight.reopen({
         
     | 
| 
       2222 
     | 
    
         
            -
              didSaveData: function(manager) {
         
     | 
| 
       2223 
     | 
    
         
            -
                var record = get(manager, 'record'),
         
     | 
| 
       2224 
     | 
    
         
            -
                    data = get(record, 'data');
         
     | 
| 
       2225 
     | 
    
         
            -
             
     | 
| 
       2226 
     | 
    
         
            -
                data.saveData();
         
     | 
| 
       2227 
     | 
    
         
            -
                data.adapterDidUpdate();
         
     | 
| 
       2228 
     | 
    
         
            -
              }
         
     | 
| 
       2229 
     | 
    
         
            -
            });
         
     | 
| 
       2230 
     | 
    
         
            -
             
     | 
| 
       2231 
     | 
    
         
            -
            var states = {
         
     | 
| 
       2232 
     | 
    
         
            -
              rootState: Ember.State.create({
         
     | 
| 
       2233 
     | 
    
         
            -
                // FLAGS
         
     | 
| 
       2234 
     | 
    
         
            -
                isLoaded: false,
         
     | 
| 
       2235 
     | 
    
         
            -
                isDirty: false,
         
     | 
| 
       2236 
     | 
    
         
            -
                isSaving: false,
         
     | 
| 
       2237 
     | 
    
         
            -
                isDeleted: false,
         
     | 
| 
       2238 
     | 
    
         
            -
                isError: false,
         
     | 
| 
       2239 
     | 
    
         
            -
                isNew: false,
         
     | 
| 
       2240 
     | 
    
         
            -
                isValid: true,
         
     | 
| 
       2241 
     | 
    
         
            -
                isPending: false,
         
     | 
| 
       2242 
     | 
    
         
            -
             
     | 
| 
       2243 
     | 
    
         
            -
                // SUBSTATES
         
     | 
| 
       2244 
     | 
    
         
            -
             
     | 
| 
       2245 
     | 
    
         
            -
                // A record begins its lifecycle in the `empty` state.
         
     | 
| 
       2246 
     | 
    
         
            -
                // If its data will come from the adapter, it will
         
     | 
| 
       2247 
     | 
    
         
            -
                // transition into the `loading` state. Otherwise, if
         
     | 
| 
       2248 
     | 
    
         
            -
                // the record is being created on the client, it will
         
     | 
| 
       2249 
     | 
    
         
            -
                // transition into the `created` state.
         
     | 
| 
       2250 
     | 
    
         
            -
                empty: DS.State.create({
         
     | 
| 
       2251 
     | 
    
         
            -
                  // EVENTS
         
     | 
| 
       2252 
     | 
    
         
            -
                  loadingData: function(manager) {
         
     | 
| 
       2253 
     | 
    
         
            -
                    manager.goToState('loading');
         
     | 
| 
       2254 
     | 
    
         
            -
                  },
         
     | 
| 
       2255 
     | 
    
         
            -
             
     | 
| 
       2256 
     | 
    
         
            -
                  didChangeData: function(manager) {
         
     | 
| 
       2257 
     | 
    
         
            -
                    didChangeData(manager);
         
     | 
| 
       2258 
     | 
    
         
            -
             
     | 
| 
       2259 
     | 
    
         
            -
                    manager.goToState('loaded.created');
         
     | 
| 
       2260 
     | 
    
         
            -
                  }
         
     | 
| 
       2261 
     | 
    
         
            -
                }),
         
     | 
| 
       2262 
     | 
    
         
            -
             
     | 
| 
       2263 
     | 
    
         
            -
                // A record enters this state when the store askes
         
     | 
| 
       2264 
     | 
    
         
            -
                // the adapter for its data. It remains in this state
         
     | 
| 
       2265 
     | 
    
         
            -
                // until the adapter provides the requested data.
         
     | 
| 
       2266 
     | 
    
         
            -
                //
         
     | 
| 
       2267 
     | 
    
         
            -
                // Usually, this process is asynchronous, using an
         
     | 
| 
       2268 
     | 
    
         
            -
                // XHR to retrieve the data.
         
     | 
| 
       2269 
     | 
    
         
            -
                loading: DS.State.create({
         
     | 
| 
       2270 
     | 
    
         
            -
                  // TRANSITIONS
         
     | 
| 
       2271 
     | 
    
         
            -
                  exit: function(manager) {
         
     | 
| 
       2272 
     | 
    
         
            -
                    var record = get(manager, 'record');
         
     | 
| 
       2273 
     | 
    
         
            -
                    record.fire('didLoad');
         
     | 
| 
       2274 
     | 
    
         
            -
                  },
         
     | 
| 
       2275 
     | 
    
         
            -
             
     | 
| 
       2276 
     | 
    
         
            -
                  // EVENTS
         
     | 
| 
       2277 
     | 
    
         
            -
                  didChangeData: function(manager, data) {
         
     | 
| 
       2278 
     | 
    
         
            -
                    didChangeData(manager);
         
     | 
| 
       2279 
     | 
    
         
            -
                    manager.send('loadedData');
         
     | 
| 
       2280 
     | 
    
         
            -
                  },
         
     | 
| 
       2281 
     | 
    
         
            -
             
     | 
| 
       2282 
     | 
    
         
            -
                  loadedData: function(manager) {
         
     | 
| 
       2283 
     | 
    
         
            -
                    manager.goToState('loaded');
         
     | 
| 
       2284 
     | 
    
         
            -
                  }
         
     | 
| 
       2285 
     | 
    
         
            -
                }),
         
     | 
| 
       2286 
     | 
    
         
            -
             
     | 
| 
       2287 
     | 
    
         
            -
                // A record enters this state when its data is populated.
         
     | 
| 
       2288 
     | 
    
         
            -
                // Most of a record's lifecycle is spent inside substates
         
     | 
| 
       2289 
     | 
    
         
            -
                // of the `loaded` state.
         
     | 
| 
       2290 
     | 
    
         
            -
                loaded: DS.State.create({
         
     | 
| 
       2291 
     | 
    
         
            -
                  initialState: 'saved',
         
     | 
| 
       2292 
     | 
    
         
            -
             
     | 
| 
       2293 
     | 
    
         
            -
                  // FLAGS
         
     | 
| 
       2294 
     | 
    
         
            -
                  isLoaded: true,
         
     | 
| 
       2295 
     | 
    
         
            -
             
     | 
| 
       2296 
     | 
    
         
            -
                  // SUBSTATES
         
     | 
| 
       2297 
     | 
    
         
            -
             
     | 
| 
       2298 
     | 
    
         
            -
                  // If there are no local changes to a record, it remains
         
     | 
| 
       2299 
     | 
    
         
            -
                  // in the `saved` state.
         
     | 
| 
       2300 
     | 
    
         
            -
                  saved: DS.State.create({
         
     | 
| 
       2301 
     | 
    
         
            -
             
     | 
| 
       2302 
     | 
    
         
            -
                    // EVENTS
         
     | 
| 
       2303 
     | 
    
         
            -
                    setProperty: function(manager, context) {
         
     | 
| 
       2304 
     | 
    
         
            -
                      setProperty(manager, context);
         
     | 
| 
       2305 
     | 
    
         
            -
                      manager.goToState('updated');
         
     | 
| 
       2306 
     | 
    
         
            -
                    },
         
     | 
| 
       2307 
     | 
    
         
            -
             
     | 
| 
       2308 
     | 
    
         
            -
                    setAssociation: function(manager, context) {
         
     | 
| 
       2309 
     | 
    
         
            -
                      setAssociation(manager, context);
         
     | 
| 
       2310 
     | 
    
         
            -
                      manager.goToState('updated');
         
     | 
| 
       2311 
     | 
    
         
            -
                    },
         
     | 
| 
       2312 
     | 
    
         
            -
             
     | 
| 
       2313 
     | 
    
         
            -
                    didChangeData: didChangeData,
         
     | 
| 
       2314 
     | 
    
         
            -
             
     | 
| 
       2315 
     | 
    
         
            -
                    deleteRecord: function(manager) {
         
     | 
| 
       2316 
     | 
    
         
            -
                      manager.goToState('deleted');
         
     | 
| 
       2317 
     | 
    
         
            -
                    },
         
     | 
| 
       2318 
     | 
    
         
            -
             
     | 
| 
       2319 
     | 
    
         
            -
                    waitingOn: function(manager, object) {
         
     | 
| 
       2320 
     | 
    
         
            -
                      waitingOn(manager, object);
         
     | 
| 
       2321 
     | 
    
         
            -
                      manager.goToState('updated.pending');
         
     | 
| 
       2322 
     | 
    
         
            -
                    },
         
     | 
| 
       2323 
     | 
    
         
            -
             
     | 
| 
       2324 
     | 
    
         
            -
                    invokeLifecycleCallbacks: function(manager, dirtyType) {
         
     | 
| 
       2325 
     | 
    
         
            -
                      var record = get(manager, 'record');
         
     | 
| 
       2326 
     | 
    
         
            -
                      if (dirtyType === 'created') {
         
     | 
| 
       2327 
     | 
    
         
            -
                        record.fire('didCreate', record);
         
     | 
| 
       2328 
     | 
    
         
            -
                      } else {
         
     | 
| 
       2329 
     | 
    
         
            -
                        record.fire('didUpdate', record);
         
     | 
| 
       2330 
     | 
    
         
            -
                      }
         
     | 
| 
       2331 
     | 
    
         
            -
                    }
         
     | 
| 
       2332 
     | 
    
         
            -
                  }),
         
     | 
| 
       2333 
     | 
    
         
            -
             
     | 
| 
       2334 
     | 
    
         
            -
                  // A record is in this state after it has been locally
         
     | 
| 
       2335 
     | 
    
         
            -
                  // created but before the adapter has indicated that
         
     | 
| 
       2336 
     | 
    
         
            -
                  // it has been saved.
         
     | 
| 
       2337 
     | 
    
         
            -
                  created: createdState,
         
     | 
| 
       2338 
     | 
    
         
            -
             
     | 
| 
       2339 
     | 
    
         
            -
                  // A record is in this state if it has already been
         
     | 
| 
       2340 
     | 
    
         
            -
                  // saved to the server, but there are new local changes
         
     | 
| 
       2341 
     | 
    
         
            -
                  // that have not yet been saved.
         
     | 
| 
       2342 
     | 
    
         
            -
                  updated: updatedState
         
     | 
| 
       2343 
     | 
    
         
            -
                }),
         
     | 
| 
       2344 
     | 
    
         
            -
             
     | 
| 
       2345 
     | 
    
         
            -
                // A record is in this state if it was deleted from the store.
         
     | 
| 
       2346 
     | 
    
         
            -
                deleted: DS.State.create({
         
     | 
| 
       2347 
     | 
    
         
            -
                  // FLAGS
         
     | 
| 
       2348 
     | 
    
         
            -
                  isDeleted: true,
         
     | 
| 
       2349 
     | 
    
         
            -
                  isLoaded: true,
         
     | 
| 
       2350 
     | 
    
         
            -
                  isDirty: true,
         
     | 
| 
       2351 
     | 
    
         
            -
             
     | 
| 
       2352 
     | 
    
         
            -
                  // TRANSITIONS
         
     | 
| 
       2353 
     | 
    
         
            -
                  enter: function(manager) {
         
     | 
| 
       2354 
     | 
    
         
            -
                    var record = get(manager, 'record'),
         
     | 
| 
       2355 
     | 
    
         
            -
                        store = get(record, 'store');
         
     | 
| 
       2356 
     | 
    
         
            -
             
     | 
| 
       2357 
     | 
    
         
            -
                    store.removeFromRecordArrays(record);
         
     | 
| 
       2358 
     | 
    
         
            -
                  },
         
     | 
| 
       2359 
     | 
    
         
            -
             
     | 
| 
       2360 
     | 
    
         
            -
                  // SUBSTATES
         
     | 
| 
       2361 
     | 
    
         
            -
             
     | 
| 
       2362 
     | 
    
         
            -
                  // When a record is deleted, it enters the `start`
         
     | 
| 
       2363 
     | 
    
         
            -
                  // state. It will exit this state when the record's
         
     | 
| 
       2364 
     | 
    
         
            -
                  // transaction starts to commit.
         
     | 
| 
       2365 
     | 
    
         
            -
                  start: DS.State.create({
         
     | 
| 
       2366 
     | 
    
         
            -
                    // TRANSITIONS
         
     | 
| 
       2367 
     | 
    
         
            -
                    enter: function(manager) {
         
     | 
| 
       2368 
     | 
    
         
            -
                      var record = get(manager, 'record');
         
     | 
| 
       2369 
     | 
    
         
            -
             
     | 
| 
       2370 
     | 
    
         
            -
                      record.withTransaction(function(t) {
         
     | 
| 
       2371 
     | 
    
         
            -
                        t.recordBecameDirty('deleted', record);
         
     | 
| 
       2372 
     | 
    
         
            -
                      });
         
     | 
| 
       2373 
     | 
    
         
            -
                    },
         
     | 
| 
       2374 
     | 
    
         
            -
             
     | 
| 
       2375 
     | 
    
         
            -
                    // EVENTS
         
     | 
| 
       2376 
     | 
    
         
            -
                    willCommit: function(manager) {
         
     | 
| 
       2377 
     | 
    
         
            -
                      manager.goToState('inFlight');
         
     | 
| 
       2378 
     | 
    
         
            -
                    },
         
     | 
| 
       2379 
     | 
    
         
            -
             
     | 
| 
       2380 
     | 
    
         
            -
                    rollback: function(manager) {
         
     | 
| 
       2381 
     | 
    
         
            -
                      var record = get(manager, 'record'),
         
     | 
| 
       2382 
     | 
    
         
            -
                          data = get(record, 'data');
         
     | 
| 
       2383 
     | 
    
         
            -
             
     | 
| 
       2384 
     | 
    
         
            -
                      data.rollback();
         
     | 
| 
       2385 
     | 
    
         
            -
                      record.withTransaction(function(t) {
         
     | 
| 
       2386 
     | 
    
         
            -
                        t.recordBecameClean('deleted', record);
         
     | 
| 
       2387 
     | 
    
         
            -
                      });
         
     | 
| 
       2388 
     | 
    
         
            -
                      manager.goToState('loaded');
         
     | 
| 
       2389 
     | 
    
         
            -
                    }
         
     | 
| 
       2390 
     | 
    
         
            -
                  }),
         
     | 
| 
       2391 
     | 
    
         
            -
             
     | 
| 
       2392 
     | 
    
         
            -
                  // After a record's transaction is committing, but
         
     | 
| 
       2393 
     | 
    
         
            -
                  // before the adapter indicates that the deletion
         
     | 
| 
       2394 
     | 
    
         
            -
                  // has saved to the server, a record is in the
         
     | 
| 
       2395 
     | 
    
         
            -
                  // `inFlight` substate of `deleted`.
         
     | 
| 
       2396 
     | 
    
         
            -
                  inFlight: DS.State.create({
         
     | 
| 
       2397 
     | 
    
         
            -
                    // FLAGS
         
     | 
| 
       2398 
     | 
    
         
            -
                    isSaving: true,
         
     | 
| 
       2399 
     | 
    
         
            -
             
     | 
| 
       2400 
     | 
    
         
            -
                    // TRANSITIONS
         
     | 
| 
       2401 
     | 
    
         
            -
                    enter: function(manager) {
         
     | 
| 
       2402 
     | 
    
         
            -
                      var record = get(manager, 'record');
         
     | 
| 
       2403 
     | 
    
         
            -
             
     | 
| 
       2404 
     | 
    
         
            -
                      record.withTransaction(function (t) {
         
     | 
| 
       2405 
     | 
    
         
            -
                        t.recordBecameInFlight('deleted', record);
         
     | 
| 
       2406 
     | 
    
         
            -
                      });
         
     | 
| 
       2407 
     | 
    
         
            -
                    },
         
     | 
| 
       2408 
     | 
    
         
            -
             
     | 
| 
       2409 
     | 
    
         
            -
                    // EVENTS
         
     | 
| 
       2410 
     | 
    
         
            -
                    didCommit: function(manager) {
         
     | 
| 
       2411 
     | 
    
         
            -
                      var record = get(manager, 'record');
         
     | 
| 
       2412 
     | 
    
         
            -
             
     | 
| 
       2413 
     | 
    
         
            -
                      record.withTransaction(function(t) {
         
     | 
| 
       2414 
     | 
    
         
            -
                        t.recordBecameClean('inflight', record);
         
     | 
| 
       2415 
     | 
    
         
            -
                      });
         
     | 
| 
       2416 
     | 
    
         
            -
             
     | 
| 
       2417 
     | 
    
         
            -
                      manager.goToState('saved');
         
     | 
| 
       2418 
     | 
    
         
            -
             
     | 
| 
       2419 
     | 
    
         
            -
                      manager.send('invokeLifecycleCallbacks');
         
     | 
| 
       2420 
     | 
    
         
            -
                    }
         
     | 
| 
       2421 
     | 
    
         
            -
                  }),
         
     | 
| 
       2422 
     | 
    
         
            -
             
     | 
| 
       2423 
     | 
    
         
            -
                  // Once the adapter indicates that the deletion has
         
     | 
| 
       2424 
     | 
    
         
            -
                  // been saved, the record enters the `saved` substate
         
     | 
| 
       2425 
     | 
    
         
            -
                  // of `deleted`.
         
     | 
| 
       2426 
     | 
    
         
            -
                  saved: DS.State.create({
         
     | 
| 
       2427 
     | 
    
         
            -
                    // FLAGS
         
     | 
| 
       2428 
     | 
    
         
            -
                    isDirty: false,
         
     | 
| 
       2429 
     | 
    
         
            -
             
     | 
| 
       2430 
     | 
    
         
            -
                    invokeLifecycleCallbacks: function(manager) {
         
     | 
| 
       2431 
     | 
    
         
            -
                      var record = get(manager, 'record');
         
     | 
| 
       2432 
     | 
    
         
            -
                      record.fire('didDelete', record);
         
     | 
| 
       2433 
     | 
    
         
            -
                    }
         
     | 
| 
       2434 
     | 
    
         
            -
                  })
         
     | 
| 
       2435 
     | 
    
         
            -
                }),
         
     | 
| 
       2436 
     | 
    
         
            -
             
     | 
| 
       2437 
     | 
    
         
            -
                // If the adapter indicates that there was an unknown
         
     | 
| 
       2438 
     | 
    
         
            -
                // error saving a record, the record enters the `error`
         
     | 
| 
       2439 
     | 
    
         
            -
                // state.
         
     | 
| 
       2440 
     | 
    
         
            -
                error: DS.State.create({
         
     | 
| 
       2441 
     | 
    
         
            -
                  isError: true,
         
     | 
| 
       2442 
     | 
    
         
            -
             
     | 
| 
       2443 
     | 
    
         
            -
                  // EVENTS
         
     | 
| 
       2444 
     | 
    
         
            -
             
     | 
| 
       2445 
     | 
    
         
            -
                  invokeLifecycleCallbacks: function(manager) {
         
     | 
| 
       2446 
     | 
    
         
            -
                    var record = get(manager, 'record');
         
     | 
| 
       2447 
     | 
    
         
            -
                    record.fire('becameError', record);
         
     | 
| 
       2448 
     | 
    
         
            -
                  }
         
     | 
| 
       2449 
     | 
    
         
            -
                })
         
     | 
| 
       2450 
     | 
    
         
            -
              })
         
     | 
| 
       2451 
     | 
    
         
            -
            };
         
     | 
| 
       2452 
     | 
    
         
            -
             
     | 
| 
       2453 
     | 
    
         
            -
            DS.StateManager = Ember.StateManager.extend({
         
     | 
| 
       2454 
     | 
    
         
            -
              record: null,
         
     | 
| 
       2455 
     | 
    
         
            -
              initialState: 'rootState',
         
     | 
| 
       2456 
     | 
    
         
            -
              states: states
         
     | 
| 
       2457 
     | 
    
         
            -
            });
         
     | 
| 
       2458 
     | 
    
         
            -
             
     | 
| 
       2459 
     | 
    
         
            -
            })();
         
     | 
| 
       2460 
     | 
    
         
            -
             
     | 
| 
       2461 
     | 
    
         
            -
             
     | 
| 
       2462 
     | 
    
         
            -
             
     | 
| 
       2463 
     | 
    
         
            -
            (function() {
         
     | 
| 
       2464 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set;
         
     | 
| 
       2465 
     | 
    
         
            -
             
     | 
| 
       2466 
     | 
    
         
            -
            //  When a record is changed on the client, it is considered "dirty"--there are
         
     | 
| 
       2467 
     | 
    
         
            -
            //  pending changes that need to be saved to a persistence layer, such as a
         
     | 
| 
       2468 
     | 
    
         
            -
            //  server.
         
     | 
| 
       2469 
     | 
    
         
            -
            //
         
     | 
| 
       2470 
     | 
    
         
            -
            //  If the record is rolled back, it re-enters a clean state, any changes are
         
     | 
| 
       2471 
     | 
    
         
            -
            //  discarded, and its attributes are reset back to the last known good copy
         
     | 
| 
       2472 
     | 
    
         
            -
            //  of the data that came from the server.
         
     | 
| 
       2473 
     | 
    
         
            -
            //
         
     | 
| 
       2474 
     | 
    
         
            -
            //  If the record is committed, the changes are sent to the server to be saved,
         
     | 
| 
       2475 
     | 
    
         
            -
            //  and once the server confirms that they are valid, the record's "canonical"
         
     | 
| 
       2476 
     | 
    
         
            -
            //  data becomes the original canonical data plus the changes merged in.
         
     | 
| 
       2477 
     | 
    
         
            -
            //
         
     | 
| 
       2478 
     | 
    
         
            -
            //  A DataProxy is an object that encapsulates this change tracking. It
         
     | 
| 
       2479 
     | 
    
         
            -
            //  contains three buckets:
         
     | 
| 
       2480 
     | 
    
         
            -
            //
         
     | 
| 
       2481 
     | 
    
         
            -
            //  * `savedData` - the last-known copy of the data from the server
         
     | 
| 
       2482 
     | 
    
         
            -
            //  * `unsavedData` - a hash that contains any changes that have not yet
         
     | 
| 
       2483 
     | 
    
         
            -
            //     been committed
         
     | 
| 
       2484 
     | 
    
         
            -
            //  * `associations` - this is similar to `savedData`, but holds the client
         
     | 
| 
       2485 
     | 
    
         
            -
            //    ids of associated records
         
     | 
| 
       2486 
     | 
    
         
            -
            //
         
     | 
| 
       2487 
     | 
    
         
            -
            //  When setting a property on the object, the value is placed into the
         
     | 
| 
       2488 
     | 
    
         
            -
            //  `unsavedData` bucket:
         
     | 
| 
       2489 
     | 
    
         
            -
            //
         
     | 
| 
       2490 
     | 
    
         
            -
            //      proxy.set('key', 'value');
         
     | 
| 
       2491 
     | 
    
         
            -
            //
         
     | 
| 
       2492 
     | 
    
         
            -
            //      // unsavedData:
         
     | 
| 
       2493 
     | 
    
         
            -
            //      {
         
     | 
| 
       2494 
     | 
    
         
            -
            //        key: "value"
         
     | 
| 
       2495 
     | 
    
         
            -
            //      }
         
     | 
| 
       2496 
     | 
    
         
            -
            //
         
     | 
| 
       2497 
     | 
    
         
            -
            //  When retrieving a property from the object, it first looks to see
         
     | 
| 
       2498 
     | 
    
         
            -
            //  if that value exists in the `unsavedData` bucket, and returns it if so.
         
     | 
| 
       2499 
     | 
    
         
            -
            //  Otherwise, it returns the value from the `savedData` bucket.
         
     | 
| 
       2500 
     | 
    
         
            -
            //
         
     | 
| 
       2501 
     | 
    
         
            -
            //  When the adapter notifies a record that it has been saved, it merges the
         
     | 
| 
       2502 
     | 
    
         
            -
            //  `unsavedData` bucket into the `savedData` bucket. If the record's
         
     | 
| 
       2503 
     | 
    
         
            -
            //  transaction is rolled back, the `unsavedData` hash is simply discarded.
         
     | 
| 
       2504 
     | 
    
         
            -
            //
         
     | 
| 
       2505 
     | 
    
         
            -
            //  This object is a regular JS object for performance. It is only
         
     | 
| 
       2506 
     | 
    
         
            -
            //  used internally for bookkeeping purposes.
         
     | 
| 
       2507 
     | 
    
         
            -
             
     | 
| 
       2508 
     | 
    
         
            -
            var DataProxy = DS._DataProxy = function(record) {
         
     | 
| 
       2509 
     | 
    
         
            -
              this.record = record;
         
     | 
| 
       2510 
     | 
    
         
            -
             
     | 
| 
       2511 
     | 
    
         
            -
              this.unsavedData = {};
         
     | 
| 
       2512 
     | 
    
         
            -
             
     | 
| 
       2513 
     | 
    
         
            -
              this.associations = {};
         
     | 
| 
       2514 
     | 
    
         
            -
            };
         
     | 
| 
       2515 
     | 
    
         
            -
             
     | 
| 
       2516 
     | 
    
         
            -
            DataProxy.prototype = {
         
     | 
| 
       2517 
     | 
    
         
            -
              get: function(key) { return Ember.get(this, key); },
         
     | 
| 
       2518 
     | 
    
         
            -
              set: function(key, value) { return Ember.set(this, key, value); },
         
     | 
| 
       2519 
     | 
    
         
            -
             
     | 
| 
       2520 
     | 
    
         
            -
              setAssociation: function(key, value) {
         
     | 
| 
       2521 
     | 
    
         
            -
                this.associations[key] = value;
         
     | 
| 
       2522 
     | 
    
         
            -
              },
         
     | 
| 
       2523 
     | 
    
         
            -
             
     | 
| 
       2524 
     | 
    
         
            -
              savedData: function() {
         
     | 
| 
       2525 
     | 
    
         
            -
                var savedData = this._savedData;
         
     | 
| 
       2526 
     | 
    
         
            -
                if (savedData) { return savedData; }
         
     | 
| 
       2527 
     | 
    
         
            -
             
     | 
| 
       2528 
     | 
    
         
            -
                var record = this.record,
         
     | 
| 
       2529 
     | 
    
         
            -
                    clientId = get(record, 'clientId'),
         
     | 
| 
       2530 
     | 
    
         
            -
                    store = get(record, 'store');
         
     | 
| 
       2531 
     | 
    
         
            -
             
     | 
| 
       2532 
     | 
    
         
            -
                if (store) {
         
     | 
| 
       2533 
     | 
    
         
            -
                  savedData = store.dataForRecord(record);
         
     | 
| 
       2534 
     | 
    
         
            -
                  this._savedData = savedData;
         
     | 
| 
       2535 
     | 
    
         
            -
                  return savedData;
         
     | 
| 
       2536 
     | 
    
         
            -
                }
         
     | 
| 
       2537 
     | 
    
         
            -
              },
         
     | 
| 
       2538 
     | 
    
         
            -
             
     | 
| 
       2539 
     | 
    
         
            -
              unknownProperty: function(key) {
         
     | 
| 
       2540 
     | 
    
         
            -
                var unsavedData = this.unsavedData,
         
     | 
| 
       2541 
     | 
    
         
            -
                    associations = this.associations,
         
     | 
| 
       2542 
     | 
    
         
            -
                    savedData = this.savedData(),
         
     | 
| 
       2543 
     | 
    
         
            -
                    store;
         
     | 
| 
       2544 
     | 
    
         
            -
             
     | 
| 
       2545 
     | 
    
         
            -
                var value = unsavedData[key], association;
         
     | 
| 
       2546 
     | 
    
         
            -
             
     | 
| 
       2547 
     | 
    
         
            -
                // if this is a belongsTo association, this will
         
     | 
| 
       2548 
     | 
    
         
            -
                // be a clientId.
         
     | 
| 
       2549 
     | 
    
         
            -
                association = associations[key];
         
     | 
| 
       2550 
     | 
    
         
            -
             
     | 
| 
       2551 
     | 
    
         
            -
                if (association !== undefined) {
         
     | 
| 
       2552 
     | 
    
         
            -
                  store = get(this.record, 'store');
         
     | 
| 
       2553 
     | 
    
         
            -
                  return store.clientIdToId[association];
         
     | 
| 
       2554 
     | 
    
         
            -
                }
         
     | 
| 
       2555 
     | 
    
         
            -
             
     | 
| 
       2556 
     | 
    
         
            -
                if (savedData && value === undefined) {
         
     | 
| 
       2557 
     | 
    
         
            -
                  value = savedData[key];
         
     | 
| 
       2558 
     | 
    
         
            -
                }
         
     | 
| 
       2559 
     | 
    
         
            -
             
     | 
| 
       2560 
     | 
    
         
            -
                return value;
         
     | 
| 
       2561 
     | 
    
         
            -
              },
         
     | 
| 
       2562 
     | 
    
         
            -
             
     | 
| 
       2563 
     | 
    
         
            -
              setUnknownProperty: function(key, value) {
         
     | 
| 
       2564 
     | 
    
         
            -
                var record = this.record,
         
     | 
| 
       2565 
     | 
    
         
            -
                    unsavedData = this.unsavedData;
         
     | 
| 
       2566 
     | 
    
         
            -
             
     | 
| 
       2567 
     | 
    
         
            -
                unsavedData[key] = value;
         
     | 
| 
       2568 
     | 
    
         
            -
             
     | 
| 
       2569 
     | 
    
         
            -
                record.hashWasUpdated();
         
     | 
| 
       2570 
     | 
    
         
            -
             
     | 
| 
       2571 
     | 
    
         
            -
                return value;
         
     | 
| 
       2572 
     | 
    
         
            -
              },
         
     | 
| 
       2573 
     | 
    
         
            -
             
     | 
| 
       2574 
     | 
    
         
            -
              commit: function() {
         
     | 
| 
       2575 
     | 
    
         
            -
                this.saveData();
         
     | 
| 
       2576 
     | 
    
         
            -
             
     | 
| 
       2577 
     | 
    
         
            -
                this.record.notifyPropertyChange('data');
         
     | 
| 
       2578 
     | 
    
         
            -
              },
         
     | 
| 
       2579 
     | 
    
         
            -
             
     | 
| 
       2580 
     | 
    
         
            -
              rollback: function() {
         
     | 
| 
       2581 
     | 
    
         
            -
                this.unsavedData = {};
         
     | 
| 
       2582 
     | 
    
         
            -
             
     | 
| 
       2583 
     | 
    
         
            -
                this.record.notifyPropertyChange('data');
         
     | 
| 
       2584 
     | 
    
         
            -
              },
         
     | 
| 
       2585 
     | 
    
         
            -
             
     | 
| 
       2586 
     | 
    
         
            -
              saveData: function() {
         
     | 
| 
       2587 
     | 
    
         
            -
                var record = this.record;
         
     | 
| 
       2588 
     | 
    
         
            -
             
     | 
| 
       2589 
     | 
    
         
            -
                var unsavedData = this.unsavedData;
         
     | 
| 
       2590 
     | 
    
         
            -
                var savedData = this.savedData();
         
     | 
| 
       2591 
     | 
    
         
            -
             
     | 
| 
       2592 
     | 
    
         
            -
                for (var prop in unsavedData) {
         
     | 
| 
       2593 
     | 
    
         
            -
                  if (unsavedData.hasOwnProperty(prop)) {
         
     | 
| 
       2594 
     | 
    
         
            -
                    savedData[prop] = unsavedData[prop];
         
     | 
| 
       2595 
     | 
    
         
            -
                    delete unsavedData[prop];
         
     | 
| 
       2596 
     | 
    
         
            -
                  }
         
     | 
| 
       2597 
     | 
    
         
            -
                }
         
     | 
| 
       2598 
     | 
    
         
            -
              },
         
     | 
| 
       2599 
     | 
    
         
            -
             
     | 
| 
       2600 
     | 
    
         
            -
              adapterDidUpdate: function() {
         
     | 
| 
       2601 
     | 
    
         
            -
                this.unsavedData = {};
         
     | 
| 
       2602 
     | 
    
         
            -
              }
         
     | 
| 
       2603 
     | 
    
         
            -
            };
         
     | 
| 
       2604 
     | 
    
         
            -
             
     | 
| 
       2605 
     | 
    
         
            -
            })();
         
     | 
| 
       2606 
     | 
    
         
            -
             
     | 
| 
       2607 
     | 
    
         
            -
             
     | 
| 
       2608 
     | 
    
         
            -
             
     | 
| 
       2609 
     | 
    
         
            -
            (function() {
         
     | 
| 
       2610 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set, getPath = Ember.getPath, none = Ember.none;
         
     | 
| 
       2611 
     | 
    
         
            -
             
     | 
| 
       2612 
     | 
    
         
            -
            var retrieveFromCurrentState = Ember.computed(function(key) {
         
     | 
| 
       2613 
     | 
    
         
            -
              return get(getPath(this, 'stateManager.currentState'), key);
         
     | 
| 
       2614 
     | 
    
         
            -
            }).property('stateManager.currentState').cacheable();
         
     | 
| 
       2615 
     | 
    
         
            -
             
     | 
| 
       2616 
     | 
    
         
            -
            DS.Model = Ember.Object.extend(Ember.Evented, {
         
     | 
| 
       2617 
     | 
    
         
            -
              isLoaded: retrieveFromCurrentState,
         
     | 
| 
       2618 
     | 
    
         
            -
              isDirty: retrieveFromCurrentState,
         
     | 
| 
       2619 
     | 
    
         
            -
              isSaving: retrieveFromCurrentState,
         
     | 
| 
       2620 
     | 
    
         
            -
              isDeleted: retrieveFromCurrentState,
         
     | 
| 
       2621 
     | 
    
         
            -
              isError: retrieveFromCurrentState,
         
     | 
| 
       2622 
     | 
    
         
            -
              isNew: retrieveFromCurrentState,
         
     | 
| 
       2623 
     | 
    
         
            -
              isPending: retrieveFromCurrentState,
         
     | 
| 
       2624 
     | 
    
         
            -
              isValid: retrieveFromCurrentState,
         
     | 
| 
       2625 
     | 
    
         
            -
             
     | 
| 
       2626 
     | 
    
         
            -
              clientId: null,
         
     | 
| 
       2627 
     | 
    
         
            -
              transaction: null,
         
     | 
| 
       2628 
     | 
    
         
            -
              stateManager: null,
         
     | 
| 
       2629 
     | 
    
         
            -
              pendingQueue: null,
         
     | 
| 
       2630 
     | 
    
         
            -
              errors: null,
         
     | 
| 
       2631 
     | 
    
         
            -
             
     | 
| 
       2632 
     | 
    
         
            -
              // because unknownProperty is used, any internal property
         
     | 
| 
       2633 
     | 
    
         
            -
              // must be initialized here.
         
     | 
| 
       2634 
     | 
    
         
            -
              primaryKey: 'id',
         
     | 
| 
       2635 
     | 
    
         
            -
              id: Ember.computed(function(key, value) {
         
     | 
| 
       2636 
     | 
    
         
            -
                var primaryKey = get(this, 'primaryKey'),
         
     | 
| 
       2637 
     | 
    
         
            -
                    data = get(this, 'data');
         
     | 
| 
       2638 
     | 
    
         
            -
             
     | 
| 
       2639 
     | 
    
         
            -
                if (arguments.length === 2) {
         
     | 
| 
       2640 
     | 
    
         
            -
                  set(data, primaryKey, value);
         
     | 
| 
       2641 
     | 
    
         
            -
                  return value;
         
     | 
| 
       2642 
     | 
    
         
            -
                }
         
     | 
| 
       2643 
     | 
    
         
            -
             
     | 
| 
       2644 
     | 
    
         
            -
                return data && get(data, primaryKey);
         
     | 
| 
       2645 
     | 
    
         
            -
              }).property('primaryKey', 'data'),
         
     | 
| 
       2646 
     | 
    
         
            -
             
     | 
| 
       2647 
     | 
    
         
            -
              // The following methods are callbacks invoked by `toJSON`. You
         
     | 
| 
       2648 
     | 
    
         
            -
              // can override one of the callbacks to override specific behavior,
         
     | 
| 
       2649 
     | 
    
         
            -
              // or toJSON itself.
         
     | 
| 
       2650 
     | 
    
         
            -
              //
         
     | 
| 
       2651 
     | 
    
         
            -
              // If you override toJSON, you can invoke these callbacks manually
         
     | 
| 
       2652 
     | 
    
         
            -
              // to get the default behavior.
         
     | 
| 
       2653 
     | 
    
         
            -
             
     | 
| 
       2654 
     | 
    
         
            -
              /**
         
     | 
| 
       2655 
     | 
    
         
            -
                Add the record's primary key to the JSON hash.
         
     | 
| 
       2656 
     | 
    
         
            -
             
     | 
| 
       2657 
     | 
    
         
            -
                The default implementation uses the record's specified `primaryKey`
         
     | 
| 
       2658 
     | 
    
         
            -
                and the `id` computed property, which are passed in as parameters.
         
     | 
| 
       2659 
     | 
    
         
            -
             
     | 
| 
       2660 
     | 
    
         
            -
                @param {Object} json the JSON hash being built
         
     | 
| 
       2661 
     | 
    
         
            -
                @param {Number|String} id the record's id
         
     | 
| 
       2662 
     | 
    
         
            -
                @param {String} key the primaryKey for the record
         
     | 
| 
       2663 
     | 
    
         
            -
              */
         
     | 
| 
       2664 
     | 
    
         
            -
              addIdToJSON: function(json, id, key) {
         
     | 
| 
       2665 
     | 
    
         
            -
                if (id) { json[key] = id; }
         
     | 
| 
       2666 
     | 
    
         
            -
              },
         
     | 
| 
       2667 
     | 
    
         
            -
             
     | 
| 
       2668 
     | 
    
         
            -
              /**
         
     | 
| 
       2669 
     | 
    
         
            -
                Add the attributes' current values to the JSON hash.
         
     | 
| 
       2670 
     | 
    
         
            -
             
     | 
| 
       2671 
     | 
    
         
            -
                The default implementation gets the current value of each
         
     | 
| 
       2672 
     | 
    
         
            -
                attribute from the `data`, and uses a `defaultValue` if
         
     | 
| 
       2673 
     | 
    
         
            -
                specified in the `DS.attr` definition.
         
     | 
| 
       2674 
     | 
    
         
            -
             
     | 
| 
       2675 
     | 
    
         
            -
                @param {Object} json the JSON hash being build
         
     | 
| 
       2676 
     | 
    
         
            -
                @param {Ember.Map} attributes a Map of attributes
         
     | 
| 
       2677 
     | 
    
         
            -
                @param {DataProxy} data the record's data, accessed with `get` and `set`.
         
     | 
| 
       2678 
     | 
    
         
            -
              */
         
     | 
| 
       2679 
     | 
    
         
            -
              addAttributesToJSON: function(json, attributes, data) {
         
     | 
| 
       2680 
     | 
    
         
            -
                attributes.forEach(function(name, meta) {
         
     | 
| 
       2681 
     | 
    
         
            -
                  var key = meta.key(this.constructor),
         
     | 
| 
       2682 
     | 
    
         
            -
                      value = get(data, key);
         
     | 
| 
       2683 
     | 
    
         
            -
             
     | 
| 
       2684 
     | 
    
         
            -
                  if (value === undefined) {
         
     | 
| 
       2685 
     | 
    
         
            -
                    value = meta.options.defaultValue;
         
     | 
| 
       2686 
     | 
    
         
            -
                  }
         
     | 
| 
       2687 
     | 
    
         
            -
             
     | 
| 
       2688 
     | 
    
         
            -
                  json[key] = value;
         
     | 
| 
       2689 
     | 
    
         
            -
                }, this);
         
     | 
| 
       2690 
     | 
    
         
            -
              },
         
     | 
| 
       2691 
     | 
    
         
            -
             
     | 
| 
       2692 
     | 
    
         
            -
              /**
         
     | 
| 
       2693 
     | 
    
         
            -
                Add the value of a `hasMany` association to the JSON hash.
         
     | 
| 
       2694 
     | 
    
         
            -
             
     | 
| 
       2695 
     | 
    
         
            -
                The default implementation honors the `embedded` option
         
     | 
| 
       2696 
     | 
    
         
            -
                passed to `DS.hasMany`. If embedded, `toJSON` is recursively
         
     | 
| 
       2697 
     | 
    
         
            -
                called on the child records. If not, the `id` of each
         
     | 
| 
       2698 
     | 
    
         
            -
                record is added.
         
     | 
| 
       2699 
     | 
    
         
            -
             
     | 
| 
       2700 
     | 
    
         
            -
                Note that if a record is not embedded and does not
         
     | 
| 
       2701 
     | 
    
         
            -
                yet have an `id` (usually provided by the server), it
         
     | 
| 
       2702 
     | 
    
         
            -
                will not be included in the output.
         
     | 
| 
       2703 
     | 
    
         
            -
             
     | 
| 
       2704 
     | 
    
         
            -
                @param {Object} json the JSON hash being built
         
     | 
| 
       2705 
     | 
    
         
            -
                @param {DataProxy} data the record's data, accessed with `get` and `set`.
         
     | 
| 
       2706 
     | 
    
         
            -
                @param {Object} meta information about the association
         
     | 
| 
       2707 
     | 
    
         
            -
                @param {Object} options options passed to `toJSON`
         
     | 
| 
       2708 
     | 
    
         
            -
              */
         
     | 
| 
       2709 
     | 
    
         
            -
              addHasManyToJSON: function(json, data, meta, options) {
         
     | 
| 
       2710 
     | 
    
         
            -
                var key = meta.key,
         
     | 
| 
       2711 
     | 
    
         
            -
                    manyArray = get(this, key),
         
     | 
| 
       2712 
     | 
    
         
            -
                    records = [], i, l,
         
     | 
| 
       2713 
     | 
    
         
            -
                    clientId, id;
         
     | 
| 
       2714 
     | 
    
         
            -
             
     | 
| 
       2715 
     | 
    
         
            -
                if (meta.options.embedded) {
         
     | 
| 
       2716 
     | 
    
         
            -
                  // TODO: Avoid materializing embedded hashes if possible
         
     | 
| 
       2717 
     | 
    
         
            -
                  manyArray.forEach(function(record) {
         
     | 
| 
       2718 
     | 
    
         
            -
                    records.push(record.toJSON(options));
         
     | 
| 
       2719 
     | 
    
         
            -
                  });
         
     | 
| 
       2720 
     | 
    
         
            -
                } else {
         
     | 
| 
       2721 
     | 
    
         
            -
                  var clientIds = get(manyArray, 'content');
         
     | 
| 
       2722 
     | 
    
         
            -
             
     | 
| 
       2723 
     | 
    
         
            -
                  for (i=0, l=clientIds.length; i<l; i++) {
         
     | 
| 
       2724 
     | 
    
         
            -
                    clientId = clientIds[i];
         
     | 
| 
       2725 
     | 
    
         
            -
                    id = get(this, 'store').clientIdToId[clientId];
         
     | 
| 
       2726 
     | 
    
         
            -
             
     | 
| 
       2727 
     | 
    
         
            -
                    if (id !== undefined) {
         
     | 
| 
       2728 
     | 
    
         
            -
                      records.push(id);
         
     | 
| 
       2729 
     | 
    
         
            -
                    }
         
     | 
| 
       2730 
     | 
    
         
            -
                  }
         
     | 
| 
       2731 
     | 
    
         
            -
                }
         
     | 
| 
       2732 
     | 
    
         
            -
             
     | 
| 
       2733 
     | 
    
         
            -
                key = meta.options.key || get(this, 'namingConvention').keyToJSONKey(key);
         
     | 
| 
       2734 
     | 
    
         
            -
                json[key] = records;
         
     | 
| 
       2735 
     | 
    
         
            -
              },
         
     | 
| 
       2736 
     | 
    
         
            -
             
     | 
| 
       2737 
     | 
    
         
            -
              /**
         
     | 
| 
       2738 
     | 
    
         
            -
                Add the value of a `belongsTo` association to the JSON hash.
         
     | 
| 
       2739 
     | 
    
         
            -
             
     | 
| 
       2740 
     | 
    
         
            -
                The default implementation always includes the `id`.
         
     | 
| 
       2741 
     | 
    
         
            -
             
     | 
| 
       2742 
     | 
    
         
            -
                @param {Object} json the JSON hash being built
         
     | 
| 
       2743 
     | 
    
         
            -
                @param {DataProxy} data the record's data, accessed with `get` and `set`.
         
     | 
| 
       2744 
     | 
    
         
            -
                @param {Object} meta information about the association
         
     | 
| 
       2745 
     | 
    
         
            -
                @param {Object} options options passed to `toJSON`
         
     | 
| 
       2746 
     | 
    
         
            -
              */
         
     | 
| 
       2747 
     | 
    
         
            -
              addBelongsToToJSON: function(json, data, meta, options) {
         
     | 
| 
       2748 
     | 
    
         
            -
                var key = meta.key, value, id;
         
     | 
| 
       2749 
     | 
    
         
            -
             
     | 
| 
       2750 
     | 
    
         
            -
                if (meta.options.embedded) {
         
     | 
| 
       2751 
     | 
    
         
            -
                  key = meta.options.key || get(this, 'namingConvention').keyToJSONKey(key);
         
     | 
| 
       2752 
     | 
    
         
            -
                  value = get(data.record, key);
         
     | 
| 
       2753 
     | 
    
         
            -
                  json[key] = value ? value.toJSON(options) : null;
         
     | 
| 
       2754 
     | 
    
         
            -
                } else {
         
     | 
| 
       2755 
     | 
    
         
            -
                  key = meta.options.key || get(this, 'namingConvention').foreignKey(key);
         
     | 
| 
       2756 
     | 
    
         
            -
                  id = data.get(key);
         
     | 
| 
       2757 
     | 
    
         
            -
                  json[key] = none(id) ? null : id;
         
     | 
| 
       2758 
     | 
    
         
            -
                }
         
     | 
| 
       2759 
     | 
    
         
            -
              },
         
     | 
| 
       2760 
     | 
    
         
            -
              /**
         
     | 
| 
       2761 
     | 
    
         
            -
                Create a JSON representation of the record, including its `id`,
         
     | 
| 
       2762 
     | 
    
         
            -
                attributes and associations. Honor any settings defined on the
         
     | 
| 
       2763 
     | 
    
         
            -
                attributes or associations (such as `embedded` or `key`).
         
     | 
| 
       2764 
     | 
    
         
            -
              */
         
     | 
| 
       2765 
     | 
    
         
            -
              toJSON: function(options) {
         
     | 
| 
       2766 
     | 
    
         
            -
                var data = get(this, 'data'),
         
     | 
| 
       2767 
     | 
    
         
            -
                    result = {},
         
     | 
| 
       2768 
     | 
    
         
            -
                    type = this.constructor,
         
     | 
| 
       2769 
     | 
    
         
            -
                    attributes = get(type, 'attributes'),
         
     | 
| 
       2770 
     | 
    
         
            -
                    primaryKey = get(this, 'primaryKey'),
         
     | 
| 
       2771 
     | 
    
         
            -
                    id = get(this, 'id'),
         
     | 
| 
       2772 
     | 
    
         
            -
                    store = get(this, 'store'),
         
     | 
| 
       2773 
     | 
    
         
            -
                    associations;
         
     | 
| 
       2774 
     | 
    
         
            -
             
     | 
| 
       2775 
     | 
    
         
            -
                options = options || {};
         
     | 
| 
       2776 
     | 
    
         
            -
             
     | 
| 
       2777 
     | 
    
         
            -
                // delegate to `addIdToJSON` callback
         
     | 
| 
       2778 
     | 
    
         
            -
                this.addIdToJSON(result, id, primaryKey);
         
     | 
| 
       2779 
     | 
    
         
            -
             
     | 
| 
       2780 
     | 
    
         
            -
                // delegate to `addAttributesToJSON` callback
         
     | 
| 
       2781 
     | 
    
         
            -
                this.addAttributesToJSON(result, attributes, data);
         
     | 
| 
       2782 
     | 
    
         
            -
             
     | 
| 
       2783 
     | 
    
         
            -
                associations = get(type, 'associationsByName');
         
     | 
| 
       2784 
     | 
    
         
            -
             
     | 
| 
       2785 
     | 
    
         
            -
                // add associations, delegating to `addHasManyToJSON` and
         
     | 
| 
       2786 
     | 
    
         
            -
                // `addBelongsToToJSON`.
         
     | 
| 
       2787 
     | 
    
         
            -
                associations.forEach(function(key, meta) {
         
     | 
| 
       2788 
     | 
    
         
            -
                  if (options.associations && meta.kind === 'hasMany') {
         
     | 
| 
       2789 
     | 
    
         
            -
                    this.addHasManyToJSON(result, data, meta, options);
         
     | 
| 
       2790 
     | 
    
         
            -
                  } else if (meta.kind === 'belongsTo') {
         
     | 
| 
       2791 
     | 
    
         
            -
                    this.addBelongsToToJSON(result, data, meta, options);
         
     | 
| 
       2792 
     | 
    
         
            -
                  }
         
     | 
| 
       2793 
     | 
    
         
            -
                }, this);
         
     | 
| 
       2794 
     | 
    
         
            -
             
     | 
| 
       2795 
     | 
    
         
            -
                return result;
         
     | 
| 
       2796 
     | 
    
         
            -
              },
         
     | 
| 
       2797 
     | 
    
         
            -
             
     | 
| 
       2798 
     | 
    
         
            -
              data: Ember.computed(function() {
         
     | 
| 
       2799 
     | 
    
         
            -
                return new DS._DataProxy(this);
         
     | 
| 
       2800 
     | 
    
         
            -
              }).cacheable(),
         
     | 
| 
       2801 
     | 
    
         
            -
             
     | 
| 
       2802 
     | 
    
         
            -
              didLoad: Ember.K,
         
     | 
| 
       2803 
     | 
    
         
            -
              didUpdate: Ember.K,
         
     | 
| 
       2804 
     | 
    
         
            -
              didCreate: Ember.K,
         
     | 
| 
       2805 
     | 
    
         
            -
              didDelete: Ember.K,
         
     | 
| 
       2806 
     | 
    
         
            -
              becameInvalid: Ember.K,
         
     | 
| 
       2807 
     | 
    
         
            -
              becameError: Ember.K,
         
     | 
| 
       2808 
     | 
    
         
            -
             
     | 
| 
       2809 
     | 
    
         
            -
              init: function() {
         
     | 
| 
       2810 
     | 
    
         
            -
                var stateManager = DS.StateManager.create({
         
     | 
| 
       2811 
     | 
    
         
            -
                  record: this
         
     | 
| 
       2812 
     | 
    
         
            -
                });
         
     | 
| 
       2813 
     | 
    
         
            -
             
     | 
| 
       2814 
     | 
    
         
            -
                set(this, 'pendingQueue', {});
         
     | 
| 
       2815 
     | 
    
         
            -
             
     | 
| 
       2816 
     | 
    
         
            -
                set(this, 'stateManager', stateManager);
         
     | 
| 
       2817 
     | 
    
         
            -
                stateManager.goToState('empty');
         
     | 
| 
       2818 
     | 
    
         
            -
              },
         
     | 
| 
       2819 
     | 
    
         
            -
             
     | 
| 
       2820 
     | 
    
         
            -
              destroy: function() {
         
     | 
| 
       2821 
     | 
    
         
            -
                if (!get(this, 'isDeleted')) {
         
     | 
| 
       2822 
     | 
    
         
            -
                  this.deleteRecord();
         
     | 
| 
       2823 
     | 
    
         
            -
                }
         
     | 
| 
       2824 
     | 
    
         
            -
                this._super();
         
     | 
| 
       2825 
     | 
    
         
            -
              },
         
     | 
| 
       2826 
     | 
    
         
            -
             
     | 
| 
       2827 
     | 
    
         
            -
              send: function(name, context) {
         
     | 
| 
       2828 
     | 
    
         
            -
                return get(this, 'stateManager').send(name, context);
         
     | 
| 
       2829 
     | 
    
         
            -
              },
         
     | 
| 
       2830 
     | 
    
         
            -
             
     | 
| 
       2831 
     | 
    
         
            -
              withTransaction: function(fn) {
         
     | 
| 
       2832 
     | 
    
         
            -
                var transaction = get(this, 'transaction');
         
     | 
| 
       2833 
     | 
    
         
            -
                if (transaction) { fn(transaction); }
         
     | 
| 
       2834 
     | 
    
         
            -
              },
         
     | 
| 
       2835 
     | 
    
         
            -
             
     | 
| 
       2836 
     | 
    
         
            -
              setProperty: function(key, value) {
         
     | 
| 
       2837 
     | 
    
         
            -
                this.send('setProperty', { key: key, value: value });
         
     | 
| 
       2838 
     | 
    
         
            -
              },
         
     | 
| 
       2839 
     | 
    
         
            -
             
     | 
| 
       2840 
     | 
    
         
            -
              deleteRecord: function() {
         
     | 
| 
       2841 
     | 
    
         
            -
                this.send('deleteRecord');
         
     | 
| 
       2842 
     | 
    
         
            -
              },
         
     | 
| 
       2843 
     | 
    
         
            -
             
     | 
| 
       2844 
     | 
    
         
            -
              waitingOn: function(record) {
         
     | 
| 
       2845 
     | 
    
         
            -
                this.send('waitingOn', record);
         
     | 
| 
       2846 
     | 
    
         
            -
              },
         
     | 
| 
       2847 
     | 
    
         
            -
             
     | 
| 
       2848 
     | 
    
         
            -
              notifyHashWasUpdated: function() {
         
     | 
| 
       2849 
     | 
    
         
            -
                var store = get(this, 'store');
         
     | 
| 
       2850 
     | 
    
         
            -
                if (store) {
         
     | 
| 
       2851 
     | 
    
         
            -
                  store.hashWasUpdated(this.constructor, get(this, 'clientId'), this);
         
     | 
| 
       2852 
     | 
    
         
            -
                }
         
     | 
| 
       2853 
     | 
    
         
            -
              },
         
     | 
| 
       2854 
     | 
    
         
            -
             
     | 
| 
       2855 
     | 
    
         
            -
              unknownProperty: function(key) {
         
     | 
| 
       2856 
     | 
    
         
            -
                var data = get(this, 'data');
         
     | 
| 
       2857 
     | 
    
         
            -
             
     | 
| 
       2858 
     | 
    
         
            -
                if (data && key in data) {
         
     | 
| 
       2859 
     | 
    
         
            -
             
     | 
| 
       2860 
     | 
    
         
            -
                }
         
     | 
| 
       2861 
     | 
    
         
            -
              },
         
     | 
| 
       2862 
     | 
    
         
            -
             
     | 
| 
       2863 
     | 
    
         
            -
              setUnknownProperty: function(key, value) {
         
     | 
| 
       2864 
     | 
    
         
            -
                var data = get(this, 'data');
         
     | 
| 
       2865 
     | 
    
         
            -
             
     | 
| 
       2866 
     | 
    
         
            -
                if (data && key in data) {
         
     | 
| 
       2867 
     | 
    
         
            -
             
     | 
| 
       2868 
     | 
    
         
            -
                } else {
         
     | 
| 
       2869 
     | 
    
         
            -
                  return this._super(key, value);
         
     | 
| 
       2870 
     | 
    
         
            -
                }
         
     | 
| 
       2871 
     | 
    
         
            -
              },
         
     | 
| 
       2872 
     | 
    
         
            -
             
     | 
| 
       2873 
     | 
    
         
            -
              namingConvention: {
         
     | 
| 
       2874 
     | 
    
         
            -
                keyToJSONKey: function(key) {
         
     | 
| 
       2875 
     | 
    
         
            -
                  // TODO: Strip off `is` from the front. Example: `isHipster` becomes `hipster`
         
     | 
| 
       2876 
     | 
    
         
            -
                  return Ember.String.decamelize(key);
         
     | 
| 
       2877 
     | 
    
         
            -
                },
         
     | 
| 
       2878 
     | 
    
         
            -
             
     | 
| 
       2879 
     | 
    
         
            -
                foreignKey: function(key) {
         
     | 
| 
       2880 
     | 
    
         
            -
                  return Ember.String.decamelize(key) + '_id';
         
     | 
| 
       2881 
     | 
    
         
            -
                }
         
     | 
| 
       2882 
     | 
    
         
            -
              },
         
     | 
| 
       2883 
     | 
    
         
            -
             
     | 
| 
       2884 
     | 
    
         
            -
              /** @private */
         
     | 
| 
       2885 
     | 
    
         
            -
              hashWasUpdated: function() {
         
     | 
| 
       2886 
     | 
    
         
            -
                // At the end of the run loop, notify record arrays that
         
     | 
| 
       2887 
     | 
    
         
            -
                // this record has changed so they can re-evaluate its contents
         
     | 
| 
       2888 
     | 
    
         
            -
                // to determine membership.
         
     | 
| 
       2889 
     | 
    
         
            -
                Ember.run.once(this, this.notifyHashWasUpdated);
         
     | 
| 
       2890 
     | 
    
         
            -
              },
         
     | 
| 
       2891 
     | 
    
         
            -
             
     | 
| 
       2892 
     | 
    
         
            -
              dataDidChange: Ember.observer(function() {
         
     | 
| 
       2893 
     | 
    
         
            -
                var associations = get(this.constructor, 'associationsByName'),
         
     | 
| 
       2894 
     | 
    
         
            -
                    data = get(this, 'data'), store = get(this, 'store'),
         
     | 
| 
       2895 
     | 
    
         
            -
                    idToClientId = store.idToClientId,
         
     | 
| 
       2896 
     | 
    
         
            -
                    cachedValue;
         
     | 
| 
       2897 
     | 
    
         
            -
             
     | 
| 
       2898 
     | 
    
         
            -
                associations.forEach(function(name, association) {
         
     | 
| 
       2899 
     | 
    
         
            -
                  if (association.kind === 'hasMany') {
         
     | 
| 
       2900 
     | 
    
         
            -
                    cachedValue = this.cacheFor(name);
         
     | 
| 
       2901 
     | 
    
         
            -
             
     | 
| 
       2902 
     | 
    
         
            -
                    if (cachedValue) {
         
     | 
| 
       2903 
     | 
    
         
            -
                      var key = association.options.key || name,
         
     | 
| 
       2904 
     | 
    
         
            -
                          ids = data.get(key) || [];
         
     | 
| 
       2905 
     | 
    
         
            -
                      var clientIds = Ember.ArrayUtils.map(ids, function(id) {
         
     | 
| 
       2906 
     | 
    
         
            -
                        return store.clientIdForId(association.type, id);
         
     | 
| 
       2907 
     | 
    
         
            -
                      });
         
     | 
| 
       2908 
     | 
    
         
            -
             
     | 
| 
       2909 
     | 
    
         
            -
                      set(cachedValue, 'content', Ember.A(clientIds));
         
     | 
| 
       2910 
     | 
    
         
            -
                      cachedValue.fetch();
         
     | 
| 
       2911 
     | 
    
         
            -
                    }
         
     | 
| 
       2912 
     | 
    
         
            -
                  }
         
     | 
| 
       2913 
     | 
    
         
            -
                }, this);
         
     | 
| 
       2914 
     | 
    
         
            -
              }, 'data'),
         
     | 
| 
       2915 
     | 
    
         
            -
             
     | 
| 
       2916 
     | 
    
         
            -
              /**
         
     | 
| 
       2917 
     | 
    
         
            -
                @private
         
     | 
| 
       2918 
     | 
    
         
            -
             
     | 
| 
       2919 
     | 
    
         
            -
                Override the default event firing from Ember.Evented to
         
     | 
| 
       2920 
     | 
    
         
            -
                also call methods with the given name.
         
     | 
| 
       2921 
     | 
    
         
            -
              */
         
     | 
| 
       2922 
     | 
    
         
            -
              fire: function(name) {
         
     | 
| 
       2923 
     | 
    
         
            -
                this[name].apply(this, [].slice.call(arguments, 1));
         
     | 
| 
       2924 
     | 
    
         
            -
                this._super.apply(this, arguments);
         
     | 
| 
       2925 
     | 
    
         
            -
              }
         
     | 
| 
       2926 
     | 
    
         
            -
            });
         
     | 
| 
       2927 
     | 
    
         
            -
             
     | 
| 
       2928 
     | 
    
         
            -
            // Helper function to generate store aliases.
         
     | 
| 
       2929 
     | 
    
         
            -
            // This returns a function that invokes the named alias
         
     | 
| 
       2930 
     | 
    
         
            -
            // on the default store, but injects the class as the
         
     | 
| 
       2931 
     | 
    
         
            -
            // first parameter.
         
     | 
| 
       2932 
     | 
    
         
            -
            var storeAlias = function(methodName) {
         
     | 
| 
       2933 
     | 
    
         
            -
              return function() {
         
     | 
| 
       2934 
     | 
    
         
            -
                var store = get(DS, 'defaultStore'),
         
     | 
| 
       2935 
     | 
    
         
            -
                    args = [].slice.call(arguments);
         
     | 
| 
       2936 
     | 
    
         
            -
             
     | 
| 
       2937 
     | 
    
         
            -
                args.unshift(this);
         
     | 
| 
       2938 
     | 
    
         
            -
                return store[methodName].apply(store, args);
         
     | 
| 
       2939 
     | 
    
         
            -
              };
         
     | 
| 
       2940 
     | 
    
         
            -
            };
         
     | 
| 
       2941 
     | 
    
         
            -
             
     | 
| 
       2942 
     | 
    
         
            -
            DS.Model.reopenClass({
         
     | 
| 
       2943 
     | 
    
         
            -
              find: storeAlias('find'),
         
     | 
| 
       2944 
     | 
    
         
            -
              filter: storeAlias('filter'),
         
     | 
| 
       2945 
     | 
    
         
            -
             
     | 
| 
       2946 
     | 
    
         
            -
              _create: DS.Model.create,
         
     | 
| 
       2947 
     | 
    
         
            -
             
     | 
| 
       2948 
     | 
    
         
            -
              create: function() {
         
     | 
| 
       2949 
     | 
    
         
            -
                throw new Ember.Error("You should not call `create` on a model. Instead, call `createRecord` with the attributes you would like to set.");
         
     | 
| 
       2950 
     | 
    
         
            -
              },
         
     | 
| 
       2951 
     | 
    
         
            -
             
     | 
| 
       2952 
     | 
    
         
            -
              createRecord: storeAlias('createRecord')
         
     | 
| 
       2953 
     | 
    
         
            -
            });
         
     | 
| 
       2954 
     | 
    
         
            -
             
     | 
| 
       2955 
     | 
    
         
            -
            })();
         
     | 
| 
       2956 
     | 
    
         
            -
             
     | 
| 
       2957 
     | 
    
         
            -
             
     | 
| 
       2958 
     | 
    
         
            -
             
     | 
| 
       2959 
     | 
    
         
            -
            (function() {
         
     | 
| 
       2960 
     | 
    
         
            -
            var get = Ember.get, getPath = Ember.getPath;
         
     | 
| 
       2961 
     | 
    
         
            -
            DS.Model.reopenClass({
         
     | 
| 
       2962 
     | 
    
         
            -
              attributes: Ember.computed(function() {
         
     | 
| 
       2963 
     | 
    
         
            -
                var map = Ember.Map.create();
         
     | 
| 
       2964 
     | 
    
         
            -
             
     | 
| 
       2965 
     | 
    
         
            -
                this.eachComputedProperty(function(name, meta) {
         
     | 
| 
       2966 
     | 
    
         
            -
                  if (meta.isAttribute) { map.set(name, meta); }
         
     | 
| 
       2967 
     | 
    
         
            -
                });
         
     | 
| 
       2968 
     | 
    
         
            -
             
     | 
| 
       2969 
     | 
    
         
            -
                return map;
         
     | 
| 
       2970 
     | 
    
         
            -
              }).cacheable(),
         
     | 
| 
       2971 
     | 
    
         
            -
             
     | 
| 
       2972 
     | 
    
         
            -
              processAttributeKeys: function() {
         
     | 
| 
       2973 
     | 
    
         
            -
                if (this.processedAttributeKeys) { return; }
         
     | 
| 
       2974 
     | 
    
         
            -
             
     | 
| 
       2975 
     | 
    
         
            -
                var namingConvention = this.proto().namingConvention;
         
     | 
| 
       2976 
     | 
    
         
            -
             
     | 
| 
       2977 
     | 
    
         
            -
                this.eachComputedProperty(function(name, meta) {
         
     | 
| 
       2978 
     | 
    
         
            -
                  if (meta.isAttribute && !meta.options.key) {
         
     | 
| 
       2979 
     | 
    
         
            -
                    meta.options.key = namingConvention.keyToJSONKey(name, this);
         
     | 
| 
       2980 
     | 
    
         
            -
                  }
         
     | 
| 
       2981 
     | 
    
         
            -
                }, this);
         
     | 
| 
       2982 
     | 
    
         
            -
              }
         
     | 
| 
       2983 
     | 
    
         
            -
            });
         
     | 
| 
       2984 
     | 
    
         
            -
             
     | 
| 
       2985 
     | 
    
         
            -
            DS.attr = function(type, options) {
         
     | 
| 
       2986 
     | 
    
         
            -
              var transform = DS.attr.transforms[type];
         
     | 
| 
       2987 
     | 
    
         
            -
             
     | 
| 
       2988 
     | 
    
         
            -
             
     | 
| 
       2989 
     | 
    
         
            -
              var transformFrom = transform.from;
         
     | 
| 
       2990 
     | 
    
         
            -
              var transformTo = transform.to;
         
     | 
| 
       2991 
     | 
    
         
            -
             
     | 
| 
       2992 
     | 
    
         
            -
              options = options || {};
         
     | 
| 
       2993 
     | 
    
         
            -
             
     | 
| 
       2994 
     | 
    
         
            -
              var meta = {
         
     | 
| 
       2995 
     | 
    
         
            -
                type: type,
         
     | 
| 
       2996 
     | 
    
         
            -
                isAttribute: true,
         
     | 
| 
       2997 
     | 
    
         
            -
                options: options,
         
     | 
| 
       2998 
     | 
    
         
            -
             
     | 
| 
       2999 
     | 
    
         
            -
                // this will ensure that the key always takes naming
         
     | 
| 
       3000 
     | 
    
         
            -
                // conventions into consideration.
         
     | 
| 
       3001 
     | 
    
         
            -
                key: function(recordType) {
         
     | 
| 
       3002 
     | 
    
         
            -
                  recordType.processAttributeKeys();
         
     | 
| 
       3003 
     | 
    
         
            -
                  return options.key;
         
     | 
| 
       3004 
     | 
    
         
            -
                }
         
     | 
| 
       3005 
     | 
    
         
            -
              };
         
     | 
| 
       3006 
     | 
    
         
            -
             
     | 
| 
       3007 
     | 
    
         
            -
              return Ember.computed(function(key, value) {
         
     | 
| 
       3008 
     | 
    
         
            -
                var data;
         
     | 
| 
       3009 
     | 
    
         
            -
             
     | 
| 
       3010 
     | 
    
         
            -
                key = meta.key(this.constructor);
         
     | 
| 
       3011 
     | 
    
         
            -
             
     | 
| 
       3012 
     | 
    
         
            -
                if (arguments.length === 2) {
         
     | 
| 
       3013 
     | 
    
         
            -
                  value = transformTo(value);
         
     | 
| 
       3014 
     | 
    
         
            -
                  this.setProperty(key, value);
         
     | 
| 
       3015 
     | 
    
         
            -
                } else {
         
     | 
| 
       3016 
     | 
    
         
            -
                  data = get(this, 'data');
         
     | 
| 
       3017 
     | 
    
         
            -
                  value = get(data, key);
         
     | 
| 
       3018 
     | 
    
         
            -
             
     | 
| 
       3019 
     | 
    
         
            -
                  if (value === undefined) {
         
     | 
| 
       3020 
     | 
    
         
            -
                    value = options.defaultValue;
         
     | 
| 
       3021 
     | 
    
         
            -
                  }
         
     | 
| 
       3022 
     | 
    
         
            -
                }
         
     | 
| 
       3023 
     | 
    
         
            -
             
     | 
| 
       3024 
     | 
    
         
            -
                return transformFrom(value);
         
     | 
| 
       3025 
     | 
    
         
            -
              // `data` is never set directly. However, it may be
         
     | 
| 
       3026 
     | 
    
         
            -
              // invalidated from the state manager's setData
         
     | 
| 
       3027 
     | 
    
         
            -
              // event.
         
     | 
| 
       3028 
     | 
    
         
            -
              }).property('data').cacheable().meta(meta);
         
     | 
| 
       3029 
     | 
    
         
            -
            };
         
     | 
| 
       3030 
     | 
    
         
            -
             
     | 
| 
       3031 
     | 
    
         
            -
            DS.attr.transforms = {
         
     | 
| 
       3032 
     | 
    
         
            -
              string: {
         
     | 
| 
       3033 
     | 
    
         
            -
                from: function(serialized) {
         
     | 
| 
       3034 
     | 
    
         
            -
                  return Ember.none(serialized) ? null : String(serialized);
         
     | 
| 
       3035 
     | 
    
         
            -
                },
         
     | 
| 
       3036 
     | 
    
         
            -
             
     | 
| 
       3037 
     | 
    
         
            -
                to: function(deserialized) {
         
     | 
| 
       3038 
     | 
    
         
            -
                  return Ember.none(deserialized) ? null : String(deserialized);
         
     | 
| 
       3039 
     | 
    
         
            -
                }
         
     | 
| 
       3040 
     | 
    
         
            -
              },
         
     | 
| 
       3041 
     | 
    
         
            -
             
     | 
| 
       3042 
     | 
    
         
            -
              number: {
         
     | 
| 
       3043 
     | 
    
         
            -
                from: function(serialized) {
         
     | 
| 
       3044 
     | 
    
         
            -
                  return Ember.none(serialized) ? null : Number(serialized);
         
     | 
| 
       3045 
     | 
    
         
            -
                },
         
     | 
| 
       3046 
     | 
    
         
            -
             
     | 
| 
       3047 
     | 
    
         
            -
                to: function(deserialized) {
         
     | 
| 
       3048 
     | 
    
         
            -
                  return Ember.none(deserialized) ? null : Number(deserialized);
         
     | 
| 
       3049 
     | 
    
         
            -
                }
         
     | 
| 
       3050 
     | 
    
         
            -
              },
         
     | 
| 
       3051 
     | 
    
         
            -
             
     | 
| 
       3052 
     | 
    
         
            -
              'boolean': {
         
     | 
| 
       3053 
     | 
    
         
            -
                from: function(serialized) {
         
     | 
| 
       3054 
     | 
    
         
            -
                  return Boolean(serialized);
         
     | 
| 
       3055 
     | 
    
         
            -
                },
         
     | 
| 
       3056 
     | 
    
         
            -
             
     | 
| 
       3057 
     | 
    
         
            -
                to: function(deserialized) {
         
     | 
| 
       3058 
     | 
    
         
            -
                  return Boolean(deserialized);
         
     | 
| 
       3059 
     | 
    
         
            -
                }
         
     | 
| 
       3060 
     | 
    
         
            -
              },
         
     | 
| 
       3061 
     | 
    
         
            -
             
     | 
| 
       3062 
     | 
    
         
            -
              date: {
         
     | 
| 
       3063 
     | 
    
         
            -
                from: function(serialized) {
         
     | 
| 
       3064 
     | 
    
         
            -
                  var type = typeof serialized;
         
     | 
| 
       3065 
     | 
    
         
            -
             
     | 
| 
       3066 
     | 
    
         
            -
                  if (type === "string" || type === "number") {
         
     | 
| 
       3067 
     | 
    
         
            -
                    return new Date(serialized);
         
     | 
| 
       3068 
     | 
    
         
            -
                  } else if (serialized === null || serialized === undefined) {
         
     | 
| 
       3069 
     | 
    
         
            -
                    // if the value is not present in the data,
         
     | 
| 
       3070 
     | 
    
         
            -
                    // return undefined, not null.
         
     | 
| 
       3071 
     | 
    
         
            -
                    return serialized;
         
     | 
| 
       3072 
     | 
    
         
            -
                  } else {
         
     | 
| 
       3073 
     | 
    
         
            -
                    return null;
         
     | 
| 
       3074 
     | 
    
         
            -
                  }
         
     | 
| 
       3075 
     | 
    
         
            -
                },
         
     | 
| 
       3076 
     | 
    
         
            -
             
     | 
| 
       3077 
     | 
    
         
            -
                to: function(date) {
         
     | 
| 
       3078 
     | 
    
         
            -
                  if (date instanceof Date) {
         
     | 
| 
       3079 
     | 
    
         
            -
                    var days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
         
     | 
| 
       3080 
     | 
    
         
            -
                    var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
         
     | 
| 
       3081 
     | 
    
         
            -
             
     | 
| 
       3082 
     | 
    
         
            -
                    var pad = function(num) {
         
     | 
| 
       3083 
     | 
    
         
            -
                      return num < 10 ? "0"+num : ""+num;
         
     | 
| 
       3084 
     | 
    
         
            -
                    };
         
     | 
| 
       3085 
     | 
    
         
            -
             
     | 
| 
       3086 
     | 
    
         
            -
                    var utcYear = date.getUTCFullYear(),
         
     | 
| 
       3087 
     | 
    
         
            -
                        utcMonth = date.getUTCMonth(),
         
     | 
| 
       3088 
     | 
    
         
            -
                        utcDayOfMonth = date.getUTCDate(),
         
     | 
| 
       3089 
     | 
    
         
            -
                        utcDay = date.getUTCDay(),
         
     | 
| 
       3090 
     | 
    
         
            -
                        utcHours = date.getUTCHours(),
         
     | 
| 
       3091 
     | 
    
         
            -
                        utcMinutes = date.getUTCMinutes(),
         
     | 
| 
       3092 
     | 
    
         
            -
                        utcSeconds = date.getUTCSeconds();
         
     | 
| 
       3093 
     | 
    
         
            -
             
     | 
| 
       3094 
     | 
    
         
            -
             
     | 
| 
       3095 
     | 
    
         
            -
                    var dayOfWeek = days[utcDay];
         
     | 
| 
       3096 
     | 
    
         
            -
                    var dayOfMonth = pad(utcDayOfMonth);
         
     | 
| 
       3097 
     | 
    
         
            -
                    var month = months[utcMonth];
         
     | 
| 
       3098 
     | 
    
         
            -
             
     | 
| 
       3099 
     | 
    
         
            -
                    return dayOfWeek + ", " + dayOfMonth + " " + month + " " + utcYear + " " +
         
     | 
| 
       3100 
     | 
    
         
            -
                           pad(utcHours) + ":" + pad(utcMinutes) + ":" + pad(utcSeconds) + " GMT";
         
     | 
| 
       3101 
     | 
    
         
            -
                  } else if (date === undefined) {
         
     | 
| 
       3102 
     | 
    
         
            -
                    return undefined;
         
     | 
| 
       3103 
     | 
    
         
            -
                  } else {
         
     | 
| 
       3104 
     | 
    
         
            -
                    return null;
         
     | 
| 
       3105 
     | 
    
         
            -
                  }
         
     | 
| 
       3106 
     | 
    
         
            -
                }
         
     | 
| 
       3107 
     | 
    
         
            -
              }
         
     | 
| 
       3108 
     | 
    
         
            -
            };
         
     | 
| 
       3109 
     | 
    
         
            -
             
     | 
| 
       3110 
     | 
    
         
            -
             
     | 
| 
       3111 
     | 
    
         
            -
            })();
         
     | 
| 
       3112 
     | 
    
         
            -
             
     | 
| 
       3113 
     | 
    
         
            -
             
     | 
| 
       3114 
     | 
    
         
            -
             
     | 
| 
       3115 
     | 
    
         
            -
            (function() {
         
     | 
| 
       3116 
     | 
    
         
            -
             
     | 
| 
       3117 
     | 
    
         
            -
            })();
         
     | 
| 
       3118 
     | 
    
         
            -
             
     | 
| 
       3119 
     | 
    
         
            -
             
     | 
| 
       3120 
     | 
    
         
            -
             
     | 
| 
       3121 
     | 
    
         
            -
            (function() {
         
     | 
| 
       3122 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set, getPath = Ember.getPath,
         
     | 
| 
       3123 
     | 
    
         
            -
                none = Ember.none;
         
     | 
| 
       3124 
     | 
    
         
            -
             
     | 
| 
       3125 
     | 
    
         
            -
            var embeddedFindRecord = function(store, type, data, key, one) {
         
     | 
| 
       3126 
     | 
    
         
            -
              var association = get(data, key);
         
     | 
| 
       3127 
     | 
    
         
            -
              return none(association) ? undefined : store.load(type, association).id;
         
     | 
| 
       3128 
     | 
    
         
            -
            };
         
     | 
| 
       3129 
     | 
    
         
            -
             
     | 
| 
       3130 
     | 
    
         
            -
            var referencedFindRecord = function(store, type, data, key, one) {
         
     | 
| 
       3131 
     | 
    
         
            -
              return get(data, key);
         
     | 
| 
       3132 
     | 
    
         
            -
            };
         
     | 
| 
       3133 
     | 
    
         
            -
             
     | 
| 
       3134 
     | 
    
         
            -
            var hasAssociation = function(type, options, one) {
         
     | 
| 
       3135 
     | 
    
         
            -
              options = options || {};
         
     | 
| 
       3136 
     | 
    
         
            -
             
     | 
| 
       3137 
     | 
    
         
            -
              var embedded = options.embedded,
         
     | 
| 
       3138 
     | 
    
         
            -
                  findRecord = embedded ? embeddedFindRecord : referencedFindRecord;
         
     | 
| 
       3139 
     | 
    
         
            -
             
     | 
| 
       3140 
     | 
    
         
            -
              var meta = { type: type, isAssociation: true, options: options, kind: 'belongsTo' };
         
     | 
| 
       3141 
     | 
    
         
            -
             
     | 
| 
       3142 
     | 
    
         
            -
              return Ember.computed(function(key, value) {
         
     | 
| 
       3143 
     | 
    
         
            -
                var data = get(this, 'data'), ids, id, association,
         
     | 
| 
       3144 
     | 
    
         
            -
                    store = get(this, 'store');
         
     | 
| 
       3145 
     | 
    
         
            -
             
     | 
| 
       3146 
     | 
    
         
            -
                if (typeof type === 'string') {
         
     | 
| 
       3147 
     | 
    
         
            -
                  type = getPath(this, type, false) || getPath(window, type);
         
     | 
| 
       3148 
     | 
    
         
            -
                }
         
     | 
| 
       3149 
     | 
    
         
            -
             
     | 
| 
       3150 
     | 
    
         
            -
                if (arguments.length === 2) {
         
     | 
| 
       3151 
     | 
    
         
            -
                  key = options.key || get(this, 'namingConvention').foreignKey(key);
         
     | 
| 
       3152 
     | 
    
         
            -
                  this.send('setAssociation', { key: key, value: value === null ? null : get(value, 'clientId') });
         
     | 
| 
       3153 
     | 
    
         
            -
                  //data.setAssociation(key, get(value, 'clientId'));
         
     | 
| 
       3154 
     | 
    
         
            -
                  // put the client id in `key` in the data hash
         
     | 
| 
       3155 
     | 
    
         
            -
                  return value;
         
     | 
| 
       3156 
     | 
    
         
            -
                } else {
         
     | 
| 
       3157 
     | 
    
         
            -
                  // Embedded belongsTo associations should not look for
         
     | 
| 
       3158 
     | 
    
         
            -
                  // a foreign key.
         
     | 
| 
       3159 
     | 
    
         
            -
                  if (embedded) {
         
     | 
| 
       3160 
     | 
    
         
            -
                    key = options.key || get(this, 'namingConvention').keyToJSONKey(key);
         
     | 
| 
       3161 
     | 
    
         
            -
             
     | 
| 
       3162 
     | 
    
         
            -
                  // Non-embedded associations should look for a foreign key.
         
     | 
| 
       3163 
     | 
    
         
            -
                  // For example, instead of person, we might look for person_id
         
     | 
| 
       3164 
     | 
    
         
            -
                  } else {
         
     | 
| 
       3165 
     | 
    
         
            -
                    key = options.key || get(this, 'namingConvention').foreignKey(key);
         
     | 
| 
       3166 
     | 
    
         
            -
                  }
         
     | 
| 
       3167 
     | 
    
         
            -
                  id = findRecord(store, type, data, key, true);
         
     | 
| 
       3168 
     | 
    
         
            -
                  association = id ? store.find(type, id) : null;
         
     | 
| 
       3169 
     | 
    
         
            -
                }
         
     | 
| 
       3170 
     | 
    
         
            -
             
     | 
| 
       3171 
     | 
    
         
            -
                return association;
         
     | 
| 
       3172 
     | 
    
         
            -
              }).property('data').cacheable().meta(meta);
         
     | 
| 
       3173 
     | 
    
         
            -
            };
         
     | 
| 
       3174 
     | 
    
         
            -
             
     | 
| 
       3175 
     | 
    
         
            -
            DS.belongsTo = function(type, options) {
         
     | 
| 
       3176 
     | 
    
         
            -
             
     | 
| 
       3177 
     | 
    
         
            -
              return hasAssociation(type, options);
         
     | 
| 
       3178 
     | 
    
         
            -
            };
         
     | 
| 
       3179 
     | 
    
         
            -
             
     | 
| 
       3180 
     | 
    
         
            -
            })();
         
     | 
| 
       3181 
     | 
    
         
            -
             
     | 
| 
       3182 
     | 
    
         
            -
             
     | 
| 
       3183 
     | 
    
         
            -
             
     | 
| 
       3184 
     | 
    
         
            -
            (function() {
         
     | 
| 
       3185 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
         
     | 
| 
       3186 
     | 
    
         
            -
            var embeddedFindRecord = function(store, type, data, key) {
         
     | 
| 
       3187 
     | 
    
         
            -
              var association = get(data, key);
         
     | 
| 
       3188 
     | 
    
         
            -
              return association ? store.loadMany(type, association).ids : [];
         
     | 
| 
       3189 
     | 
    
         
            -
            };
         
     | 
| 
       3190 
     | 
    
         
            -
             
     | 
| 
       3191 
     | 
    
         
            -
            var referencedFindRecord = function(store, type, data, key, one) {
         
     | 
| 
       3192 
     | 
    
         
            -
              return get(data, key);
         
     | 
| 
       3193 
     | 
    
         
            -
            };
         
     | 
| 
       3194 
     | 
    
         
            -
             
     | 
| 
       3195 
     | 
    
         
            -
            var hasAssociation = function(type, options) {
         
     | 
| 
       3196 
     | 
    
         
            -
              options = options || {};
         
     | 
| 
       3197 
     | 
    
         
            -
             
     | 
| 
       3198 
     | 
    
         
            -
              var embedded = options.embedded,
         
     | 
| 
       3199 
     | 
    
         
            -
                  findRecord = embedded ? embeddedFindRecord : referencedFindRecord;
         
     | 
| 
       3200 
     | 
    
         
            -
             
     | 
| 
       3201 
     | 
    
         
            -
              var meta = { type: type, isAssociation: true, options: options, kind: 'hasMany' };
         
     | 
| 
       3202 
     | 
    
         
            -
             
     | 
| 
       3203 
     | 
    
         
            -
              return Ember.computed(function(key, value) {
         
     | 
| 
       3204 
     | 
    
         
            -
                var data = get(this, 'data'),
         
     | 
| 
       3205 
     | 
    
         
            -
                    store = get(this, 'store'),
         
     | 
| 
       3206 
     | 
    
         
            -
                    ids, id, association;
         
     | 
| 
       3207 
     | 
    
         
            -
             
     | 
| 
       3208 
     | 
    
         
            -
                if (typeof type === 'string') {
         
     | 
| 
       3209 
     | 
    
         
            -
                  type = getPath(this, type, false) || getPath(window, type);
         
     | 
| 
       3210 
     | 
    
         
            -
                }
         
     | 
| 
       3211 
     | 
    
         
            -
             
     | 
| 
       3212 
     | 
    
         
            -
                key = options.key || get(this, 'namingConvention').keyToJSONKey(key);
         
     | 
| 
       3213 
     | 
    
         
            -
                ids = findRecord(store, type, data, key);
         
     | 
| 
       3214 
     | 
    
         
            -
                association = store.findMany(type, ids);
         
     | 
| 
       3215 
     | 
    
         
            -
                set(association, 'parentRecord', this);
         
     | 
| 
       3216 
     | 
    
         
            -
             
     | 
| 
       3217 
     | 
    
         
            -
                return association;
         
     | 
| 
       3218 
     | 
    
         
            -
              }).property().cacheable().meta(meta);
         
     | 
| 
       3219 
     | 
    
         
            -
            };
         
     | 
| 
       3220 
     | 
    
         
            -
             
     | 
| 
       3221 
     | 
    
         
            -
            DS.hasMany = function(type, options) {
         
     | 
| 
       3222 
     | 
    
         
            -
             
     | 
| 
       3223 
     | 
    
         
            -
              return hasAssociation(type, options);
         
     | 
| 
       3224 
     | 
    
         
            -
            };
         
     | 
| 
       3225 
     | 
    
         
            -
             
     | 
| 
       3226 
     | 
    
         
            -
            })();
         
     | 
| 
       3227 
     | 
    
         
            -
             
     | 
| 
       3228 
     | 
    
         
            -
             
     | 
| 
       3229 
     | 
    
         
            -
             
     | 
| 
       3230 
     | 
    
         
            -
            (function() {
         
     | 
| 
       3231 
     | 
    
         
            -
            var get = Ember.get, getPath = Ember.getPath;
         
     | 
| 
       3232 
     | 
    
         
            -
             
     | 
| 
       3233 
     | 
    
         
            -
            DS.Model.reopenClass({
         
     | 
| 
       3234 
     | 
    
         
            -
              typeForAssociation: function(name) {
         
     | 
| 
       3235 
     | 
    
         
            -
                var association = get(this, 'associationsByName').get(name);
         
     | 
| 
       3236 
     | 
    
         
            -
                return association && association.type;
         
     | 
| 
       3237 
     | 
    
         
            -
              },
         
     | 
| 
       3238 
     | 
    
         
            -
             
     | 
| 
       3239 
     | 
    
         
            -
              associations: Ember.computed(function() {
         
     | 
| 
       3240 
     | 
    
         
            -
                var map = Ember.Map.create();
         
     | 
| 
       3241 
     | 
    
         
            -
             
     | 
| 
       3242 
     | 
    
         
            -
                this.eachComputedProperty(function(name, meta) {
         
     | 
| 
       3243 
     | 
    
         
            -
                  if (meta.isAssociation) {
         
     | 
| 
       3244 
     | 
    
         
            -
                    var type = meta.type,
         
     | 
| 
       3245 
     | 
    
         
            -
                        typeList = map.get(type);
         
     | 
| 
       3246 
     | 
    
         
            -
             
     | 
| 
       3247 
     | 
    
         
            -
                    if (typeof type === 'string') {
         
     | 
| 
       3248 
     | 
    
         
            -
                      type = getPath(this, type, false) || getPath(window, type);
         
     | 
| 
       3249 
     | 
    
         
            -
                      meta.type = type;
         
     | 
| 
       3250 
     | 
    
         
            -
                    }
         
     | 
| 
       3251 
     | 
    
         
            -
             
     | 
| 
       3252 
     | 
    
         
            -
                    if (!typeList) {
         
     | 
| 
       3253 
     | 
    
         
            -
                      typeList = [];
         
     | 
| 
       3254 
     | 
    
         
            -
                      map.set(type, typeList);
         
     | 
| 
       3255 
     | 
    
         
            -
                    }
         
     | 
| 
       3256 
     | 
    
         
            -
             
     | 
| 
       3257 
     | 
    
         
            -
                    typeList.push({ name: name, kind: meta.kind });
         
     | 
| 
       3258 
     | 
    
         
            -
                  }
         
     | 
| 
       3259 
     | 
    
         
            -
                });
         
     | 
| 
       3260 
     | 
    
         
            -
             
     | 
| 
       3261 
     | 
    
         
            -
                return map;
         
     | 
| 
       3262 
     | 
    
         
            -
              }).cacheable(),
         
     | 
| 
       3263 
     | 
    
         
            -
             
     | 
| 
       3264 
     | 
    
         
            -
              associationsByName: Ember.computed(function() {
         
     | 
| 
       3265 
     | 
    
         
            -
                var map = Ember.Map.create(), type;
         
     | 
| 
       3266 
     | 
    
         
            -
             
     | 
| 
       3267 
     | 
    
         
            -
                this.eachComputedProperty(function(name, meta) {
         
     | 
| 
       3268 
     | 
    
         
            -
                  if (meta.isAssociation) {
         
     | 
| 
       3269 
     | 
    
         
            -
                    meta.key = name;
         
     | 
| 
       3270 
     | 
    
         
            -
                    type = meta.type;
         
     | 
| 
       3271 
     | 
    
         
            -
             
     | 
| 
       3272 
     | 
    
         
            -
                    if (typeof type === 'string') {
         
     | 
| 
       3273 
     | 
    
         
            -
                      type = getPath(this, type, false) || getPath(window, type);
         
     | 
| 
       3274 
     | 
    
         
            -
                      meta.type = type;
         
     | 
| 
       3275 
     | 
    
         
            -
                    }
         
     | 
| 
       3276 
     | 
    
         
            -
             
     | 
| 
       3277 
     | 
    
         
            -
                    map.set(name, meta);
         
     | 
| 
       3278 
     | 
    
         
            -
                  }
         
     | 
| 
       3279 
     | 
    
         
            -
                });
         
     | 
| 
       3280 
     | 
    
         
            -
             
     | 
| 
       3281 
     | 
    
         
            -
                return map;
         
     | 
| 
       3282 
     | 
    
         
            -
              }).cacheable()
         
     | 
| 
       3283 
     | 
    
         
            -
            });
         
     | 
| 
       3284 
     | 
    
         
            -
             
     | 
| 
       3285 
     | 
    
         
            -
            })();
         
     | 
| 
       3286 
     | 
    
         
            -
             
     | 
| 
       3287 
     | 
    
         
            -
             
     | 
| 
       3288 
     | 
    
         
            -
             
     | 
| 
       3289 
     | 
    
         
            -
            (function() {
         
     | 
| 
       3290 
     | 
    
         
            -
             
     | 
| 
       3291 
     | 
    
         
            -
            })();
         
     | 
| 
       3292 
     | 
    
         
            -
             
     | 
| 
       3293 
     | 
    
         
            -
             
     | 
| 
       3294 
     | 
    
         
            -
             
     | 
| 
       3295 
     | 
    
         
            -
            (function() {
         
     | 
| 
       3296 
     | 
    
         
            -
            /**
         
     | 
| 
       3297 
     | 
    
         
            -
              An adapter is an object that receives requests from a store and
         
     | 
| 
       3298 
     | 
    
         
            -
              translates them into the appropriate action to take against your
         
     | 
| 
       3299 
     | 
    
         
            -
              persistence layer. The persistence layer is usually an HTTP API, but may
         
     | 
| 
       3300 
     | 
    
         
            -
              be anything, such as the browser's local storage.
         
     | 
| 
       3301 
     | 
    
         
            -
             
     | 
| 
       3302 
     | 
    
         
            -
              ### Creating an Adapter
         
     | 
| 
       3303 
     | 
    
         
            -
             
     | 
| 
       3304 
     | 
    
         
            -
              First, create a new subclass of `DS.Adapter`:
         
     | 
| 
       3305 
     | 
    
         
            -
             
     | 
| 
       3306 
     | 
    
         
            -
                  App.MyAdapter = DS.Adapter.extend({
         
     | 
| 
       3307 
     | 
    
         
            -
                    // ...your code here
         
     | 
| 
       3308 
     | 
    
         
            -
                  });
         
     | 
| 
       3309 
     | 
    
         
            -
             
     | 
| 
       3310 
     | 
    
         
            -
              To tell your store which adapter to use, set its `adapter` property:
         
     | 
| 
       3311 
     | 
    
         
            -
             
     | 
| 
       3312 
     | 
    
         
            -
                  App.store = DS.Store.create({
         
     | 
| 
       3313 
     | 
    
         
            -
                    revision: 3,
         
     | 
| 
       3314 
     | 
    
         
            -
                    adapter: App.MyAdapter.create()
         
     | 
| 
       3315 
     | 
    
         
            -
                  });
         
     | 
| 
       3316 
     | 
    
         
            -
             
     | 
| 
       3317 
     | 
    
         
            -
              `DS.Adapter` is an abstract base class that you should override in your
         
     | 
| 
       3318 
     | 
    
         
            -
              application to customize it for your backend. The minimum set of methods
         
     | 
| 
       3319 
     | 
    
         
            -
              that you should implement is:
         
     | 
| 
       3320 
     | 
    
         
            -
             
     | 
| 
       3321 
     | 
    
         
            -
                * `find()`
         
     | 
| 
       3322 
     | 
    
         
            -
                * `createRecord()`
         
     | 
| 
       3323 
     | 
    
         
            -
                * `updateRecord()`
         
     | 
| 
       3324 
     | 
    
         
            -
                * `deleteRecord()`
         
     | 
| 
       3325 
     | 
    
         
            -
             
     | 
| 
       3326 
     | 
    
         
            -
               To improve the network performance of your application, you can optimize
         
     | 
| 
       3327 
     | 
    
         
            -
               your adapter by overriding these lower-level methods:
         
     | 
| 
       3328 
     | 
    
         
            -
             
     | 
| 
       3329 
     | 
    
         
            -
                * `findMany()`
         
     | 
| 
       3330 
     | 
    
         
            -
                * `createRecords()`
         
     | 
| 
       3331 
     | 
    
         
            -
                * `updateRecords()`
         
     | 
| 
       3332 
     | 
    
         
            -
                * `deleteRecords()`
         
     | 
| 
       3333 
     | 
    
         
            -
                * `commit()`
         
     | 
| 
       3334 
     | 
    
         
            -
             
     | 
| 
       3335 
     | 
    
         
            -
               For more information about the adapter API, please see `README.md`.
         
     | 
| 
       3336 
     | 
    
         
            -
            */
         
     | 
| 
       3337 
     | 
    
         
            -
             
     | 
| 
       3338 
     | 
    
         
            -
            DS.Adapter = Ember.Object.extend({
         
     | 
| 
       3339 
     | 
    
         
            -
              /**
         
     | 
| 
       3340 
     | 
    
         
            -
                The `find()` method is invoked when the store is asked for a record that
         
     | 
| 
       3341 
     | 
    
         
            -
                has not previously been loaded. In response to `find()` being called, you
         
     | 
| 
       3342 
     | 
    
         
            -
                should query your persistence layer for a record with the given ID. Once
         
     | 
| 
       3343 
     | 
    
         
            -
                found, you can asynchronously call the store's `load()` method to load
         
     | 
| 
       3344 
     | 
    
         
            -
                the record.
         
     | 
| 
       3345 
     | 
    
         
            -
             
     | 
| 
       3346 
     | 
    
         
            -
                Here is an example `find` implementation:
         
     | 
| 
       3347 
     | 
    
         
            -
             
     | 
| 
       3348 
     | 
    
         
            -
                  find: function(store, type, id) {
         
     | 
| 
       3349 
     | 
    
         
            -
                    var url = type.url;
         
     | 
| 
       3350 
     | 
    
         
            -
                    url = url.fmt(id);
         
     | 
| 
       3351 
     | 
    
         
            -
             
     | 
| 
       3352 
     | 
    
         
            -
                    jQuery.getJSON(url, function(data) {
         
     | 
| 
       3353 
     | 
    
         
            -
                        // data is a Hash of key/value pairs. If your server returns a
         
     | 
| 
       3354 
     | 
    
         
            -
                        // root, simply do something like:
         
     | 
| 
       3355 
     | 
    
         
            -
                        // store.load(type, id, data.person)
         
     | 
| 
       3356 
     | 
    
         
            -
                        store.load(type, id, data);
         
     | 
| 
       3357 
     | 
    
         
            -
                    });
         
     | 
| 
       3358 
     | 
    
         
            -
                  }
         
     | 
| 
       3359 
     | 
    
         
            -
              */
         
     | 
| 
       3360 
     | 
    
         
            -
              find: null,
         
     | 
| 
       3361 
     | 
    
         
            -
             
     | 
| 
       3362 
     | 
    
         
            -
              /**
         
     | 
| 
       3363 
     | 
    
         
            -
                If the globally unique IDs for your records should be generated on the client,
         
     | 
| 
       3364 
     | 
    
         
            -
                implement the `generateIdForRecord()` method. This method will be invoked
         
     | 
| 
       3365 
     | 
    
         
            -
                each time you create a new record, and the value returned from it will be
         
     | 
| 
       3366 
     | 
    
         
            -
                assigned to the record's `primaryKey`.
         
     | 
| 
       3367 
     | 
    
         
            -
             
     | 
| 
       3368 
     | 
    
         
            -
                Most traditional REST-like HTTP APIs will not use this method. Instead, the ID
         
     | 
| 
       3369 
     | 
    
         
            -
                of the record will be set by the server, and your adapter will update the store
         
     | 
| 
       3370 
     | 
    
         
            -
                with the new ID when it calls `didCreateRecord()`. Only implement this method if
         
     | 
| 
       3371 
     | 
    
         
            -
                you intend to generate record IDs on the client-side.
         
     | 
| 
       3372 
     | 
    
         
            -
             
     | 
| 
       3373 
     | 
    
         
            -
                The `generateIdForRecord()` method will be invoked with the requesting store as
         
     | 
| 
       3374 
     | 
    
         
            -
                the first parameter and the newly created record as the second parameter:
         
     | 
| 
       3375 
     | 
    
         
            -
             
     | 
| 
       3376 
     | 
    
         
            -
                    generateIdForRecord: function(store, record) {
         
     | 
| 
       3377 
     | 
    
         
            -
                      var uuid = App.generateUUIDWithStatisticallyLowOddsOfCollision();
         
     | 
| 
       3378 
     | 
    
         
            -
                      return uuid;
         
     | 
| 
       3379 
     | 
    
         
            -
                    }
         
     | 
| 
       3380 
     | 
    
         
            -
              */
         
     | 
| 
       3381 
     | 
    
         
            -
              generateIdForRecord: null,
         
     | 
| 
       3382 
     | 
    
         
            -
             
     | 
| 
       3383 
     | 
    
         
            -
              commit: function(store, commitDetails) {
         
     | 
| 
       3384 
     | 
    
         
            -
                commitDetails.updated.eachType(function(type, array) {
         
     | 
| 
       3385 
     | 
    
         
            -
                  this.updateRecords(store, type, array.slice());
         
     | 
| 
       3386 
     | 
    
         
            -
                }, this);
         
     | 
| 
       3387 
     | 
    
         
            -
             
     | 
| 
       3388 
     | 
    
         
            -
                commitDetails.created.eachType(function(type, array) {
         
     | 
| 
       3389 
     | 
    
         
            -
                  this.createRecords(store, type, array.slice());
         
     | 
| 
       3390 
     | 
    
         
            -
                }, this);
         
     | 
| 
       3391 
     | 
    
         
            -
             
     | 
| 
       3392 
     | 
    
         
            -
                commitDetails.deleted.eachType(function(type, array) {
         
     | 
| 
       3393 
     | 
    
         
            -
                  this.deleteRecords(store, type, array.slice());
         
     | 
| 
       3394 
     | 
    
         
            -
                }, this);
         
     | 
| 
       3395 
     | 
    
         
            -
              },
         
     | 
| 
       3396 
     | 
    
         
            -
             
     | 
| 
       3397 
     | 
    
         
            -
              createRecords: function(store, type, records) {
         
     | 
| 
       3398 
     | 
    
         
            -
                records.forEach(function(record) {
         
     | 
| 
       3399 
     | 
    
         
            -
                  this.createRecord(store, type, record);
         
     | 
| 
       3400 
     | 
    
         
            -
                }, this);
         
     | 
| 
       3401 
     | 
    
         
            -
              },
         
     | 
| 
       3402 
     | 
    
         
            -
             
     | 
| 
       3403 
     | 
    
         
            -
              updateRecords: function(store, type, records) {
         
     | 
| 
       3404 
     | 
    
         
            -
                records.forEach(function(record) {
         
     | 
| 
       3405 
     | 
    
         
            -
                  this.updateRecord(store, type, record);
         
     | 
| 
       3406 
     | 
    
         
            -
                }, this);
         
     | 
| 
       3407 
     | 
    
         
            -
              },
         
     | 
| 
       3408 
     | 
    
         
            -
             
     | 
| 
       3409 
     | 
    
         
            -
              deleteRecords: function(store, type, records) {
         
     | 
| 
       3410 
     | 
    
         
            -
                records.forEach(function(record) {
         
     | 
| 
       3411 
     | 
    
         
            -
                  this.deleteRecord(store, type, record);
         
     | 
| 
       3412 
     | 
    
         
            -
                }, this);
         
     | 
| 
       3413 
     | 
    
         
            -
              },
         
     | 
| 
       3414 
     | 
    
         
            -
             
     | 
| 
       3415 
     | 
    
         
            -
              findMany: function(store, type, ids) {
         
     | 
| 
       3416 
     | 
    
         
            -
                ids.forEach(function(id) {
         
     | 
| 
       3417 
     | 
    
         
            -
                  this.find(store, type, id);
         
     | 
| 
       3418 
     | 
    
         
            -
                }, this);
         
     | 
| 
       3419 
     | 
    
         
            -
              }
         
     | 
| 
       3420 
     | 
    
         
            -
            });
         
     | 
| 
       3421 
     | 
    
         
            -
             
     | 
| 
       3422 
     | 
    
         
            -
            })();
         
     | 
| 
       3423 
     | 
    
         
            -
             
     | 
| 
       3424 
     | 
    
         
            -
             
     | 
| 
       3425 
     | 
    
         
            -
             
     | 
| 
       3426 
     | 
    
         
            -
            (function() {
         
     | 
| 
       3427 
     | 
    
         
            -
            var set = Ember.set;
         
     | 
| 
       3428 
     | 
    
         
            -
             
     | 
| 
       3429 
     | 
    
         
            -
            Ember.onLoad('application', function(app) {
         
     | 
| 
       3430 
     | 
    
         
            -
              app.registerInjection(function(app, stateManager, property) {
         
     | 
| 
       3431 
     | 
    
         
            -
                if (property === 'Store') {
         
     | 
| 
       3432 
     | 
    
         
            -
                  set(stateManager, 'store', app[property].create());
         
     | 
| 
       3433 
     | 
    
         
            -
                }
         
     | 
| 
       3434 
     | 
    
         
            -
              });
         
     | 
| 
       3435 
     | 
    
         
            -
            });
         
     | 
| 
       3436 
     | 
    
         
            -
             
     | 
| 
       3437 
     | 
    
         
            -
            })();
         
     | 
| 
       3438 
     | 
    
         
            -
             
     | 
| 
       3439 
     | 
    
         
            -
             
     | 
| 
       3440 
     | 
    
         
            -
             
     | 
| 
       3441 
     | 
    
         
            -
            (function() {
         
     | 
| 
       3442 
     | 
    
         
            -
            DS.fixtureAdapter = DS.Adapter.create({
         
     | 
| 
       3443 
     | 
    
         
            -
              find: function(store, type, id) {
         
     | 
| 
       3444 
     | 
    
         
            -
                var fixtures = type.FIXTURES;
         
     | 
| 
       3445 
     | 
    
         
            -
             
     | 
| 
       3446 
     | 
    
         
            -
                if (fixtures.hasLoaded) { return; }
         
     | 
| 
       3447 
     | 
    
         
            -
             
     | 
| 
       3448 
     | 
    
         
            -
                setTimeout(function() {
         
     | 
| 
       3449 
     | 
    
         
            -
                  store.loadMany(type, fixtures);
         
     | 
| 
       3450 
     | 
    
         
            -
                  fixtures.hasLoaded = true;
         
     | 
| 
       3451 
     | 
    
         
            -
                }, 300);
         
     | 
| 
       3452 
     | 
    
         
            -
              },
         
     | 
| 
       3453 
     | 
    
         
            -
             
     | 
| 
       3454 
     | 
    
         
            -
              findMany: function() {
         
     | 
| 
       3455 
     | 
    
         
            -
                this.find.apply(this, arguments);
         
     | 
| 
       3456 
     | 
    
         
            -
              },
         
     | 
| 
       3457 
     | 
    
         
            -
             
     | 
| 
       3458 
     | 
    
         
            -
              findAll: function(store, type) {
         
     | 
| 
       3459 
     | 
    
         
            -
                var fixtures = type.FIXTURES;
         
     | 
| 
       3460 
     | 
    
         
            -
             
     | 
| 
       3461 
     | 
    
         
            -
             
     | 
| 
       3462 
     | 
    
         
            -
                var ids = fixtures.map(function(item, index, self){ return item.id; });
         
     | 
| 
       3463 
     | 
    
         
            -
                store.loadMany(type, ids, fixtures);
         
     | 
| 
       3464 
     | 
    
         
            -
              }
         
     | 
| 
       3465 
     | 
    
         
            -
             
     | 
| 
       3466 
     | 
    
         
            -
            });
         
     | 
| 
       3467 
     | 
    
         
            -
             
     | 
| 
       3468 
     | 
    
         
            -
            })();
         
     | 
| 
       3469 
     | 
    
         
            -
             
     | 
| 
       3470 
     | 
    
         
            -
             
     | 
| 
       3471 
     | 
    
         
            -
             
     | 
| 
       3472 
     | 
    
         
            -
            (function() {
         
     | 
| 
       3473 
     | 
    
         
            -
            /*global jQuery*/
         
     | 
| 
       3474 
     | 
    
         
            -
             
     | 
| 
       3475 
     | 
    
         
            -
            var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
         
     | 
| 
       3476 
     | 
    
         
            -
             
     | 
| 
       3477 
     | 
    
         
            -
            DS.RESTAdapter = DS.Adapter.extend({
         
     | 
| 
       3478 
     | 
    
         
            -
              bulkCommit: false,
         
     | 
| 
       3479 
     | 
    
         
            -
            	
         
     | 
| 
       3480 
     | 
    
         
            -
              createRecord: function(store, type, record) {
         
     | 
| 
       3481 
     | 
    
         
            -
                var root = this.rootForType(type);
         
     | 
| 
       3482 
     | 
    
         
            -
             
     | 
| 
       3483 
     | 
    
         
            -
                var data = {};
         
     | 
| 
       3484 
     | 
    
         
            -
                data[root] = record.toJSON();
         
     | 
| 
       3485 
     | 
    
         
            -
             
     | 
| 
       3486 
     | 
    
         
            -
                this.ajax(this.buildURL(root), "POST", {
         
     | 
| 
       3487 
     | 
    
         
            -
                  data: data,
         
     | 
| 
       3488 
     | 
    
         
            -
                  success: function(json) {
         
     | 
| 
       3489 
     | 
    
         
            -
                    this.sideload(store, type, json, root);
         
     | 
| 
       3490 
     | 
    
         
            -
                    store.didCreateRecord(record, json[root]);
         
     | 
| 
       3491 
     | 
    
         
            -
                  }
         
     | 
| 
       3492 
     | 
    
         
            -
                });
         
     | 
| 
       3493 
     | 
    
         
            -
              },
         
     | 
| 
       3494 
     | 
    
         
            -
             
     | 
| 
       3495 
     | 
    
         
            -
              createRecords: function(store, type, records) {
         
     | 
| 
       3496 
     | 
    
         
            -
                if (get(this, 'bulkCommit') === false) {
         
     | 
| 
       3497 
     | 
    
         
            -
                  return this._super(store, type, records);
         
     | 
| 
       3498 
     | 
    
         
            -
                }
         
     | 
| 
       3499 
     | 
    
         
            -
             
     | 
| 
       3500 
     | 
    
         
            -
                var root = this.rootForType(type),
         
     | 
| 
       3501 
     | 
    
         
            -
                    plural = this.pluralize(root);
         
     | 
| 
       3502 
     | 
    
         
            -
             
     | 
| 
       3503 
     | 
    
         
            -
                var data = {};
         
     | 
| 
       3504 
     | 
    
         
            -
                data[plural] = records.map(function(record) {
         
     | 
| 
       3505 
     | 
    
         
            -
                  return record.toJSON();
         
     | 
| 
       3506 
     | 
    
         
            -
                });
         
     | 
| 
       3507 
     | 
    
         
            -
             
     | 
| 
       3508 
     | 
    
         
            -
                this.ajax(this.buildURL(root), "POST", {
         
     | 
| 
       3509 
     | 
    
         
            -
                  data: data,
         
     | 
| 
       3510 
     | 
    
         
            -
             
     | 
| 
       3511 
     | 
    
         
            -
                  success: function(json) {
         
     | 
| 
       3512 
     | 
    
         
            -
                    this.sideload(store, type, json, plural);
         
     | 
| 
       3513 
     | 
    
         
            -
                    store.didCreateRecords(type, records, json[plural]);
         
     | 
| 
       3514 
     | 
    
         
            -
                  }
         
     | 
| 
       3515 
     | 
    
         
            -
                });
         
     | 
| 
       3516 
     | 
    
         
            -
              },
         
     | 
| 
       3517 
     | 
    
         
            -
             
     | 
| 
       3518 
     | 
    
         
            -
              updateRecord: function(store, type, record) {
         
     | 
| 
       3519 
     | 
    
         
            -
                var id = get(record, 'id');
         
     | 
| 
       3520 
     | 
    
         
            -
                var root = this.rootForType(type);
         
     | 
| 
       3521 
     | 
    
         
            -
             
     | 
| 
       3522 
     | 
    
         
            -
                var data = {};
         
     | 
| 
       3523 
     | 
    
         
            -
                data[root] = record.toJSON();
         
     | 
| 
       3524 
     | 
    
         
            -
             
     | 
| 
       3525 
     | 
    
         
            -
                this.ajax(this.buildURL(root, id), "PUT", {
         
     | 
| 
       3526 
     | 
    
         
            -
                  data: data,
         
     | 
| 
       3527 
     | 
    
         
            -
                  success: function(json) {
         
     | 
| 
       3528 
     | 
    
         
            -
                    this.sideload(store, type, json, root);
         
     | 
| 
       3529 
     | 
    
         
            -
                    store.didUpdateRecord(record, json && json[root]);
         
     | 
| 
       3530 
     | 
    
         
            -
                  }
         
     | 
| 
       3531 
     | 
    
         
            -
                });
         
     | 
| 
       3532 
     | 
    
         
            -
              },
         
     | 
| 
       3533 
     | 
    
         
            -
             
     | 
| 
       3534 
     | 
    
         
            -
              updateRecords: function(store, type, records) {
         
     | 
| 
       3535 
     | 
    
         
            -
                if (get(this, 'bulkCommit') === false) {
         
     | 
| 
       3536 
     | 
    
         
            -
                  return this._super(store, type, records);
         
     | 
| 
       3537 
     | 
    
         
            -
                }
         
     | 
| 
       3538 
     | 
    
         
            -
             
     | 
| 
       3539 
     | 
    
         
            -
                var root = this.rootForType(type),
         
     | 
| 
       3540 
     | 
    
         
            -
                    plural = this.pluralize(root);
         
     | 
| 
       3541 
     | 
    
         
            -
             
     | 
| 
       3542 
     | 
    
         
            -
                var data = {};
         
     | 
| 
       3543 
     | 
    
         
            -
                data[plural] = records.map(function(record) {
         
     | 
| 
       3544 
     | 
    
         
            -
                  return record.toJSON();
         
     | 
| 
       3545 
     | 
    
         
            -
                });
         
     | 
| 
       3546 
     | 
    
         
            -
             
     | 
| 
       3547 
     | 
    
         
            -
                this.ajax(this.buildURL(root, "bulk"), "PUT", {
         
     | 
| 
       3548 
     | 
    
         
            -
                  data: data,
         
     | 
| 
       3549 
     | 
    
         
            -
                  success: function(json) {
         
     | 
| 
       3550 
     | 
    
         
            -
                    this.sideload(store, type, json, plural);
         
     | 
| 
       3551 
     | 
    
         
            -
                    store.didUpdateRecords(records, json[plural]);
         
     | 
| 
       3552 
     | 
    
         
            -
                  }
         
     | 
| 
       3553 
     | 
    
         
            -
                });
         
     | 
| 
       3554 
     | 
    
         
            -
              },
         
     | 
| 
       3555 
     | 
    
         
            -
             
     | 
| 
       3556 
     | 
    
         
            -
              deleteRecord: function(store, type, record) {
         
     | 
| 
       3557 
     | 
    
         
            -
                var id = get(record, 'id');
         
     | 
| 
       3558 
     | 
    
         
            -
                var root = this.rootForType(type);
         
     | 
| 
       3559 
     | 
    
         
            -
             
     | 
| 
       3560 
     | 
    
         
            -
                this.ajax(this.buildURL(root, id), "DELETE", {
         
     | 
| 
       3561 
     | 
    
         
            -
                  success: function(json) {
         
     | 
| 
       3562 
     | 
    
         
            -
                    if (json) { this.sideload(store, type, json); }
         
     | 
| 
       3563 
     | 
    
         
            -
                    store.didDeleteRecord(record);
         
     | 
| 
       3564 
     | 
    
         
            -
                  }
         
     | 
| 
       3565 
     | 
    
         
            -
                });
         
     | 
| 
       3566 
     | 
    
         
            -
              },
         
     | 
| 
       3567 
     | 
    
         
            -
             
     | 
| 
       3568 
     | 
    
         
            -
              deleteRecords: function(store, type, records) {
         
     | 
| 
       3569 
     | 
    
         
            -
                if (get(this, 'bulkCommit') === false) {
         
     | 
| 
       3570 
     | 
    
         
            -
                  return this._super(store, type, records);
         
     | 
| 
       3571 
     | 
    
         
            -
                }
         
     | 
| 
       3572 
     | 
    
         
            -
             
     | 
| 
       3573 
     | 
    
         
            -
                var root = this.rootForType(type),
         
     | 
| 
       3574 
     | 
    
         
            -
                    plural = this.pluralize(root);
         
     | 
| 
       3575 
     | 
    
         
            -
             
     | 
| 
       3576 
     | 
    
         
            -
                var data = {};
         
     | 
| 
       3577 
     | 
    
         
            -
                data[plural] = records.map(function(record) {
         
     | 
| 
       3578 
     | 
    
         
            -
                  return get(record, 'id');
         
     | 
| 
       3579 
     | 
    
         
            -
                });
         
     | 
| 
       3580 
     | 
    
         
            -
             
     | 
| 
       3581 
     | 
    
         
            -
                this.ajax(this.buildURL(root, 'bulk'), "DELETE", {
         
     | 
| 
       3582 
     | 
    
         
            -
                  data: data,
         
     | 
| 
       3583 
     | 
    
         
            -
                  success: function(json) {
         
     | 
| 
       3584 
     | 
    
         
            -
                    if (json) { this.sideload(store, type, json); }
         
     | 
| 
       3585 
     | 
    
         
            -
                    store.didDeleteRecords(records);
         
     | 
| 
       3586 
     | 
    
         
            -
                  }
         
     | 
| 
       3587 
     | 
    
         
            -
                });
         
     | 
| 
       3588 
     | 
    
         
            -
              },
         
     | 
| 
       3589 
     | 
    
         
            -
             
     | 
| 
       3590 
     | 
    
         
            -
              find: function(store, type, id) {
         
     | 
| 
       3591 
     | 
    
         
            -
                var root = this.rootForType(type);
         
     | 
| 
       3592 
     | 
    
         
            -
             
     | 
| 
       3593 
     | 
    
         
            -
                this.ajax(this.buildURL(root, id), "GET", {
         
     | 
| 
       3594 
     | 
    
         
            -
                  success: function(json) {
         
     | 
| 
       3595 
     | 
    
         
            -
                    store.load(type, json[root]);
         
     | 
| 
       3596 
     | 
    
         
            -
                    this.sideload(store, type, json, root);
         
     | 
| 
       3597 
     | 
    
         
            -
                  }
         
     | 
| 
       3598 
     | 
    
         
            -
                });
         
     | 
| 
       3599 
     | 
    
         
            -
              },
         
     | 
| 
       3600 
     | 
    
         
            -
             
     | 
| 
       3601 
     | 
    
         
            -
              findMany: function(store, type, ids) {
         
     | 
| 
       3602 
     | 
    
         
            -
                var root = this.rootForType(type), plural = this.pluralize(root);
         
     | 
| 
       3603 
     | 
    
         
            -
             
     | 
| 
       3604 
     | 
    
         
            -
                this.ajax(this.buildURL(root), "GET", {
         
     | 
| 
       3605 
     | 
    
         
            -
                  data: { ids: ids },
         
     | 
| 
       3606 
     | 
    
         
            -
                  success: function(json) {
         
     | 
| 
       3607 
     | 
    
         
            -
                    store.loadMany(type, json[plural]);
         
     | 
| 
       3608 
     | 
    
         
            -
                    this.sideload(store, type, json, plural);
         
     | 
| 
       3609 
     | 
    
         
            -
                  }
         
     | 
| 
       3610 
     | 
    
         
            -
                });
         
     | 
| 
       3611 
     | 
    
         
            -
              },
         
     | 
| 
       3612 
     | 
    
         
            -
             
     | 
| 
       3613 
     | 
    
         
            -
              findAll: function(store, type) {
         
     | 
| 
       3614 
     | 
    
         
            -
                var root = this.rootForType(type), plural = this.pluralize(root);
         
     | 
| 
       3615 
     | 
    
         
            -
             
     | 
| 
       3616 
     | 
    
         
            -
                this.ajax(this.buildURL(root), "GET", {
         
     | 
| 
       3617 
     | 
    
         
            -
                  success: function(json) {
         
     | 
| 
       3618 
     | 
    
         
            -
                    store.loadMany(type, json[plural]);
         
     | 
| 
       3619 
     | 
    
         
            -
                    this.sideload(store, type, json, plural);
         
     | 
| 
       3620 
     | 
    
         
            -
                  }
         
     | 
| 
       3621 
     | 
    
         
            -
                });
         
     | 
| 
       3622 
     | 
    
         
            -
              },
         
     | 
| 
       3623 
     | 
    
         
            -
             
     | 
| 
       3624 
     | 
    
         
            -
              findQuery: function(store, type, query, recordArray) {
         
     | 
| 
       3625 
     | 
    
         
            -
                var root = this.rootForType(type), plural = this.pluralize(root);
         
     | 
| 
       3626 
     | 
    
         
            -
             
     | 
| 
       3627 
     | 
    
         
            -
                this.ajax(this.buildURL(root), "GET", {
         
     | 
| 
       3628 
     | 
    
         
            -
                  data: query,
         
     | 
| 
       3629 
     | 
    
         
            -
                  success: function(json) {
         
     | 
| 
       3630 
     | 
    
         
            -
                    recordArray.load(json[plural]);
         
     | 
| 
       3631 
     | 
    
         
            -
                    this.sideload(store, type, json, plural);
         
     | 
| 
       3632 
     | 
    
         
            -
                  }
         
     | 
| 
       3633 
     | 
    
         
            -
                });
         
     | 
| 
       3634 
     | 
    
         
            -
              },
         
     | 
| 
       3635 
     | 
    
         
            -
             
     | 
| 
       3636 
     | 
    
         
            -
              // HELPERS
         
     | 
| 
       3637 
     | 
    
         
            -
             
     | 
| 
       3638 
     | 
    
         
            -
              plurals: {},
         
     | 
| 
       3639 
     | 
    
         
            -
             
     | 
| 
       3640 
     | 
    
         
            -
              // define a plurals hash in your subclass to define
         
     | 
| 
       3641 
     | 
    
         
            -
              // special-case pluralization
         
     | 
| 
       3642 
     | 
    
         
            -
              pluralize: function(name) {
         
     | 
| 
       3643 
     | 
    
         
            -
                return this.plurals[name] || name + "s";
         
     | 
| 
       3644 
     | 
    
         
            -
              },
         
     | 
| 
       3645 
     | 
    
         
            -
             
     | 
| 
       3646 
     | 
    
         
            -
              rootForType: function(type) {
         
     | 
| 
       3647 
     | 
    
         
            -
                if (type.url) { return type.url; }
         
     | 
| 
       3648 
     | 
    
         
            -
             
     | 
| 
       3649 
     | 
    
         
            -
                // use the last part of the name as the URL
         
     | 
| 
       3650 
     | 
    
         
            -
                var parts = type.toString().split(".");
         
     | 
| 
       3651 
     | 
    
         
            -
                var name = parts[parts.length - 1];
         
     | 
| 
       3652 
     | 
    
         
            -
                return name.replace(/([A-Z])/g, '_$1').toLowerCase().slice(1);
         
     | 
| 
       3653 
     | 
    
         
            -
              },
         
     | 
| 
       3654 
     | 
    
         
            -
             
     | 
| 
       3655 
     | 
    
         
            -
              ajax: function(url, type, hash) {
         
     | 
| 
       3656 
     | 
    
         
            -
                hash.url = url;
         
     | 
| 
       3657 
     | 
    
         
            -
                hash.type = type;
         
     | 
| 
       3658 
     | 
    
         
            -
                hash.dataType = 'json';
         
     | 
| 
       3659 
     | 
    
         
            -
                hash.contentType = 'application/json; charset=utf-8';
         
     | 
| 
       3660 
     | 
    
         
            -
                hash.context = this;
         
     | 
| 
       3661 
     | 
    
         
            -
             
     | 
| 
       3662 
     | 
    
         
            -
                if (hash.data && type !== 'GET') {
         
     | 
| 
       3663 
     | 
    
         
            -
                  hash.data = JSON.stringify(hash.data);
         
     | 
| 
       3664 
     | 
    
         
            -
                }
         
     | 
| 
       3665 
     | 
    
         
            -
             
     | 
| 
       3666 
     | 
    
         
            -
                jQuery.ajax(hash);
         
     | 
| 
       3667 
     | 
    
         
            -
              },
         
     | 
| 
       3668 
     | 
    
         
            -
             
     | 
| 
       3669 
     | 
    
         
            -
              sideload: function(store, type, json, root) {
         
     | 
| 
       3670 
     | 
    
         
            -
                var sideloadedType, mappings;
         
     | 
| 
       3671 
     | 
    
         
            -
             
     | 
| 
       3672 
     | 
    
         
            -
                for (var prop in json) {
         
     | 
| 
       3673 
     | 
    
         
            -
                  if (!json.hasOwnProperty(prop)) { continue; }
         
     | 
| 
       3674 
     | 
    
         
            -
                  if (prop === root) { continue; }
         
     | 
| 
       3675 
     | 
    
         
            -
             
     | 
| 
       3676 
     | 
    
         
            -
                  sideloadedType = type.typeForAssociation(prop);
         
     | 
| 
       3677 
     | 
    
         
            -
             
     | 
| 
       3678 
     | 
    
         
            -
                  if (!sideloadedType) {
         
     | 
| 
       3679 
     | 
    
         
            -
                    mappings = get(this, 'mappings');
         
     | 
| 
       3680 
     | 
    
         
            -
             
     | 
| 
       3681 
     | 
    
         
            -
             
     | 
| 
       3682 
     | 
    
         
            -
                    sideloadedType = get(mappings, prop);
         
     | 
| 
       3683 
     | 
    
         
            -
             
     | 
| 
       3684 
     | 
    
         
            -
                  }
         
     | 
| 
       3685 
     | 
    
         
            -
             
     | 
| 
       3686 
     | 
    
         
            -
                  this.loadValue(store, sideloadedType, json[prop]);
         
     | 
| 
       3687 
     | 
    
         
            -
                }
         
     | 
| 
       3688 
     | 
    
         
            -
              },
         
     | 
| 
       3689 
     | 
    
         
            -
             
     | 
| 
       3690 
     | 
    
         
            -
              loadValue: function(store, type, value) {
         
     | 
| 
       3691 
     | 
    
         
            -
                if (value instanceof Array) {
         
     | 
| 
       3692 
     | 
    
         
            -
                  store.loadMany(type, value);
         
     | 
| 
       3693 
     | 
    
         
            -
                } else {
         
     | 
| 
       3694 
     | 
    
         
            -
                  store.load(type, value);
         
     | 
| 
       3695 
     | 
    
         
            -
                }
         
     | 
| 
       3696 
     | 
    
         
            -
              },
         
     | 
| 
       3697 
     | 
    
         
            -
             
     | 
| 
       3698 
     | 
    
         
            -
              buildURL: function(record, suffix) {
         
     | 
| 
       3699 
     | 
    
         
            -
                var url = [""];
         
     | 
| 
       3700 
     | 
    
         
            -
             
     | 
| 
       3701 
     | 
    
         
            -
             
     | 
| 
       3702 
     | 
    
         
            -
             
     | 
| 
       3703 
     | 
    
         
            -
             
     | 
| 
       3704 
     | 
    
         
            -
                if (this.namespace !== undefined) {
         
     | 
| 
       3705 
     | 
    
         
            -
                  url.push(this.namespace);
         
     | 
| 
       3706 
     | 
    
         
            -
                }
         
     | 
| 
       3707 
     | 
    
         
            -
             
     | 
| 
       3708 
     | 
    
         
            -
                url.push(this.pluralize(record));
         
     | 
| 
       3709 
     | 
    
         
            -
                if (suffix !== undefined) {
         
     | 
| 
       3710 
     | 
    
         
            -
                  url.push(suffix);
         
     | 
| 
       3711 
     | 
    
         
            -
                }
         
     | 
| 
       3712 
     | 
    
         
            -
             
     | 
| 
       3713 
     | 
    
         
            -
                return url.join("/");
         
     | 
| 
       3714 
     | 
    
         
            -
              }
         
     | 
| 
       3715 
     | 
    
         
            -
            });
         
     | 
| 
       3716 
     | 
    
         
            -
             
     | 
| 
       3717 
     | 
    
         
            -
             
     | 
| 
       3718 
     | 
    
         
            -
            })();
         
     | 
| 
       3719 
     | 
    
         
            -
             
     | 
| 
       3720 
     | 
    
         
            -
             
     | 
| 
       3721 
     | 
    
         
            -
             
     | 
| 
       3722 
     | 
    
         
            -
            (function() {
         
     | 
| 
       3723 
     | 
    
         
            -
            //Copyright (C) 2011 by Living Social, Inc.
         
     | 
| 
       3724 
     | 
    
         
            -
             
     | 
| 
       3725 
     | 
    
         
            -
            //Permission is hereby granted, free of charge, to any person obtaining a copy of
         
     | 
| 
       3726 
     | 
    
         
            -
            //this software and associated documentation files (the "Software"), to deal in
         
     | 
| 
       3727 
     | 
    
         
            -
            //the Software without restriction, including without limitation the rights to
         
     | 
| 
       3728 
     | 
    
         
            -
            //use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
         
     | 
| 
       3729 
     | 
    
         
            -
            //of the Software, and to permit persons to whom the Software is furnished to do
         
     | 
| 
       3730 
     | 
    
         
            -
            //so, subject to the following conditions:
         
     | 
| 
       3731 
     | 
    
         
            -
             
     | 
| 
       3732 
     | 
    
         
            -
            //The above copyright notice and this permission notice shall be included in all
         
     | 
| 
       3733 
     | 
    
         
            -
            //copies or substantial portions of the Software.
         
     | 
| 
       3734 
     | 
    
         
            -
             
     | 
| 
       3735 
     | 
    
         
            -
            //THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
         
     | 
| 
       3736 
     | 
    
         
            -
            //IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
         
     | 
| 
       3737 
     | 
    
         
            -
            //FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
         
     | 
| 
       3738 
     | 
    
         
            -
            //AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
         
     | 
| 
       3739 
     | 
    
         
            -
            //LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
         
     | 
| 
       3740 
     | 
    
         
            -
            //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         
     | 
| 
       3741 
     | 
    
         
            -
            //SOFTWARE.
         
     | 
| 
       3742 
     | 
    
         
            -
             
     | 
| 
       3743 
     | 
    
         
            -
            })();
         
     | 
| 
       3744 
     | 
    
         
            -
             
     | 
| 
      
 9 
     | 
    
         
            +
            (function(){window.DS=Ember.Namespace.create({CURRENT_API_REVISION:4})})(),function(){var a=Ember.get,b=Ember.set;DS.RecordArray=Ember.ArrayProxy.extend({type:null,content:null,store:null,init:function(){b(this,"recordCache",Ember.A([])),this._super()},arrayDidChange:function(b,c,d,e){var f=a(this,"recordCache");f.replace(c,0,new Array(e)),this._super(b,c,d,e)},arrayWillChange:function(b,c,d,e){this._super(b,c,d,e);var f=a(this,"recordCache");f.replace(c,d)},objectAtContent:function(b){var c=a(this,"recordCache"),d=c.objectAt(b);if(!d){var e=a(this,"store"),f=a(this,"content"),g=f.objectAt(b);g!==undefined&&(d=e.findByClientId(a(this,"type"),g),c.replace(b,1,[d]))}return d}})}(),function(){var a=Ember.get;DS.FilteredRecordArray=DS.RecordArray.extend({filterFunction:null,replace:function(){var b=a(this,"type").toString();throw new Error("The result of a client-side filter (on "+b+") is immutable.")},updateFilter:Ember.observer(function(){var b=a(this,"store");b.updateRecordArrayFilter(this,a(this,"type"),a(this,"filterFunction"))},"filterFunction")})}(),function(){var a=Ember.get,b=Ember.set;DS.AdapterPopulatedRecordArray=DS.RecordArray.extend({query:null,isLoaded:!1,replace:function(){var b=a(this,"type").toString();throw new Error("The result of a server query (on "+b+") is immutable.")},load:function(c){var d=a(this,"store"),e=a(this,"type"),f=d.loadMany(e,c).clientIds;this.beginPropertyChanges(),b(this,"content",Ember.A(f)),b(this,"isLoaded",!0),this.endPropertyChanges()}})}(),function(){var a=Ember.get,b=Ember.set,c=Ember.guidFor,d=function(){this.hash={},this.list=[]};d.prototype={add:function(a){var b=this.hash,d=c(a);if(b.hasOwnProperty(d))return;b[d]=!0,this.list.push(a)},remove:function(a){var b=this.hash,d=c(a);if(!b.hasOwnProperty(d))return;delete b[d];var e=this.list,f=Ember.ArrayUtils.indexOf(this,a);e.splice(f,1)},isEmpty:function(){return this.list.length===0}};var e=Ember.State.extend({recordWasAdded:function(b,c){var d=b.dirty,e;d.add(c),e=function(){a(c,"isDirty")||(c.removeObserver("isDirty",e),b.send("childWasSaved",c))},c.addObserver("isDirty",e)},recordWasRemoved:function(b,c){var d=b.dirty,e;d.add(c),e=function(){c.removeObserver("isDirty",e),a(c,"isDirty")||b.send("childWasSaved",c)},c.addObserver("isDirty",e)}}),f={clean:e.create({isDirty:!1,recordWasAdded:function(a,b){this._super(a,b),a.goToState("dirty")},update:function(a,c){var d=a.manyArray;b(d,"content",c)}}),dirty:e.create({isDirty:!0,childWasSaved:function(a,b){var c=a.dirty;c.remove(b),c.isEmpty()&&a.send("arrayBecameSaved")},arrayBecameSaved:function(a){a.goToState("clean")}})};DS.ManyArrayStateManager=Ember.StateManager.extend({manyArray:null,initialState:"clean",states:f,init:function(){this._super(),this.dirty=new d}})}(),function(){var a=Ember.get,b=Ember.set,c=Ember.getPath;DS.ManyArray=DS.RecordArray.extend({init:function(){return b(this,"stateManager",DS.ManyArrayStateManager.create({manyArray:this})),this._super()},parentRecord:null,isDirty:Ember.computed(function(){return c(this,"stateManager.currentState.isDirty")}).property("stateManager.currentState").cacheable(),fetch:function(){var b=a(this,"content"),c=a(this,"store"),d=a(this,"type"),e=b.map(function(a){return c.clientIdToId[a]});c.fetchMany(d,e)},replace:function(b,c,d){var e=a(this,"parentRecord"),f=e&&!a(e,"id"),g=a(this,"stateManager");d=d.map(function(a){return f&&a.send("waitingOn",e),this.assignInverse(a,e),g.send("recordWasAdded",a),a.get("clientId")},this);var h=this.store,i=b+c,j;for(var k=b;k<i;k++)j=this.objectAt(k),this.assignInverse(j,e,!0),f&&j.send("doneWaitingOn",e),g.send("recordWasAdded",j);this._super(b,c,d)},assignInverse:function(c,d,e){var f=a(c.constructor,"associations"),g=f.get(d.constructor),h,i;if(!g)return;for(var j=0,k=g.length;j<k;j++){h=g[j];if(h.kind==="belongsTo"){i=h;break}}i&&b(c,i.name,e?null:d)},createRecord:function(b,c){var d=a(this,"parentRecord"),e=a(d,"store"),f=a(this,"type"),g;return c=c||a(d,"transaction"),g=e.createRecord.call(e,f,b,c),this.pushObject(g),g}})}(),function(){}(),function(){var a=Ember.get,b=Ember.set,c=Ember.getPath,d=Ember.String.fmt;DS.Transaction=Ember.Object.extend({init:function(){b(this,"buckets",{clean:Ember.Map.create(),created:Ember.Map.create(),updated:Ember.Map.create(),deleted:Ember.Map.create(),inflight:Ember.Map.create()})},createRecord:function(b,c){var d=a(this,"store");return d.createRecord(b,c,this)},add:function(b){var d=a(b,"transaction"),e=c(this,"store.defaultTransaction");this.adoptRecord(b)},commit:function(){var b=this,c;c=function(c,d,e){var f=b.bucketForType(c);f.forEach(function(b,c){if(c.isEmpty())return;var f=[];c.forEach(function(b){b.send("willCommit"),a(b,"isPending")===!1&&f.push(b)}),d.call(e,b,f)})};var e={updated:{eachType:function(a,b){c("updated",a,b)}},created:{eachType:function(a,b){c("created",a,b)}},deleted:{eachType:function(a,b){c("deleted",a,b)}}},f=a(this,"store"),g=a(f,"_adapter");this.removeCleanRecords();if(g&&g.commit)g.commit(f,e);else throw d("Adapter is either null or does not implement `commit` method",this)},rollback:function(){var b=a(this,"store"),c;["created","updated","deleted","inflight"].forEach(function(a){c=this.bucketForType(a),c.forEach(function(a,b){b.forEach(function(a){a.send("rollback")})})},this),this.removeCleanRecords()},remove:function(a){var b=c(this,"store.defaultTransaction");b.adoptRecord(a)},removeCleanRecords:function(){var a=this.bucketForType("clean"),b=this;a.forEach(function(a,c){c.forEach(function(a){b.remove(a)})})},bucketForType:function(b){var c=a(this,"buckets");return a(c,b)},adoptRecord:function(c){var d=a(c,"transaction");d&&d.removeFromBucket("clean",c),this.addToBucket("clean",c),b(c,"transaction",this)},addToBucket:function(a,b){var c=this.bucketForType(a),d=b.constructor,e=c.get(d);e||(e=Ember.OrderedSet.create(),c.set(d,e)),e.add(b)},removeFromBucket:function(a,b){var c=this.bucketForType(a),d=b.constructor,e=c.get(d);e.remove(b)},recordBecameDirty:function(a,b){this.removeFromBucket("clean",b),this.addToBucket(a,b)},recordBecameInFlight:function(a,b){this.removeFromBucket(a,b),this.addToBucket("inflight",b)},recordBecameClean:function(a,b){this.removeFromBucket(a,b),this.remove(b)}})}(),function(){var a=Ember.get,b=Ember.set,c=Ember.getPath,d=Ember.String.fmt,e={get:function(a){return this.savedData[a]}},f="unloaded",g="loading";DS.Store=Ember.Object.extend({init:function(){var c=a(this,"revision");if(c!==DS.CURRENT_API_REVISION&&!Ember.ENV.TESTING)throw new Error("Error: The Ember Data library has had breaking API changes since the last time you updated the library. Please review the list of breaking changes at https://github.com/emberjs/data/blob/master/BREAKING_CHANGES.md, then update your store's `revision` property to "+DS.CURRENT_API_REVISION);return(!a(DS,"defaultStore")||a(this,"isDefaultStore"))&&b(DS,"defaultStore",this),this.typeMaps={},this.recordCache=[],this.clientIdToId={},this.recordArraysByClientId={},b(this,"defaultTransaction",this.transaction()),this._super()},transaction:function(){return DS.Transaction.create({store:this})},dataForRecord:function(b){var c=b.constructor,d=a(b,"clientId"),e=this.typeMapFor(c);return e.cidToHash[d]},adapter:null,_adapter:Ember.computed(function(){var b=a(this,"adapter");return typeof b=="string"?c(this,b,!1)||c(window,b):b}).property("adapter").cacheable(),clientIdCounter:1,createRecord:function(c,d,e){d=d||{};var f=c._create({store:this});e=e||a(this,"defaultTransaction"),e.adoptRecord(f);var g=a(f,"primaryKey"),h=d[g]||null,i;Ember.none(h)&&(i=a(this,"adapter"),i&&i.generateIdForRecord&&(h=i.generateIdForRecord(this,f),d.id=h));var j={},k;k=this.pushHash(j,h,c),f.send("didChangeData");var l=a(this,"recordCache");return b(f,"clientId",k),l[k]=f,f.setProperties(d),this.updateRecordArrays(c,k,a(f,"data")),f},deleteRecord:function(a){a.send("deleteRecord")},find:function(a,b,c){if(b===undefined)return this.findAll(a);if(c!==undefined)return this.findMany(a,b,c);if(Ember.typeOf(b)==="object")return this.findQuery(a,b);if(Ember.isArray(b))return this.findMany(a,b);var d=this.typeMapFor(a).idToCid[b];return this.findByClientId(a,d,b)},findByClientId:function(b,c,e){var f=a(this,"recordCache"),h=this.typeMapFor(b).cidToHash,i;if(c!==undefined)i=f[c],i||(i=this.materializeRecord(b,c),typeof h[c]=="object"&&i.send("didChangeData"));else{c=this.pushHash(g,e,b),i=this.materializeRecord(b,c,e);var j=a(this,"_adapter");if(j&&j.find)j.find(this,b,e);else throw d("Adapter is either null or does not implement `find` method",this)}return i},fetchMany:function(b,c,e){var h=this.typeMapFor(b),i=h.idToCid,j=h.cidToHash,k=h.cidToHash,l,m=Ember.A([]);c?(l=[],c.forEach(function(a){var c=i[a];c===undefined?(c=this.pushHash(g,a,b),l.push(a)):c&&k[c]===f&&(j[c]=g,l.push(a)),m.push(c)},this)):l=null;if(l&&a(l,"length")>0||e){var n=a(this,"_adapter");if(n&&n.findMany)n.findMany(this,b,l,e);else throw d("Adapter is either null or does not implement `findMany` method",this)}return m},findMany:function(a,b,c){var d=this.fetchMany(a,b,c);return this.createManyArray(a,d)},findQuery:function(b,c){var e=DS.AdapterPopulatedRecordArray.create({type:b,content:Ember.A([]),store:this}),f=a(this,"_adapter");if(f&&f.findQuery)f.findQuery(this,b,c,e);else throw d("Adapter is either null or does not implement `findQuery` method",this);return e},findAll:function(b){var c=this.typeMapFor(b),d=c.findAllCache;if(d)return d;var e=DS.RecordArray.create({type:b,content:Ember.A([]),store:this});this.registerRecordArray(e,b);var f=a(this,"_adapter");return f&&f.findAll&&f.findAll(this,b),c.findAllCache=e,e},filter:function(a,b,c){arguments.length===3?this.findQuery(a,b):arguments.length===2&&(c=b);var d=DS.FilteredRecordArray.create({type:a,content:Ember.A([]),store:this,filterFunction:c});return this.registerRecordArray(d,a,c),d},hashWasUpdated:function(b,c,d){if(a(d,"isDeleted"))return;this.updateRecordArrays(b,c,a(d,"data"))},commit:function(){var c=a(this,"defaultTransaction");b(this,"defaultTransaction",this.transaction()),c.commit()},didUpdateRecords:function(a,b){b?a.forEach(function(a,c){this.didUpdateRecord(a,b[c])},this):a.forEach(function(a){this.didUpdateRecord(a)},this)},didUpdateRecord:function(b,c){if(c){var d=a(b,"clientId"),e=this.typeMapFor(b.constructor).cidToHash;e[d]=c,b.send("didChangeData"),b.hashWasUpdated()}else b.send("didSaveData");b.send("didCommit")},didDeleteRecords:function(a){a.forEach(function(a){a.send("didCommit")})},didDeleteRecord:function(a){a.send("didCommit")},_didCreateRecord:function(b,c,d,e,f){var g=a(b,"data"),h,i;c?(d.cidToHash[e]=c,b.beginPropertyChanges(),b.send("didChangeData"),g.adapterDidUpdate(),b.hashWasUpdated(),b.endPropertyChanges(),h=c[f],d.idToCid[h]=e,this.clientIdToId[e]=h):g.commit(),b.send("didCommit")},didCreateRecords:function(b,c,d){var e=b.proto().primaryKey,f=this.typeMapFor(b),g;for(var h=0,i=a(c,"length");h<i;h++){var j=c[h],k=d[h];g=a(j,"clientId"),this._didCreateRecord(j,k,f,g,e)}},didCreateRecord:function(b,c){var d=b.constructor,e=this.typeMapFor(d),f,g;g=d.proto().primaryKey,!c,f=a(b,"clientId"),this._didCreateRecord(b,c,e,f,g)},recordWasInvalid:function(a,b){a.send("becameInvalid",b)},registerRecordArray:function(a,b,c){var d=this.typeMapFor(b).recordArrays;d.push(a),this.updateRecordArrayFilter(a,b,c)},createManyArray:function(a,b){var c=DS.ManyArray.create({type:a,content:b,store:this});return b.forEach(function(a){var b=this.recordArraysForClientId(a);b.add(c)},this),c},updateRecordArrayFilter:function(b,c,d){var f=this.typeMapFor(c),g=f.cidToHash,h=f.clientIds,i,j,k,l=a(this,"recordCache"),m;for(var n=0,o=h.length;n<o;n++)i=h[n],j=g[i],typeof j=="object"&&((m=l[i])?k=a(m,"data"):(e.savedData=j,k=e),this.updateRecordArray(b,d,c,i,k))},updateRecordArrays:function(b,c,d){var e=this.typeMapFor(b).recordArrays,f;e.forEach(function(e){f=a(e,"filterFunction"),this.updateRecordArray(e,f,b,c,d)},this)},updateRecordArray:function(b,c,d,e,f){var g;c?g=c(f):g=!0;var h=a(b,"content"),i=h.indexOf(e)!==-1,j=this.recordArraysForClientId(e);g&&!i?(j.add(b),h.pushObject(e)):!g&&i&&(j.remove(b),h.removeObject(e))},removeFromRecordArrays:function(b){var c=a(b,"clientId"),d=this.recordArraysForClientId(c);d.forEach(function(b){var d=a(b,"content");d.removeObject(c)})},recordArraysForClientId:function(b){var c=a(this,"recordArraysByClientId"),d=c[b];return d||(d=c[b]=Ember.OrderedSet.create()),d},typeMapFor:function(b){var c=a(this,"typeMaps"),d=Ember.guidFor(b),e=c[d];return e?e:c[d]={idToCid:{},clientIds:[],cidToHash:{},recordArrays:[]}},clientIdForId:function(a,b){var c=this.typeMapFor(a).idToCid[b];return c!==undefined?c:this.pushHash(f,b,a)},load:function(b,c,d){if(d===undefined){d=c;var f=b.proto().primaryKey;c=d[f]}var g=this.typeMapFor(b),h=g.cidToHash,i=g.idToCid[c],j=a(this,"recordCache");if(i!==undefined){h[i]=d;var k=j[i];k&&k.send("didChangeData")}else i=this.pushHash(d,c,b);return e.savedData=d,this.updateRecordArrays(b,i,e),{id:c,clientId:i}},loadMany:function(b,c,d){var e=Ember.A([]);if(d===undefined){d=c,c=[];var f=b.proto().primaryKey;c=Ember.ArrayUtils.map(d,function(a){return a[f]})}for(var g=0,h=a(c,"length");g<h;g++){var i=this.load(b,c[g],d[g]);e.pushObject(i.clientId)}return{clientIds:e,ids:c}},pushHash:function(a,b,c){var d=this.typeMapFor(c),e=d.idToCid,f=this.clientIdToId,g=d.clientIds,h=d.cidToHash,i=++this.clientIdCounter;return h[i]=a,b&&(e[b]=i,f[i]=b),g.push(i),i},materializeRecord:function(b,c,d){var e;return a(this,"recordCache")[c]=e=b._create({store:this,clientId:c,_id:d}),a(this,"defaultTransaction").adoptRecord(e),e.send("loadingData"),e},destroy:function(){return a(DS,"defaultStore")===this&&b(DS,"defaultStore",null),this._super()}})}(),function(){var a=Ember.get,b=Ember.set,c=Ember.getPath,d=Ember.guidFor,e=Ember.computed(function(b){var c=a(this,"parentState");if(c)return a(c,b)}).property(),f=function(a){for(var b in a)if(a.hasOwnProperty(b))return!1;return!0},g=function(a){for(var b in a)if(a.hasOwnProperty(b)&&a[b])return!0;return!1};DS.State=Ember.State.extend({isLoaded:e,isDirty:e,isSaving:e,isDeleted:e,isError:e,isNew:e,isValid:e,isPending:e,dirtyType:e});var h=function(c,d){var e=d.key,f=d.value,g=a(c,"record"),h=a(g,"data");b(h,e,f)},i=function(b,c){var d=c.key,e=c.value,f=a(b,"record"),g=a(f,"data");g.setAssociation(d,e)},j=function(b){var c=a(b,"record"),d=a(c,"data");d._savedData=null,c.notifyPropertyChange("data")},k=function(b,c){var e=a(b,"record"),f=a(e,"pendingQueue"),g=d(c),h=function(){a(c,"id")&&(b.send("doneWaitingOn",c),Ember.removeObserver(c,"id",h))};f[g]=[c,h],Ember.addObserver(c,"id",h)},l=Ember.Mixin.create({setProperty:h,setAssociation:i}),m=Ember.Mixin.create({deleteRecord:function(b){var c=a(b,"record");this._super(b),c.withTransaction(function(a){a.recordBecameClean("created",c)}),b.goToState("deleted.saved")}}),n=Ember.Mixin.create({deleteRecord:function(b){this._super(b);var c=a(b,"record");c.withTransaction(function(a){a.recordBecameClean("updated",c)}),b.goToState("deleted")}}),o=DS.State.extend({initialState:"uncommitted",isDirty:!0,uncommitted:DS.State.extend({enter:function(b){var c=a(this,"dirtyType"),d=a(b,"record");d.withTransaction(function(a){a.recordBecameDirty(c,d)})},deleteRecord:Ember.K,waitingOn:function(a,b){k(a,b),a.goToState("pending")},willCommit:function(a){a.goToState("inFlight")},becameInvalid:function(b){var c=a(this,"dirtyType"),d=a(b,"record");d.withTransaction(function(a){a.recordBecameInFlight(c,d)}),b.goToState("invalid")},rollback:function(b){var c=a(b,"record"),d=a(this,"dirtyType"),e=a(c,"data");e.rollback(),c.withTransaction(function(a){a.recordBecameClean(d,c)}),b.goToState("loaded")}},l),inFlight:DS.State.extend({isSaving:!0,enter:function(b){var c=a(this,"dirtyType"),d=a(b,"record");d.withTransaction(function(a){a.recordBecameInFlight(c,d)})},didCommit:function(b){var c=a(this,"dirtyType"),d=a(b,"record");d.withTransaction(function(a){a.recordBecameClean("inflight",d)}),b.goToState("loaded"),b.send("invokeLifecycleCallbacks",c)},becameInvalid:function(c,d){var e=a(c,"record");b(e,"errors",d),c.goToState("invalid"),c.send("invokeLifecycleCallbacks")},becameError:function(a){a.goToState("error"),a.send("invokeLifecycleCallbacks")},didChangeData:j}),pending:DS.State.extend({initialState:"uncommitted",isPending:!0,uncommitted:DS.State.extend({deleteRecord:function(b){var c=a(b,"record"),d=a(c,"pendingQueue"),e;for(var f in d){if(!d.hasOwnProperty(f))continue;e=d[f],Ember.removeObserver(e[0],"id",e[1])}},willCommit:function(a){a.goToState("committing")},doneWaitingOn:function(b,c){var e=a(b,"record"),g=a(e,"pendingQueue"),h=d(c);delete g[h],f(g)&&b.send("doneWaiting")},doneWaiting:function(b){var c=a(this,"dirtyType");b.goToState(c+".uncommitted")}},l),committing:DS.State.extend({isSaving:!0,doneWaitingOn:function(b,c){var e=a(b,"record"),g=a(e,"pendingQueue"),h=d(c);delete g[h],f(g)&&b.send("doneWaiting")},doneWaiting:function(b){var c=a(b,"record"),d=a(c,"transaction");Ember.run.once(d,d.commit)},willCommit:function(b){var c=a(b,"record"),d=a(c,"pendingQueue");if(f(d)){var e=a(this,"dirtyType");b.goToState(e+".inFlight")}}})}),invalid:DS.State.extend({isValid:!1,exit:function(b){var c=a(b,"record");c.withTransaction(function(a){a.recordBecameClean("inflight",c)})},deleteRecord:function(a){a.goToState("deleted")},setAssociation:i,setProperty:function(b,c){h(b,c);var d=a(b,"record"),e=a(d,"errors"),f=c.key;delete e[f],g(e)||b.send("becameValid")},rollback:function(a){a.send("becameValid"),a.send("rollback")},becameValid:function(a){a.goToState("uncommitted")},invokeLifecycleCallbacks:function(b){var c=a(b,"record");c.fire("becameInvalid",c)}})}),p=o.create({dirtyType:"created",isNew:!0}),q=o.create({dirtyType:"updated"});p.states.uncommitted.reopen(m),p.states.pending.states.uncommitted.reopen(m),p.states.uncommitted.reopen({rollback:function(a){this._super(a),a.goToState("deleted.saved")}}),q.states.uncommitted.reopen(n),q.states.pending.states.uncommitted.reopen(n),q.states.inFlight.reopen({didSaveData:function(b){var c=a(b,"record"),d=a(c,"data");d.saveData(),d.adapterDidUpdate()}});var r={rootState:Ember.State.create({isLoaded:!1,isDirty:!1,isSaving:!1,isDeleted:!1,isError:!1,isNew:!1,isValid:!0,isPending:!1,empty:DS.State.create({loadingData:function(a){a.goToState("loading")},didChangeData:function(a){j(a),a.goToState("loaded.created")}}),loading:DS.State.create({exit:function(b){var c=a(b,"record");c.fire("didLoad")},didChangeData:function(a,b){j(a),a.send("loadedData")},loadedData:function(a){a.goToState("loaded")}}),loaded:DS.State.create({initialState:"saved",isLoaded:!0,saved:DS.State.create({setProperty:function(a,b){h(a,b),a.goToState("updated")},setAssociation:function(a,b){i(a,b),a.goToState("updated")},didChangeData:j,deleteRecord:function(a){a.goToState("deleted")},waitingOn:function(a,b){k(a,b),a.goToState("updated.pending")},invokeLifecycleCallbacks:function(b,c){var d=a(b,"record");c==="created"?d.fire("didCreate",d):d.fire("didUpdate",d)}}),created:p,updated:q}),deleted:DS.State.create({isDeleted:!0,isLoaded:!0,isDirty:!0,enter:function(b){var c=a(b,"record"),d=a(c,"store");d.removeFromRecordArrays(c)},start:DS.State.create({enter:function(b){var c=a(b,"record");c.withTransaction(function(a){a.recordBecameDirty("deleted",c)})},willCommit:function(a){a.goToState("inFlight")},rollback:function(b){var c=a(b,"record"),d=a(c,"data");d.rollback(),c.withTransaction(function(a){a.recordBecameClean("deleted",c)}),b.goToState("loaded")}}),inFlight:DS.State.create({isSaving:!0,enter:function(b){var c=a(b,"record");c.withTransaction(function(a){a.recordBecameInFlight("deleted",c)})},didCommit:function(b){var c=a(b,"record");c.withTransaction(function(a){a.recordBecameClean("inflight",c)}),b.goToState("saved"),b.send("invokeLifecycleCallbacks")}}),saved:DS.State.create({isDirty:!1,invokeLifecycleCallbacks:function(b){var c=a(b,"record");c.fire("didDelete",c)}})}),error:DS.State.create({isError:!0,invokeLifecycleCallbacks:function(b){var c=a(b,"record");c.fire("becameError",c)}})})};DS.StateManager=Ember.StateManager.extend({record:null,initialState:"rootState",states:r})}(),function(){var a=Ember.get,b=Ember.set,c=DS._DataProxy=function(a){this.record=a,this.unsavedData={},this.associations={}};c.prototype={get:function(a){return Ember.get(this,a)},set:function(a,b){return Ember.set(this,a,b)},setAssociation:function(a,b){this.associations[a]=b},savedData:function(){var b=this._savedData;if(b)return b;var c=this.record,d=a(c,"clientId"),e=a(c,"store");if(e)return b=e.dataForRecord(c),this._savedData=b,b},unknownProperty:function(b){var c=this.unsavedData,d=this.associations,e=this.savedData(),f,g=c[b],h;return h=d[b],h!==undefined?(f=a(this.record,"store"),f.clientIdToId[h]):(e&&g===undefined&&(g=e[b]),g)},setUnknownProperty:function(a,b){var c=this.record,d=this.unsavedData;return d[a]=b,c.hashWasUpdated(),b},commit:function(){this.saveData(),this.record.notifyPropertyChange("data")},rollback:function(){this.unsavedData={},this.record.notifyPropertyChange("data")},saveData:function(){var a=this.record,b=this.unsavedData,c=this.savedData();for(var d in b)b.hasOwnProperty(d)&&(c[d]=b[d],delete b[d])},adapterDidUpdate:function(){this.unsavedData={}}}}(),function(){var a=Ember.get,b=Ember.set,c=Ember.getPath,d=Ember.none,e=Ember.computed(function(b){return a(c(this,"stateManager.currentState"),b)}).property("stateManager.currentState").cacheable();DS.Model=Ember.Object.extend(Ember.Evented,{isLoaded:e,isDirty:e,isSaving:e,isDeleted:e,isError:e,isNew:e,isPending:e,isValid:e,clientId:null,transaction:null,stateManager:null,pendingQueue:null,errors:null,primaryKey:"id",id:Ember.computed(function(c,d){var e=a(this,"primaryKey"),f=a(this,"data");if(arguments.length===2)return b(f,e,d),d;var g=a(f,e);return g?g:this._id}).property("primaryKey","data"),addIdToJSON:function(a,b,c){b&&(a[c]=b)},addAttributesToJSON:function(b,c,d){c.forEach(function(c,e){var f=e.key(this.constructor),g=a(d,f);g===undefined&&(g=e.options.defaultValue),b[f]=g},this)},addHasManyToJSON:function(b,c,d,e){var f=d.key,g=a(this,f),h=[],i,j,k,l;if(d.options.embedded)g.forEach(function(a){h.push(a.toJSON(e))});else{var m=a(g,"content");for(i=0,j=m.length;i<j;i++)k=m[i],l=a(this,"store").clientIdToId[k],l!==undefined&&h.push(l)}f=d.options.key||a(this,"namingConvention").keyToJSONKey(f),b[f]=h},addBelongsToToJSON:function(b,c,e,f){var g=e.key,h,i;e.options.embedded?(g=e.options.key||a(this,"namingConvention").keyToJSONKey(g),h=a(c.record,g),b[g]=h?h.toJSON(f):null):(g=e.options.key||a(this,"namingConvention").foreignKey(g),i=c.get(g),b[g]=d(i)?null:i)},toJSON:function(b){var c=a(this,"data"),d={},e=this.constructor,f=a(e,"attributes"),g=a(this,"primaryKey"),h=a(this,"id"),i=a(this,"store"),j;return b=b||{},this.addIdToJSON(d,h,g),this.addAttributesToJSON(d,f,c),j=a(e,"associationsByName"),j.forEach(function(a,e){b.associations&&e.kind==="hasMany"?this.addHasManyToJSON(d,c,e,b):e.kind==="belongsTo"&&this.addBelongsToToJSON(d,c,e,b)},this),d},data:Ember.computed(function(){return new DS._DataProxy(this)}).cacheable(),didLoad:Ember.K,didUpdate:Ember.K,didCreate:Ember.K,didDelete:Ember.K,becameInvalid:Ember.K,becameError:Ember.K,init:function(){var a=DS.StateManager.create({record:this});b(this,"pendingQueue",{}),b(this,"stateManager",a),a.goToState("empty")},destroy:function(){a(this,"isDeleted")||this.deleteRecord(),this._super()},send:function(b,c){return a(this,"stateManager").send(b,c)},withTransaction:function(b){var c=a(this,"transaction");c&&b(c)},setProperty:function(a,b){this.send("setProperty",{key:a,value:b})},deleteRecord:function(){this.send("deleteRecord")},waitingOn:function(a){this.send("waitingOn",a)},notifyHashWasUpdated:function(){var b=a(this,"store");b&&b.hashWasUpdated(this.constructor,a(this,"clientId"),this)},unknownProperty:function(b){var c=a(this,"data");!(c&&b in c)},setUnknownProperty:function(b,c){var d=a(this,"data");if(!(d&&b in d))return this._super(b,c)},namingConvention:{keyToJSONKey:function(a){return Ember.String.decamelize(a)},foreignKey:function(a){return Ember.String.decamelize(a)+"_id"}},hashWasUpdated:function(){Ember.run.once(this,this.notifyHashWasUpdated)},dataDidChange:Ember.observer(function(){var c=a(this.constructor,"associationsByName"),d=a(this,"data"),e=a(this,"store"),f=e.idToClientId,g;c.forEach(function(a,c){if(c.kind==="hasMany"){g=this.cacheFor(a);if(g){var f=c.options.key||a,h=d.get(f)||[],i=Ember.ArrayUtils.map(h,function(a){return e.clientIdForId(c.type,a)});b(g,"content",Ember.A(i)),g.fetch()}}},this)},"data"),fire:function(a){this[a].apply(this,[].slice.call(arguments,1)),this._super.apply(this,arguments)}});var f=function(b){return function(){var c=a(DS,"defaultStore"),d=[].slice.call(arguments);return d.unshift(this),c[b].apply(c,d)}};DS.Model.reopenClass({find:f("find"),filter:f("filter"),_create:DS.Model.create,create:function(){throw new Ember.Error("You should not call `create` on a model. Instead, call `createRecord` with the attributes you would like to set.")},createRecord:f("createRecord")})}(),function(){var a=Ember.get,b=Ember.getPath;DS.Model.reopenClass({attributes:Ember.computed(function(){var a=Ember.Map.create();return this.eachComputedProperty(function(b,c){c.isAttribute&&a.set(b,c)}),a}).cacheable(),processAttributeKeys:function(){if(this.processedAttributeKeys)return;var a=this.proto().namingConvention;this.eachComputedProperty(function(b,c){c.isAttribute&&!c.options.key&&(c.options.key=a.keyToJSONKey(b,this))},this)}}),DS.attr=function(b,c){var d=DS.attr.transforms[b],e=d.from,f=d.to;c=c||{};var g={type:b,isAttribute:!0,options:c,key:function(a){return a.processAttributeKeys(),c.key}};return Ember.computed(function(b,d){var h;return b=g.key(this.constructor),arguments.length===2?(d=f(d),this.setProperty(b,d)):(h=a(this,"data"),d=a(h,b),d===undefined&&(d=c.defaultValue)),e(d)}).property("data").cacheable().meta(g)},DS.attr.transforms={string:{from:function(a){return Ember.none(a)?null:String(a)},to:function(a){return Ember.none(a)?null:String(a)}},number:{from:function(a){return Ember.none(a)?null:Number(a)},to:function(a){return Ember.none(a)?null:Number(a)}},"boolean":{from:function(a){return Boolean(a)},to:function(a){return Boolean(a)}},date:{from:function(a){var b=typeof a;return b==="string"||b==="number"?new Date(a):a===null||a===undefined?a:null},to:function(a){if(a instanceof Date){var b=["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],c=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],d=function(a){return a<10?"0"+a:""+a},e=a.getUTCFullYear(),f=a.getUTCMonth(),g=a.getUTCDate(),h=a.getUTCDay(),i=a.getUTCHours(),j=a.getUTCMinutes(),k=a.getUTCSeconds(),l=b[h],m=d(g),n=c[f];return l+", "+m+" "+n+" "+e+" "+d(i)+":"+d(j)+":"+d(k)+" GMT"}return a===undefined?undefined:null}}}}(),function(){}(),function(){var a=Ember.get,b=Ember.set,c=Ember.getPath,d=Ember.none,e=function(b,c,e,f,g){var h=a(e,f);return d(h)?undefined:b.load(c,h).id},f=function(b,c,d,e,f){return a(d,e)},g=function(b,d,g){d=d||{};var h=d.embedded,i=h?e:f,j={type:b,isAssociation:!0,options:d,kind:"belongsTo"};return Ember.computed(function(e,f){var g=a(this,"data"),j,k,l,m=a(this,"store");return typeof b=="string"&&(b=c(this,b,!1)||c(window,b)),arguments.length===2?(e=d.key||a(this,"namingConvention").foreignKey(e),this.send("setAssociation",{key:e,value:f===null?null:a(f,"clientId")}),f):(h?e=d.key||a(this,"namingConvention").keyToJSONKey(e):e=d.key||a(this,"namingConvention").foreignKey(e),k=i(m,b,g,e,!0),l=k?m.find(b,k):null,l)}).property("data").cacheable().meta(j)};DS.belongsTo=function(a,b){return g(a,b)}}(),function(){var a=Ember.get,b=Ember.set,c=Ember.getPath,d=function(b,c,d,e){var f=a(d,e);return f?b.loadMany(c,f).ids:[]},e=function(b,c,d,e,f){return a(d,e)},f=function(f,g){g=g||{};var h=g.embedded,i=h?d:e,j={type:f,isAssociation:!0,options:g,kind:"hasMany"};return Ember.computed(function(d,e){var h=a(this,"data"),j=a(this,"store"),k,l,m;return typeof f=="string"&&(f=c(this,f,!1)||c(window,f)),d=g.key||a(this,"namingConvention").keyToJSONKey(d),k=i(j,f,h,d),m=j.findMany(f,k),b(m,"parentRecord",this),m}).property().cacheable().meta(j)};DS.hasMany=function(a,b){return f(a,b)}}(),function(){var a=Ember.get,b=Ember.getPath;DS.Model.reopenClass({typeForAssociation:function(b){var c=a(this,"associationsByName").get(b);return c&&c.type},associations:Ember.computed(function(){var a=Ember.Map.create();return this.eachComputedProperty(function(c,d){if(d.isAssociation){var e=d.type,f=a.get(e);typeof e=="string"&&(e=b(this,e,!1)||b(window,e),d.type=e),f||(f=[],a.set(e,f)),f.push({name:c,kind:d.kind})}}),a}).cacheable(),associationsByName:Ember.computed(function(){var a=Ember.Map.create(),c;return this.eachComputedProperty(function(d,e){e.isAssociation&&(e.key=d,c=e.type,typeof c=="string"&&(c=b(this,c,!1)||b(window,c),e.type=c),a.set(d,e))}),a}).cacheable()})}(),function(){}(),function(){DS.Adapter=Ember.Object.extend({find:null,generateIdForRecord:null,commit:function(a,b){b.updated.eachType(function(b,c){this.updateRecords(a,b,c.slice())},this),b.created.eachType(function(b,c){this.createRecords(a,b,c.slice())},this),b.deleted.eachType(function(b,c){this.deleteRecords(a,b,c.slice())},this)},createRecords:function(a,b,c){c.forEach(function(c){this.createRecord(a,b,c)},this)},updateRecords:function(a,b,c){c.forEach(function(c){this.updateRecord(a,b,c)},this)},deleteRecords:function(a,b,c){c.forEach(function(c){this.deleteRecord(a,b,c)},this)},findMany:function(a,b,c){c.forEach(function(c){this.find(a,b,c)},this)}})}(),function(){var a=Ember.set;Ember.onLoad("application",function(b){b.registerInjection(function(b,c,d){d==="Store"&&a(c,"store",b[d].create())})})}(),function(){DS.fixtureAdapter=DS.Adapter.create({find:function(a,b,c){var d=b.FIXTURES;if(d.hasLoaded)return;setTimeout(function(){a.loadMany(b,d),d.hasLoaded=!0},300)},findMany:function(){this.find.apply(this,arguments)},findAll:function(a,b){var c=b.FIXTURES,d=c.map(function(a,b,c){return a.id});a.loadMany(b,d,c)}})}(),function(){var a=Ember.get,b=Ember.set,c=Ember.getPath;DS.RESTAdapter=DS.Adapter.extend({bulkCommit:!1,createRecord:function(a,b,c){var d=this.rootForType(b),e={};e[d]=c.toJSON(),this.ajax(this.buildURL(d),"POST",{data:e,success:function(e){this.sideload(a,b,e,d),a.didCreateRecord(c,e[d])}})},createRecords:function(b,c,d){if(a(this,"bulkCommit")===!1)return this._super(b,c,d);var e=this.rootForType(c),f=this.pluralize(e),g={};g[f]=d.map(function(a){return a.toJSON()}),this.ajax(this.buildURL(e),"POST",{data:g,success:function(a){this.sideload(b,c,a,f),b.didCreateRecords(c,d,a[f])}})},updateRecord:function(b,c,d){var e=a(d,"id"),f=this.rootForType(c),g={};g[f]=d.toJSON(),this.ajax(this.buildURL(f,e),"PUT",{data:g,success:function(a){this.sideload(b,c,a,f),b.didUpdateRecord(d,a&&a[f])}})},updateRecords:function(b,c,d){if(a(this,"bulkCommit")===!1)return this._super(b,c,d);var e=this.rootForType(c),f=this.pluralize(e),g={};g[f]=d.map(function(a){return a.toJSON()}),this.ajax(this.buildURL(e,"bulk"),"PUT",{data:g,success:function(a){this.sideload(b,c,a,f),b.didUpdateRecords(d,a[f])}})},deleteRecord:function(b,c,d){var e=a(d,"id"),f=this.rootForType(c);this.ajax(this.buildURL(f,e),"DELETE",{success:function(a){a&&this.sideload(b,c,a),b.didDeleteRecord(d)}})},deleteRecords:function(b,c,d){if(a(this,"bulkCommit")===!1)return this._super(b,c,d);var e=this.rootForType(c),f=this.pluralize(e),g={};g[f]=d.map(function(b){return a(b,"id")}),this.ajax(this.buildURL(e,"bulk"),"DELETE",{data:g,success:function(a){a&&this.sideload(b,c,a),b.didDeleteRecords(d)}})},find:function(a,b,c){var d=this.rootForType(b);this.ajax(this.buildURL(d,c),"GET",{success:function(c){a.load(b,c[d]),this.sideload(a,b,c,d)}})},findMany:function(a,b,c){var d=this.rootForType(b),e=this.pluralize(d);this.ajax(this.buildURL(d),"GET",{data:{ids:c},success:function(c){a.loadMany(b,c[e]),this.sideload(a,b,c,e)}})},findAll:function(a,b){var c=this.rootForType(b),d=this.pluralize(c);this.ajax(this.buildURL(c),"GET",{success:function(c){a.loadMany(b,c[d]),this.sideload(a,b,c,d)}})},findQuery:function(a,b,c,d){var e=this.rootForType(b),f=this.pluralize(e);this.ajax(this.buildURL(e),"GET",{data:c,success:function(c){d.load(c[f]),this.sideload(a,b,c,f)}})},plurals:{},pluralize:function(a){return this.plurals[a]||a+"s"},rootForType:function(a){if(a.url)return a.url;var b=a.toString().split("."),c=b[b.length-1];return c.replace(/([A-Z])/g,"_$1").toLowerCase().slice(1)},ajax:function(a,b,c){c.url=a,c.type=b,c.dataType="json",c.contentType="application/json; charset=utf-8",c.context=this,c.data&&b!=="GET"&&(c.data=JSON.stringify(c.data)),jQuery.ajax(c)},sideload:function(b,c,d,e){var f,g;for(var h in d){if(!d.hasOwnProperty
         
     | 
| 
      
 10 
     | 
    
         
            +
            (h))continue;if(h===e)continue;f=c.typeForAssociation(h),f||(g=a(this,"mappings"),f=a(g,h)),this.loadValue(b,f,d[h])}},loadValue:function(a,b,c){c instanceof Array?a.loadMany(b,c):a.load(b,c)},buildURL:function(a,b){var c=[""];return this.namespace!==undefined&&c.push(this.namespace),c.push(this.pluralize(a)),b!==undefined&&c.push(b),c.join("/")}})}(),function(){}()
         
     |