forbid scale constraints along with fixedrange

Author: alexcjohnson

Diff for: src/plot_api/plot_api.js

@@ -2107,6 +2107,7 @@ function _relayout(gd, aobj) {
                     pp1 === 'rangemode' ||
                     pp1 === 'type' ||
                     pp1 === 'domain' ||
+                    pp1 === 'fixedrange' ||
                     ai.indexOf('calendar') !== -1 ||
                     ai.match(/^(bar|box|font)/)) {
                 flags.docalc = true;

Diff for: src/plots/cartesian/constraint_defaults.js

@@ -16,7 +16,7 @@ var id2name = require('./axis_ids').id2name;
 module.exports = function handleConstraintDefaults(containerIn, containerOut, coerce, counterAxes, layoutOut) {
     var constraintGroups = layoutOut._axisConstraintGroups;
 
-    if(!containerIn.scaleanchor) return;
+    if(containerOut.fixedrange || !containerIn.scaleanchor) return;
 
     var constraintOpts = getConstraintOpts(constraintGroups, containerOut._id, counterAxes, layoutOut);
 
@@ -41,8 +41,9 @@ module.exports = function handleConstraintDefaults(containerIn, containerOut, co
     }
     else if(counterAxes.indexOf(containerIn.scaleanchor) !== -1) {
         Lib.warn('ignored ' + containerOut._name + '.scaleanchor: "' +
-            containerIn.scaleanchor + '" to avoid an infinite loop ' +
-            'and possibly inconsistent scaleratios.');
+            containerIn.scaleanchor + '" to avoid either an infinite loop ' +
+            'and possibly inconsistent scaleratios, or because the target' +
+            'axis has fixed range.');
     }
 };
 
@@ -53,23 +54,29 @@ function getConstraintOpts(constraintGroups, thisID, counterAxes, layoutOut) {
 
     var thisType = layoutOut[id2name(thisID)].type;
 
-    var i, j, idj;
+    var i, j, idj, axj;
+
+    var linkableAxes = [];
+    for(j = 0; j < counterAxes.length; j++) {
+        idj = counterAxes[j];
+        axj = layoutOut[id2name(idj)];
+        if(axj.type === thisType && !axj.fixedrange) linkableAxes.push(idj);
+    }
+
     for(i = 0; i < constraintGroups.length; i++) {
         if(constraintGroups[i][thisID]) {
             var thisGroup = constraintGroups[i];
 
-            var linkableAxes = [];
-            for(j = 0; j < counterAxes.length; j++) {
-                idj = counterAxes[j];
-                if(!thisGroup[idj] && layoutOut[id2name(idj)].type === thisType) {
-                    linkableAxes.push(idj);
-                }
+            var linkableAxesNoLoops = [];
+            for(j = 0; j < linkableAxes.length; j++) {
+                idj = linkableAxes[j];
+                if(!thisGroup[idj]) linkableAxesNoLoops.push(idj);
             }
-            return {linkableAxes: linkableAxes, thisGroup: thisGroup};
+            return {linkableAxes: linkableAxesNoLoops, thisGroup: thisGroup};
         }
     }
 
-    return {linkableAxes: counterAxes, thisGroup: null};
+    return {linkableAxes: linkableAxes, thisGroup: null};
 }
 
 

Diff for: src/plots/cartesian/layout_defaults.js

@@ -117,7 +117,7 @@ module.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
 
     var bgColor = Color.combine(plot_bgcolor, layoutOut.paper_bgcolor);
 
-    var axName, axLayoutIn, axLayoutOut;
+    var axName, axLetter, axLayoutIn, axLayoutOut;
 
     function coerce(attr, dflt) {
         return Lib.coerce(axLayoutIn, axLayoutOut, layoutAttributes, attr, dflt);
@@ -128,6 +128,8 @@ module.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
         return Lib.simpleMap(list, axisIds.name2id);
     }
 
+    var counterAxes = {x: getCounterAxes('x'), y: getCounterAxes('y')};
+
     function getOverlayableAxes(axLetter, axName) {
         var list = {x: xaList, y: yaList}[axLetter];
         var out = [];
@@ -143,12 +145,7 @@ module.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
         return out;
     }
 
-    // sets of axes linked by `scaleanchor` along with the scaleratios compounded
-    // together, populated in handleConstraintDefaults
-    layoutOut._axisConstraintGroups = [];
-
-    // first pass creates the containers and determines types, because
-    // we need to have all types predetermined before setting constraints
+    // first pass creates the containers, determines types, and handles most of the settings
     for(i = 0; i < axesList.length; i++) {
         axName = axesList[i];
 
@@ -160,17 +157,8 @@ module.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
         axLayoutOut = layoutOut[axName] = {};
 
         handleTypeDefaults(axLayoutIn, axLayoutOut, coerce, fullData, axName);
-    }
 
-    // second pass handles most of the settings
-    for(i = 0; i < axesList.length; i++) {
-        axName = axesList[i];
-
-        axLayoutIn = layoutIn[axName];
-        axLayoutOut = layoutOut[axName];
-
-        var axLetter = axName.charAt(0);
-        var counterAxes = getCounterAxes(axLetter);
+        axLetter = axName.charAt(0);
         var overlayableAxes = getOverlayableAxes(axLetter, axName);
 
         var defaultOptions = {
@@ -185,11 +173,9 @@ module.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
 
         handleAxisDefaults(axLayoutIn, axLayoutOut, coerce, defaultOptions, layoutOut);
 
-        handleConstraintDefaults(axLayoutIn, axLayoutOut, coerce, counterAxes, layoutOut);
-
         var positioningOptions = {
             letter: axLetter,
-            counterAxes: counterAxes,
+            counterAxes: counterAxes[axLetter],
             overlayableAxes: overlayableAxes
         };
 
@@ -198,7 +184,7 @@ module.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
         axLayoutOut._input = axLayoutIn;
     }
 
-    // quick third pass for range slider and selector defaults
+    // quick second pass for range slider and selector defaults
     var rangeSliderDefaults = Registry.getComponentMethod('rangeslider', 'handleDefaults'),
         rangeSelectorDefaults = Registry.getComponentMethod('rangeselector', 'handleDefaults');
 
@@ -237,4 +223,22 @@ module.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
 
         coerce('fixedrange', fixedRangeDflt);
     }
+
+    // Finally, handle scale constraints. We need to do this after all axes have
+    // coerced both `type` (so we link only axes of the same type) and
+    // `fixedrange` (so we can avoid linking from OR TO a fixed axis).
+
+    // sets of axes linked by `scaleanchor` along with the scaleratios compounded
+    // together, populated in handleConstraintDefaults
+    layoutOut._axisConstraintGroups = [];
+
+    for(i = 0; i < axesList.length; i++) {
+        axName = axesList[i];
+        axLetter = axName.charAt(0);
+
+        axLayoutIn = layoutIn[axName];
+        axLayoutOut = layoutOut[axName];
+
+        handleConstraintDefaults(axLayoutIn, axLayoutOut, coerce, counterAxes[axLetter], layoutOut);
+    }
 };

Diff for: test/jasmine/tests/axes_test.js

@@ -449,14 +449,14 @@ describe('Test axes', function() {
             layoutIn = {
                 // first group: linked in series, scales compound
                 xaxis: {},
-                yaxis: {scalewith: 'x', scaleratio: 2},
-                xaxis2: {scalewith: 'y', scaleratio: 3},
-                yaxis2: {scalewith: 'x2', scaleratio: 5},
+                yaxis: {scaleanchor: 'x', scaleratio: 2},
+                xaxis2: {scaleanchor: 'y', scaleratio: 3},
+                yaxis2: {scaleanchor: 'x2', scaleratio: 5},
                 // second group: linked in parallel, scales don't compound
                 yaxis3: {},
-                xaxis3: {scalewith: 'y3'},  // default scaleratio: 1
-                xaxis4: {scalewith: 'y3', scaleratio: 7},
-                xaxis5: {scalewith: 'y3', scaleratio: 9}
+                xaxis3: {scaleanchor: 'y3'},  // default scaleratio: 1
+                xaxis4: {scaleanchor: 'y3', scaleratio: 7},
+                xaxis5: {scaleanchor: 'y3', scaleratio: 9}
             };
 
             supplyLayoutDefaults(layoutIn, layoutOut, fullData);
@@ -467,20 +467,20 @@ describe('Test axes', function() {
             ]);
         });
 
-        it('breaks scalewith loops and drops conflicting ratios', function() {
+        it('breaks scaleanchor loops and drops conflicting ratios', function() {
             var warnings = [];
             spyOn(Lib, 'warn').and.callFake(function(msg) {
                 warnings.push(msg);
             });
 
             layoutIn = {
-                xaxis: {scalewith: 'y', scaleratio: 2},
-                yaxis: {scalewith: 'x', scaleratio: 3},
+                xaxis: {scaleanchor: 'y', scaleratio: 2},
+                yaxis: {scaleanchor: 'x', scaleratio: 3},
 
-                xaxis2: {scalewith: 'y2', scaleratio: 5},
-                yaxis2: {scalewith: 'x3', scaleratio: 7},
-                xaxis3: {scalewith: 'y3', scaleratio: 9},
-                yaxis3: {scalewith: 'x2', scaleratio: 11}
+                xaxis2: {scaleanchor: 'y2', scaleratio: 5},
+                yaxis2: {scaleanchor: 'x3', scaleratio: 7},
+                xaxis3: {scaleanchor: 'y3', scaleratio: 9},
+                yaxis3: {scaleanchor: 'x2', scaleratio: 11}
             };
 
             supplyLayoutDefaults(layoutIn, layoutOut, fullData);
@@ -490,24 +490,26 @@ describe('Test axes', function() {
                 {x2: 5 * 7 * 9, y2: 7 * 9, y3: 1, x3: 9}
             ]);
 
+            var warnTxt = ' to avoid either an infinite loop and possibly ' +
+                'inconsistent scaleratios, or because the targetaxis has ' +
+                'fixed range.';
+
             expect(warnings).toEqual([
-                'ignored yaxis.scalewith: "x" to avoid an infinite loop ' +
-                    'and possibly inconsistent scaleratios.',
-                'ignored yaxis3.scalewith: "x2" to avoid an infinite loop ' +
-                    'and possibly inconsistent scaleratios.'
+                'ignored yaxis.scaleanchor: "x"' + warnTxt,
+                'ignored yaxis3.scaleanchor: "x2"' + warnTxt
             ]);
         });
 
-        it('silently drops invalid scalewith values', function() {
+        it('silently drops invalid scaleanchor values', function() {
             var warnings = [];
             spyOn(Lib, 'warn').and.callFake(function(msg) {
                 warnings.push(msg);
             });
 
             layoutIn = {
-                xaxis: {scalewith: 'x2', scaleratio: 2}, // must be opposite letter
-                yaxis: {scalewith: 'x4', scaleratio: 3}, // doesn't exist
-                xaxis2: {scalewith: 'yaxis', scaleratio: 5} // must be an id, not a name
+                xaxis: {scaleanchor: 'x2', scaleratio: 2}, // must be opposite letter
+                yaxis: {scaleanchor: 'x4', scaleratio: 3}, // doesn't exist
+                xaxis2: {scaleanchor: 'yaxis', scaleratio: 5} // must be an id, not a name
             };
 
             supplyLayoutDefaults(layoutIn, layoutOut, fullData);
@@ -516,7 +518,50 @@ describe('Test axes', function() {
             expect(warnings).toEqual([]);
 
             ['xaxis', 'yaxis', 'xaxis2'].forEach(function(axName) {
-                expect(layoutOut[axName].scalewith).toBeUndefined();
+                expect(layoutOut[axName].scaleanchor).toBeUndefined(axName);
+                expect(layoutOut[axName].scaleratio).toBeUndefined(axName);
+            });
+        });
+
+        it('will not link axes of different types', function() {
+            layoutIn = {
+                xaxis: {type: 'linear'},
+                yaxis: {type: 'log', scaleanchor: 'x', scaleratio: 2},
+                xaxis2: {type: 'date', scaleanchor: 'y', scaleratio: 3},
+                yaxis2: {type: 'category', scaleanchor: 'x2', scaleratio: 5}
+            };
+
+            supplyLayoutDefaults(layoutIn, layoutOut, fullData);
+
+            expect(layoutOut._axisConstraintGroups).toEqual([]);
+
+            ['xaxis', 'yaxis', 'xaxis2', 'yaxis2'].forEach(function(axName) {
+                expect(layoutOut[axName].scaleanchor).toBeUndefined(axName);
+                expect(layoutOut[axName].scaleratio).toBeUndefined(axName);
+            });
+        });
+
+        it('drops scaleanchor settings if either the axis or target has fixedrange', function() {
+            // some of these will create warnings... not too important, so not going to test,
+            // just want to keep the output clean
+            // spyOn(Lib, 'warn');
+
+            layoutIn = {
+                xaxis: {fixedrange: true, scaleanchor: 'y', scaleratio: 2},
+                yaxis: {scaleanchor: 'x2', scaleratio: 3}, // only this one should survive
+                xaxis2: {},
+                yaxis2: {scaleanchor: 'x', scaleratio: 5}
+            };
+
+            supplyLayoutDefaults(layoutIn, layoutOut, fullData);
+
+            expect(layoutOut._axisConstraintGroups).toEqual([{x2: 1, y: 3}]);
+
+            expect(layoutOut.yaxis.scaleanchor).toBe('x2');
+            expect(layoutOut.yaxis.scaleratio).toBe(3);
+
+            ['xaxis', 'yaxis2', 'xaxis2'].forEach(function(axName) {
+                expect(layoutOut[axName].scaleanchor).toBeUndefined();
                 expect(layoutOut[axName].scaleratio).toBeUndefined();
             });
         });