plots: make relinkPrivateKeys less strict

- remove error when array container are not of the same length
- this is a temporary fix until
  #749
  is addressed.

Author: etpinard

src/plots/plots.js

@@ -585,45 +585,46 @@ plots.cleanPlot = function(newFullData, newFullLayout, oldFullData, oldFullLayou
 };
 
 /**
- * Relink private _keys and keys with a function value from one layout
- * (usually cached) to the new fullLayout.
- * relink means copying if object is pass-by-value and adding a reference
- * if object is pass-by-ref. This prevents deepCopying massive structures like
- * a webgl context.
+ * Relink private _keys and keys with a function value from one container
+ * to the new container.
+ * Relink means copying if object is pass-by-value and adding a reference
+ * if object is pass-by-ref.
+ * This prevents deepCopying massive structures like a webgl context.
  */
-function relinkPrivateKeys(toLayout, fromLayout) {
-    var keys = Object.keys(fromLayout);
-    var j;
+function relinkPrivateKeys(toContainer, fromContainer) {
+    var isPlainObject = Lib.isPlainObject,
+        isArray = Array.isArray;
+
+    var keys = Object.keys(fromContainer);
+
+    for(var i = 0; i < keys.length; i++) {
+        var k = keys[i],
+            fromVal = fromContainer[k],
+            toVal = toContainer[k];
+
+        if(k.charAt(0) === '_' || typeof fromVal === 'function') {
 
-    for(var i = 0; i < keys.length; ++i) {
-        var k = keys[i];
-        if(k.charAt(0) === '_' || typeof fromLayout[k] === 'function') {
             // if it already exists at this point, it's something
             // that we recreate each time around, so ignore it
-            if(k in toLayout) continue;
+            if(k in toContainer) continue;
 
-            toLayout[k] = fromLayout[k];
+            toContainer[k] = fromVal;
         }
-        else if(Array.isArray(fromLayout[k]) &&
-                 Array.isArray(toLayout[k]) &&
-                 fromLayout[k].length &&
-                 Lib.isPlainObject(fromLayout[k][0])) {
-            if(fromLayout[k].length !== toLayout[k].length) {
-                // this should be handled elsewhere, it causes
-                // ambiguity if we try to deal with it here.
-                throw new Error('relinkPrivateKeys needs equal ' +
-                                'length arrays');
-            }
+        else if(isArray(fromVal) && isArray(toVal)) {
 
-            for(j = 0; j < fromLayout[k].length; j++) {
-                relinkPrivateKeys(toLayout[k][j], fromLayout[k][j]);
+            // recurse into arrays
+            for(var j = 0; j < fromVal.length; j++) {
+                if(isPlainObject(fromVal[j]) && isPlainObject(toVal[j])) {
+                    relinkPrivateKeys(toVal[j], fromVal[j]);
+                }
             }
         }
-        else if(Lib.isPlainObject(fromLayout[k]) &&
-                 Lib.isPlainObject(toLayout[k])) {
+        else if(isPlainObject(fromVal) && isPlainObject(toVal)) {
+
             // recurse into objects, but only if they still exist
-            relinkPrivateKeys(toLayout[k], fromLayout[k]);
-            if(!Object.keys(toLayout[k]).length) delete toLayout[k];
+            relinkPrivateKeys(toVal, fromVal);
+
+            if(!Object.keys(toVal).length) delete toContainer[k];
         }
     }
 }

test/jasmine/tests/plots_test.js

@@ -7,6 +7,63 @@ var destroyGraphDiv = require('../assets/destroy_graph_div');
 describe('Test Plots', function() {
     'use strict';
 
+    describe('Plots.supplyDefaults', function() {
+
+        var gd;
+
+        it('should relink private keys', function() {
+            var oldFullData = [{
+                type: 'scatter3d',
+                z: [1, 2, 3]
+            }, {
+                type: 'contour',
+                _empties: [1, 2, 3]
+            }];
+
+            var oldFullLayout = {
+                _plots: { xy: {} },
+                xaxis: { c2p: function() {} },
+                yaxis: { _m: 20 },
+                scene: { _scene: {} },
+                annotations: [{ _min: 10, }, { _max: 20 }],
+                someFunc: function() {}
+            };
+
+            var newData = [{
+                type: 'scatter3d',
+                z: [1, 2, 3, 4]
+            }, {
+                type: 'contour',
+                z: [[1, 2, 3], [2, 3, 4]]
+            }];
+
+            var newLayout = {
+                annotations: [{}, {}, {}]
+            };
+
+            gd = {
+                _fullData: oldFullData,
+                _fullLayout: oldFullLayout,
+                data: newData,
+                layout: newLayout
+            };
+
+            Plots.supplyDefaults(gd);
+
+            expect(gd._fullData[1]._empties).toBe(oldFullData[1]._empties);
+            expect(gd._fullLayout.scene._scene).toBe(oldFullLayout.scene._scene);
+            expect(gd._fullLayout._plots).toBe(oldFullLayout._plots);
+            expect(gd._fullLayout.annotations[0]._min).toBe(oldFullLayout.annotations[0]._min);
+            expect(gd._fullLayout.annotations[1]._max).toBe(oldFullLayout.annotations[1]._max);
+            expect(gd._fullLayout.someFunc).toBe(oldFullLayout.someFunc);
+
+            expect(gd._fullLayout.xaxis.c2p)
+                .not.toBe(oldFullLayout.xaxis.c2p, '(set during ax.setScale');
+            expect(gd._fullLayout.yaxis._m)
+                .not.toBe(oldFullLayout.yaxis._m, '(set during ax.setScale');
+        });
+    });
+
     describe('Plots.supplyLayoutGlobalDefaults should', function() {
         var layoutIn,
             layoutOut,