remove needless change events when creating a recordArrays

addon/-private/system/record-array-manager.js

@@ -9,9 +9,11 @@ import {
   AdapterPopulatedRecordArray
 } from "./record-arrays";
 import { assert } from 'ember-data/-debug';
+import cloneNull from "./clone-null";
 
 const {
   get,
+  set,
   run: emberRun
 } = Ember;
 
@@ -25,7 +27,6 @@ const {
   createRecordArray,
   liveRecordArrayFor,
   filteredRecordArraysFor,
-  populateLiveRecordArray,
   recordDidChange,
   registerFilteredRecordArray,
   unregisterRecordArray,
@@ -41,7 +42,6 @@ const {
   'createRecordArray',
   'liveRecordArrayFor',
   'filteredRecordArraysFor',
-  'populateLiveRecordArray',
   'recordDidChange',
   'registerFilteredRecordArray',
   'unregisterRecordArray',
@@ -126,59 +126,22 @@ export default class RecordArrayManager {
         }
       }
 
-      // TODO: skip if it only changed
-      // process liveRecordArrays
-      if (this._liveRecordArrays[modelName]) {
-        this.updateLiveRecordArray(modelName, internalModels);
+      let array = this._liveRecordArrays[modelName];
+      if (array) {
+        // TODO: skip if it only changed
+        // process liveRecordArrays
+        this.updateLiveRecordArray(array, internalModels);
       }
 
       // process adapterPopulatedRecordArrays
       if (modelsToRemove.length > 0) {
-        this.removeFromAdapterPopulatedRecordArrays(modelsToRemove);
+        removeFromAdapterPopulatedRecordArrays(modelsToRemove);
       }
     }
   }
 
-  updateLiveRecordArray(modelName, internalModels) {
-    let array = this.liveRecordArrayFor(modelName);
-
-    let modelsToAdd = [];
-    let modelsToRemove = [];
-
-    for (let i = 0; i < internalModels.length; i++) {
-      let internalModel = internalModels[i];
-      let isDeleted = internalModel.isHiddenFromRecordArrays();
-      let recordArrays = internalModel._recordArrays;
-
-      if (!isDeleted && !internalModel.isEmpty()) {
-        if (!recordArrays.has(array)) {
-          modelsToAdd.push(internalModel);
-          recordArrays.add(array);
-        }
-      }
-
-      if (isDeleted) {
-        modelsToRemove.push(internalModel);
-        recordArrays.delete(array)
-      }
-    }
-
-    if (modelsToAdd.length > 0)    { array._pushInternalModels(modelsToAdd); }
-    if (modelsToRemove.length > 0) { array._removeInternalModels(modelsToRemove); }
-  }
-
-  removeFromAdapterPopulatedRecordArrays(internalModels) {
-    for (let i = 0; i < internalModels.length; i++) {
-      let internalModel = internalModels[i];
-      let list = internalModel._recordArrays.list;
-
-      for (let j = 0; j < list.length; j++) {
-        // TODO: group by arrays, so we can batch remove
-        list[j]._removeInternalModels([internalModel]);
-      }
-
-      internalModel._recordArrays.clear();
-    }
+  updateLiveRecordArray(array, internalModels) {
+    return updateLiveRecordArray(array, internalModels);
   }
 
   /**
@@ -217,7 +180,7 @@ export default class RecordArrayManager {
   }
 
   // TODO: remove, utilize existing flush code but make it flush sync based on 1 modelName
-  syncLiveRecordArray(array, modelName) {
+  _syncLiveRecordArray(array, modelName) {
     assert(`recordArrayManger.syncLiveRecordArray expects modelName not modelClass as the second param`, typeof modelName === 'string');
     let hasNoPotentialDeletions = Object.keys(this._pending).length === 0;
     let map = this.store._internalModelsFor(modelName);
@@ -228,29 +191,19 @@ export default class RecordArrayManager {
       liveRecordArrays, and is capable of strategically flushing those changes and applying
       small diffs if desired.  However, until we've refactored recordArrayManager, this dirty
       check prevents us from unnecessarily wiping out live record arrays returned by peekAll.
-     */
+      */
     if (hasNoPotentialDeletions && hasNoInsertionsOrRemovals) {
       return;
     }
 
-    this.populateLiveRecordArray(array, map.models);
-  }
-
-  // TODO: remove, when syncLiveRecordArray is removed
-  populateLiveRecordArray(array, internalModels) {
-    heimdall.increment(populateLiveRecordArray);
-
+    let internalModels = this._visibleInternalModelsByType(modelName);
     let modelsToAdd = [];
     for (let i = 0; i < internalModels.length; i++) {
       let internalModel = internalModels[i];
-
-      if (!internalModel.isHiddenFromRecordArrays()) {
-        let recordArrays = internalModel._recordArrays;
-
-        if (!recordArrays.has(array)) {
-          modelsToAdd.push(internalModel);
-          recordArrays.add(array);
-        }
+      let recordArrays = internalModel._recordArrays;
+      if (recordArrays.has(array) === false) {
+        recordArrays.add(array);
+        modelsToAdd.push(internalModel);
       }
     }
 
@@ -278,6 +231,13 @@ export default class RecordArrayManager {
     this.updateFilterRecordArray(array, filter, internalModels);
   }
 
+  _didUpdateAll(modelName) {
+    let recordArray = this._liveRecordArrays[modelName];
+    if (recordArray) {
+      set(recordArray, 'isUpdating', false);
+    }
+  }
+
   /**
     Get the `DS.RecordArray` for a modelName, which contains all loaded records of
     given modelName.
@@ -291,9 +251,33 @@ export default class RecordArrayManager {
 
     heimdall.increment(liveRecordArrayFor);
 
-    return this._liveRecordArrays[modelName] || (this._liveRecordArrays[modelName] = this.createRecordArray(modelName))
+    let array = this._liveRecordArrays[modelName];
+
+    if (array) {
+      // if the array already exists, synchronize
+      this._syncLiveRecordArray(array, modelName);
+    } else {
+      // if the array is being newly created merely create it with its initial
+      // content already set. This prevents unneeded change events.
+      let internalModels = this._visibleInternalModelsByType(modelName);
+      array = this.createRecordArray(modelName, internalModels);
+      this._liveRecordArrays[modelName] = array;
+    }
+
+    return array;
   }
 
+  _visibleInternalModelsByType(modelName) {
+    let all = this.store._internalModelsFor(modelName)._models;
+    let visible = [];
+    for (let i = 0; i < all.length; i++) {
+      let model = all[i];
+      if (model.isHiddenFromRecordArrays() === false) {
+        visible.push(model);
+      }
+    }
+    return visible;
+  }
   /**
     Get the `DS.RecordArray` for a modelName, which contains all loaded records of
     given modelName.
@@ -314,18 +298,26 @@ export default class RecordArrayManager {
 
     @method createRecordArray
     @param {String} modelName
+    @param {Array} _content (optional|private)
     @return {DS.RecordArray}
   */
-  createRecordArray(modelName) {
+  createRecordArray(modelName, content) {
     assert(`recordArrayManger.createRecordArray expects modelName not modelClass as the param`, typeof modelName === 'string');
     heimdall.increment(createRecordArray);
-    return RecordArray.create({
+
+    let array = RecordArray.create({
       modelName,
-      content: Ember.A(),
+      content: Ember.A(content || []),
       store: this.store,
       isLoaded: true,
       manager: this
     });
+
+    if (Array.isArray(content)) {
+      associateWithRecordArray(content, array);
+    }
+
+    return array;
   }
 
   /**
@@ -363,17 +355,34 @@ export default class RecordArrayManager {
     @param {Object} query
     @return {DS.AdapterPopulatedRecordArray}
   */
-  createAdapterPopulatedRecordArray(modelName, query) {
+  createAdapterPopulatedRecordArray(modelName, query, internalModels, payload) {
     heimdall.increment(createAdapterPopulatedRecordArray);
     assert(`recordArrayManger.createAdapterPopulatedRecordArray expects modelName not modelClass as the first param, received ${modelName}`, typeof modelName === 'string');
 
-    let array = AdapterPopulatedRecordArray.create({
-      modelName,
-      query: query,
-      content: Ember.A(),
-      store: this.store,
-      manager: this
-    });
+    let array;
+    if (Array.isArray(internalModels)) {
+      array = AdapterPopulatedRecordArray.create({
+        modelName,
+        query: query,
+        content: Ember.A(internalModels),
+        store: this.store,
+        manager: this,
+        isLoaded: true,
+        isUpdating: false,
+        meta: cloneNull(payload.meta),
+        links: cloneNull(payload.links)
+      });
+
+      associateWithRecordArray(internalModels, array);
+    } else {
+      array = AdapterPopulatedRecordArray.create({
+        modelName,
+        query: query,
+        content: Ember.A(),
+        store: this.store,
+        manager: this
+      });
+    }
 
     this._adapterPopulatedRecordArrays.push(array);
 
@@ -470,3 +479,50 @@ function remove(array, item) {
 
   return false;
 }
+
+function updateLiveRecordArray(array, internalModels) {
+  let modelsToAdd = [];
+  let modelsToRemove = [];
+
+  for (let i = 0; i < internalModels.length; i++) {
+    let internalModel = internalModels[i];
+    let isDeleted = internalModel.isHiddenFromRecordArrays();
+    let recordArrays = internalModel._recordArrays;
+
+    if (!isDeleted && !internalModel.isEmpty()) {
+      if (!recordArrays.has(array)) {
+        modelsToAdd.push(internalModel);
+        recordArrays.add(array);
+      }
+    }
+
+    if (isDeleted) {
+      modelsToRemove.push(internalModel);
+      recordArrays.delete(array)
+    }
+  }
+
+  if (modelsToAdd.length > 0)    { array._pushInternalModels(modelsToAdd); }
+  if (modelsToRemove.length > 0) { array._removeInternalModels(modelsToRemove); }
+}
+
+function removeFromAdapterPopulatedRecordArrays(internalModels) {
+  for (let i = 0; i < internalModels.length; i++) {
+    let internalModel = internalModels[i];
+    let list = internalModel._recordArrays.list;
+
+    for (let j = 0; j < list.length; j++) {
+      // TODO: group by arrays, so we can batch remove
+      list[j]._removeInternalModels([internalModel]);
+    }
+
+    internalModel._recordArrays.clear();
+  }
+}
+
+export function associateWithRecordArray(internalModels, array) {
+  for (let i = 0, l = internalModels.length; i < l; i++) {
+    let internalModel = internalModels[i];
+    internalModel._recordArrays.add(array);
+  }
+}

addon/-private/system/record-arrays/adapter-populated-record-array.js

@@ -1,6 +1,7 @@
 import Ember from 'ember';
 import RecordArray from "./record-array";
 import cloneNull from "../clone-null";
+import { associateWithRecordArray } from '../record-array-manager';
 
 /**
   @module ember-data
@@ -87,11 +88,7 @@ export default RecordArray.extend({
       links: cloneNull(payload.links)
     });
 
-    for (let i = 0, l = internalModels.length; i < l; i++) {
-      let internalModel = internalModels[i];
-
-      internalModel._recordArrays.add(this);
-    }
+    associateWithRecordArray(internalModels, this);
 
     // TODO: should triggering didLoad event be the last action of the runLoop?
     Ember.run.once(this, 'trigger', 'didLoad');

addon/-private/system/store.js

@@ -1270,8 +1270,6 @@ Store = Service.extend({
     let modelToken = heimdall.start('initial-modelFor-lookup');
     heimdall.stop(modelToken);
 
-    array = array || this.recordArrayManager.createAdapterPopulatedRecordArray(modelName, query);
-
     let adapterToken = heimdall.start('initial-adapterFor-lookup');
     let adapter = this.adapterFor(modelName);
     heimdall.stop(adapterToken);
@@ -1652,9 +1650,7 @@ Store = Service.extend({
   */
   _didUpdateAll(modelName) {
     heimdall.increment(_didUpdateAll);
-    let liveRecordArray = this.recordArrayManager.liveRecordArrayFor(modelName);
-
-    set(liveRecordArray, 'isUpdating', false);
+    this.recordArrayManager._didUpdateAll(modelName);
   },
 
   didUpdateAll(modelName) {
@@ -1691,11 +1687,7 @@ Store = Service.extend({
     assert(`You need to pass a model name to the store's peekAll method`, isPresent(modelName));
     assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
     let normalizedModelName = normalizeModelName(modelName);
-    let liveRecordArray = this.recordArrayManager.liveRecordArrayFor(normalizedModelName);
-
-    this.recordArrayManager.syncLiveRecordArray(liveRecordArray, normalizedModelName);
-
-    return liveRecordArray;
+    return this.recordArrayManager.liveRecordArrayFor(normalizedModelName);
   },
 
   /**

addon/-private/system/store/finders.js

@@ -137,7 +137,14 @@ export function _findAll(adapter, store, modelName, sinceToken, options) {
 
 export function _query(adapter, store, modelName, query, recordArray) {
   let modelClass = store.modelFor(modelName); // adapter.query needs the class
-  let promise = adapter.query(store, modelClass, query, recordArray);
+
+  let promise;
+  if (adapter.query.length > 3) {
+    recordArray = recordArray || store.recordArrayManager.createAdapterPopulatedRecordArray(modelName, query);
+    promise = adapter.query(store, modelClass, query, recordArray);
+  } else {
+    promise = adapter.query(store, modelClass, query);
+  }
 
   let label = `DS: Handle Adapter#query of ${modelClass}`;
 
@@ -154,7 +161,11 @@ export function _query(adapter, store, modelName, query, recordArray) {
     let internalModels = store._push(payload);
 
     assert('The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record.', Array.isArray(internalModels));
-    recordArray._setInternalModels(internalModels, payload);
+    if (recordArray) {
+      recordArray._setInternalModels(internalModels, payload);
+    } else {
+      recordArray = store.recordArrayManager.createAdapterPopulatedRecordArray(modelName, query, internalModels, payload);
+    }
 
     return recordArray;
   }, null, `DS: Extract payload of query ${modelName}`);