Command to decide when bindings are simple

Author: rreusser

src/plots/command.js

@@ -15,27 +15,65 @@ var Lib = require('../lib');
 var attrPrefixRegex = /^(data|layout)(\[(-?[0-9]*)\])?\.(.*)$/;
 
 /*
- * This function checks to see if a set of bindings is compatible
- * with automatic two-way binding. The criteria right now are that
+ * This function checks to see if an array of objects containing
+ * method and args properties is compatible with automatic two-way
+ * binding. The criteria right now are that
  *
  *   1. multiple traces may be affected
  *   2. only one property may be affected
+ *   3. the same property must be affected by all commands
  */
-exports.bindingsAreConsistent = function(currentBindings, newBindings) {
-    // If they're not both arrays of equal length, return false:
-    if(!newBindings || !currentBindings || currentBindings.length !== newBindings.length) {
-        return false;
-    }
+exports.hasSimpleBindings = function(gd, commandList) {
+    var n = commandList.length;
 
-    var n = currentBindings.length;
+    var refBinding;
 
     for(var i = 0; i < n; i++) {
-        // This is not the most efficient check, but the pathological case where there
-        // are an excessive number of bindings should be rare, and at any rate we really
-        // try to bail out early at every opportunity.
-        if(currentBindings.indexOf(newBindings[i]) === -1) {
+        var command = commandList[i];
+        var method = command.method;
+        var args = command.args;
+
+        // If any command has no method, refuse to bind:
+        if(!method) {
+            return false;
+        }
+        var bindings = exports.computeAPICommandBindings(gd, method, args);
+
+        // Right now, handle one and *only* one property being set:
+        if(bindings.length !== 1) {
             return false;
         }
+
+        if(!refBinding) {
+            refBinding = bindings[0];
+            if(Array.isArray(refBinding.traces)) {
+                refBinding.traces.sort();
+            }
+        } else {
+            var binding = bindings[0];
+            if(binding.type !== refBinding.type) {
+                return false;
+            }
+            if(binding.prop !== refBinding.prop) {
+                return false;
+            }
+            if(Array.isArray(refBinding.traces)) {
+                if(Array.isArray(binding.traces)) {
+                    binding.traces.sort();
+                    for(var j = 0; j < refBinding.traces.length; j++) {
+                        if(refBinding.traces[j] !== binding.traces[j]) {
+                            return false;
+                        }
+                    }
+                } else {
+                    return false;
+                }
+            } else {
+                if(binding.prop !== refBinding.prop) {
+                    return false;
+                }
+            }
+        }
     }
 
     return true;

src/plots/plots.js

@@ -42,7 +42,7 @@ var commandModule = require('./command');
 plots.executeAPICommand = commandModule.executeAPICommand;
 plots.computeAPICommandBindings = commandModule.computeAPICommandBindings;
 plots.evaluateAPICommandBinding = commandModule.evaluateAPICommandBinding;
-plots.bindingsAreConsistent = commandModule.bindingsAreConsistent;
+plots.hasSimpleBindings = commandModule.hasSimpleBindings;
 
 /**
  * Find subplot ids in data.

test/jasmine/tests/command_test.js

@@ -75,6 +75,95 @@ describe('Plots.executeAPICommand', function() {
     });
 });
 
+describe('Plots.hasSimpleBindings', function() {
+    'use strict';
+    var gd;
+    beforeEach(function() {
+        gd = createGraphDiv();
+
+        Plotly.plot(gd, [
+            {x: [1, 2, 3], y: [1, 2, 3]},
+            {x: [1, 2, 3], y: [4, 5, 6]},
+        ]);
+    });
+
+    afterEach(function() {
+        destroyGraphDiv(gd);
+    });
+
+    it('return true when bindings are simple', function() {
+        var isSimple = Plots.hasSimpleBindings(gd, [{
+            method: 'restyle',
+            args: [{'marker.size': 10}]
+        }, {
+            method: 'restyle',
+            args: [{'marker.size': 20}]
+        }]);
+
+        expect(isSimple).toBe(true);
+    });
+
+    it('return false when properties are not the same', function() {
+        var isSimple = Plots.hasSimpleBindings(gd, [{
+            method: 'restyle',
+            args: [{'marker.size': 10}]
+        }, {
+            method: 'restyle',
+            args: [{'marker.color': 20}]
+        }]);
+
+        expect(isSimple).toBe(false);
+    });
+
+    it('return false when a command binds to more than one property', function() {
+        var isSimple = Plots.hasSimpleBindings(gd, [{
+            method: 'restyle',
+            args: [{'marker.color': 10, 'marker.size': 12}]
+        }, {
+            method: 'restyle',
+            args: [{'marker.color': 20}]
+        }]);
+
+        expect(isSimple).toBe(false);
+    });
+
+    it('return false when commands affect different traces', function() {
+        var isSimple = Plots.hasSimpleBindings(gd, [{
+            method: 'restyle',
+            args: [{'marker.color': 10}, [0]]
+        }, {
+            method: 'restyle',
+            args: [{'marker.color': 20}, [1]]
+        }]);
+
+        expect(isSimple).toBe(false);
+    });
+
+    it('return true when commands affect the same traces', function() {
+        var isSimple = Plots.hasSimpleBindings(gd, [{
+            method: 'restyle',
+            args: [{'marker.color': 10}, [1]]
+        }, {
+            method: 'restyle',
+            args: [{'marker.color': 20}, [1]]
+        }]);
+
+        expect(isSimple).toBe(true);
+    });
+
+    it('return true when commands affect the same traces in different order', function() {
+        var isSimple = Plots.hasSimpleBindings(gd, [{
+            method: 'restyle',
+            args: [{'marker.color': 10}, [1, 2]]
+        }, {
+            method: 'restyle',
+            args: [{'marker.color': 20}, [2, 1]]
+        }]);
+
+        expect(isSimple).toBe(true);
+    });
+});
+
 describe('Plots.computeAPICommandBindings', function() {
     'use strict';