Fix performance regression with cursors.

leebyron · leebyron · commit a602dcbd14d3 · 2015-01-12T18:00:50.000-05:00
Closes immutable-js#284
diff --git a/contrib/cursor/index.js b/contrib/cursor/index.js
@@ -28,8 +28,8 @@ function cursorFrom(rootData, keyPath, onChange) {
   } else if (typeof keyPath === 'function') {
     onChange = keyPath;
     keyPath = [];
-  } else if (!Array.isArray(keyPath)) {
-    keyPath = [keyPath];
+  } else {
+    keyPath = valToKeyPath(keyPath);
   }
   return makeCursor(rootData, keyPath, onChange);
 }
@@ -74,20 +74,18 @@ IndexedCursorPrototype.get = function(key, notSetValue) {
 }
 
 KeyedCursorPrototype.getIn =
-IndexedCursorPrototype.getIn = function(key, notSetValue) {
-  if (!Array.isArray(key)) {
-    key = Immutable.Iterable(key).toArray();
-  }
-  if (key.length === 0) {
+IndexedCursorPrototype.getIn = function(keyPath, notSetValue) {
+  keyPath = listToKeyPath(keyPath);
+  if (keyPath.length === 0) {
     return this;
   }
-  var value = this._rootData.getIn(newKeyPath(this._keyPath, key), NOT_SET);
-  return value === NOT_SET ? notSetValue : wrappedValue(this, key, value);
+  var value = this._rootData.getIn(newKeyPath(this._keyPath, keyPath), NOT_SET);
+  return value === NOT_SET ? notSetValue : wrappedValue(this, keyPath, value);
 }
 
 IndexedCursorPrototype.set =
 KeyedCursorPrototype.set = function(key, value) {
-  return updateCursor(this, function (m) { return m.set(key, value); }, key);
+  return updateCursor(this, function (m) { return m.set(key, value); }, [key]);
 }
 
 IndexedCursorPrototype.setIn =
@@ -97,7 +95,7 @@ KeyedCursorPrototype.remove =
 KeyedCursorPrototype['delete'] =
 IndexedCursorPrototype.remove =
 IndexedCursorPrototype['delete'] = function(key) {
-  return updateCursor(this, function (m) { return m.remove(key); }, key);
+  return updateCursor(this, function (m) { return m.remove(key); }, [key]);
 }
 
 IndexedCursorPrototype.removeIn =
@@ -170,9 +168,9 @@ IndexedCursorPrototype.withMutations = function(fn) {
 }
 
 KeyedCursorPrototype.cursor =
-IndexedCursorPrototype.cursor = function(subKey) {
-  return Array.isArray(subKey) && subKey.length === 0 ?
-    this : subCursor(this, subKey);
+IndexedCursorPrototype.cursor = function(subKeyPath) {
+  subKeyPath = valToKeyPath(subKeyPath);
+  return subKeyPath.length === 0 ? this : subCursor(this, subKeyPath);
 }
 
 /**
@@ -183,7 +181,7 @@ IndexedCursorPrototype.__iterate = function(fn, reverse) {
   var cursor = this;
   var deref = cursor.deref();
   return deref && deref.__iterate ? deref.__iterate(
-    function (v, k) { return fn(wrappedValue(cursor, k, v), k, cursor); },
+    function (v, k) { return fn(wrappedValue(cursor, [k], v), k, cursor); },
     reverse
   ) : 0;
 }
@@ -207,7 +205,7 @@ IndexedCursorPrototype.__iterator = function(type, reverse) {
     }
     var entry = step.value;
     var k = entry[0];
-    var v = wrappedValue(cursor, k, entry[1]);
+    var v = wrappedValue(cursor, [k], entry[1]);
     return {
       value: type === Iterator.KEYS ? k : type === Iterator.VALUES ? v : [k, v],
       done: false
@@ -230,31 +228,32 @@ function makeCursor(rootData, keyPath, onChange, value) {
   return new CursorClass(rootData, keyPath, onChange, size);
 }
 
-function wrappedValue(cursor, key, value) {
-  return Iterable.isIterable(value) ? subCursor(cursor, key, value) : value;
+function wrappedValue(cursor, keyPath, value) {
+  return Iterable.isIterable(value) ? subCursor(cursor, keyPath, value) : value;
 }
 
-function subCursor(cursor, key, value) {
+function subCursor(cursor, keyPath, value) {
   return makeCursor(
     cursor._rootData,
-    newKeyPath(cursor._keyPath, key),
+    newKeyPath(cursor._keyPath, keyPath),
     cursor._onChange,
     value
   );
 }
 
-function updateCursor(cursor, changeFn, changeKey) {
+function updateCursor(cursor, changeFn, changeKeyPath) {
+  var deepChange = arguments.length > 2;
   var newRootData = cursor._rootData.updateIn(
     cursor._keyPath,
-    changeKey ? Map() : undefined,
+    deepChange ? Map() : undefined,
     changeFn
   );
   var keyPath = cursor._keyPath || [];
   var result = cursor._onChange && cursor._onChange.call(
     undefined,
     newRootData,
     cursor._rootData,
-    arguments.length > 2 ? newKeyPath(keyPath, changeKey) : keyPath
+    deepChange ? newKeyPath(keyPath, changeKeyPath) : keyPath
   );
   if (result !== undefined) {
     newRootData = result;
@@ -263,7 +262,17 @@ function updateCursor(cursor, changeFn, changeKey) {
 }
 
 function newKeyPath(head, tail) {
-  return Seq(head).concat(tail).toArray();
+  return head.concat(listToKeyPath(tail));
+}
+
+function listToKeyPath(list) {
+  return Array.isArray(list) ? list : Immutable.Iterable(list).toArray();
+}
+
+function valToKeyPath(val) {
+  return Array.isArray(val) ? val :
+    Iterable.isIterable(val) ? val.toArray() :
+    [val];
 }
 
 exports.from = cursorFrom;
