record real initial axis (auto)range so we can update to autorange

Author: alexcjohnson

src/plot_api/plot_api.js

@@ -1445,7 +1445,8 @@ function storeCurrent(attr, val, newVal, preGUI) {
  * of the calling routine.
  *
  * @param {object} container: the input attributes container (eg `layout` or a `trace`)
- * @param {object} fullContainer: the full partner to `container`
+ * @param {object} preGUI: where original values should be stored, either
+ *     `layout._preGUI` or `layout._tracePreGUI[uid]`
  * @param {object} edits: the {attr: val} object as normally passed to `relayout` etc
  */
 exports._storeDirectGUIEdit = function(container, preGUI, edits) {
@@ -2367,7 +2368,7 @@ exports._guiUpdate = guiEdit(update);
 // Ordered by most common edits first, to minimize our search time
 var layoutUIControlPatterns = [
     {pattern: /^hiddenlabels/, attr: 'legend.uirevision'},
-    {pattern: /^((x|y)axis\d*)\.((auto)?range|title)/, autofill: true},
+    {pattern: /^((x|y)axis\d*)\.((auto)?range|title)/},
 
     // showspikes and modes include those nested inside scenes
     {pattern: /axis\d*\.showspikes$/, attr: 'modebar.uirevision'},
@@ -2376,8 +2377,7 @@ var layoutUIControlPatterns = [
     {pattern: /^(scene\d*)\.camera/},
     {pattern: /^(geo\d*)\.(projection|center)/},
     {pattern: /^(ternary\d*\.[abc]axis)\.(min|title)$/},
-    {pattern: /^(polar\d*\.radialaxis)\.(auto)?range/, autofill: true},
-    {pattern: /^(polar\d*\.radialaxis)\.(angle|title)/},
+    {pattern: /^(polar\d*\.radialaxis)\.((auto)?range|angle|title)/},
     {pattern: /^(polar\d*\.angularaxis)\.rotation/},
     {pattern: /^(mapbox\d*)\.(center|zoom|bearing|pitch)/},
 
@@ -2411,7 +2411,7 @@ function findUIPattern(key, patternSpecs) {
         var spec = patternSpecs[i];
         var match = key.match(spec.pattern);
         if(match) {
-            return {head: match[1], attr: spec.attr, autofill: spec.autofill};
+            return {head: match[1], attr: spec.attr};
         }
     }
 }
@@ -2464,6 +2464,8 @@ function valsMatch(v1, v2) {
 function applyUIRevisions(data, layout, oldFullData, oldFullLayout) {
     var layoutPreGUI = oldFullLayout._preGUI;
     var key, revAttr, oldRev, newRev, match, preGUIVal, newNP, newVal;
+    var bothInheritAutorange = [];
+    var newRangeAccepted = {};
     for(key in layoutPreGUI) {
         match = findUIPattern(key, layoutUIControlPatterns);
         if(match) {
@@ -2485,8 +2487,11 @@ function applyUIRevisions(data, layout, oldFullData, oldFullLayout) {
                 // storing *that* in preGUI... oh well, for now at least I limit
                 // this to attributes that get autofilled, which AFAICT among
                 // the GUI-editable attributes is just axis.range/autorange.
-                if(valsMatch(newVal, preGUIVal) || (match.autofill && newVal === undefined)) {
-                    newNP.set(nestedProperty(oldFullLayout, key).get());
+                if(valsMatch(newVal, preGUIVal)) {
+                    if(newVal === undefined && key.substr(key.length - 9) === 'autorange') {
+                        bothInheritAutorange.push(key.substr(0, key.length - 10));
+                    }
+                    newNP.set(undefinedToNull(nestedProperty(oldFullLayout, key).get()));
                     continue;
                 }
             }
@@ -2498,12 +2503,26 @@ function applyUIRevisions(data, layout, oldFullData, oldFullLayout) {
         // point (either because it changed or revision changed)
         // so remove it from _preGUI for next time.
         delete layoutPreGUI[key];
+
+        if(key.substr(key.length - 8, 6) === 'range[') {
+            newRangeAccepted[key.substr(0, key.length - 9)] = 1;
+        }
+    }
+
+    // Special logic for `autorange`, since it interacts with `range`:
+    // If the new figure's matching `range` was kept, and `autorange`
+    // wasn't supplied explicitly in either the original or the new figure,
+    // we shouldn't alter that - but we may just have done that, so fix it.
+    for(var i = 0; i < bothInheritAutorange.length; i++) {
+        var axAttr = bothInheritAutorange[i];
+        if(newRangeAccepted[axAttr]) {
+            var newAx = nestedProperty(layout, axAttr).get();
+            if(newAx) delete newAx.autorange;
+        }
     }
 
     // Now traces - try to match them up by uid (in case we added/deleted in
     // the middle), then fall back on index.
-    // var tracei = -1;
-    // for(var fulli = 0; fulli < oldFullData.length; fulli++) {
     var allTracePreGUI = oldFullLayout._tracePreGUI;
     for(var uid in allTracePreGUI) {
         var tracePreGUI = allTracePreGUI[uid];
@@ -2550,8 +2569,8 @@ function applyUIRevisions(data, layout, oldFullData, oldFullLayout) {
                     if(preGUIVal === null) preGUIVal = undefined;
                     newNP = nestedProperty(newTrace, key);
                     newVal = newNP.get();
-                    if(valsMatch(newVal, preGUIVal) || (match.autofill && newVal === undefined)) {
-                        newNP.set(nestedProperty(fullInput, key).get());
+                    if(valsMatch(newVal, preGUIVal)) {
+                        newNP.set(undefinedToNull(nestedProperty(fullInput, key).get()));
                         continue;
                     }
                 }

src/plots/cartesian/autorange.js

@@ -12,6 +12,7 @@ var isNumeric = require('fast-isnumeric');
 
 var Lib = require('../../lib');
 var FP_SAFE = require('../../constants/numerical').FP_SAFE;
+var Registry = require('../../registry');
 
 module.exports = {
     getAutoRange: getAutoRange,
@@ -250,6 +251,13 @@ function doAutoRange(gd, ax) {
         // but we want to report its results back to layout
 
         axIn = ax._input;
+
+        // before we edit _input, store preGUI values
+        var edits = {};
+        edits[ax._attr + '.range'] = ax.range;
+        edits[ax._attr + '.autorange'] = ax.autorange;
+        Registry.call('_storeDirectGUIEdit', gd.layout, gd._fullLayout._preGUI, edits);
+
         axIn.range = ax.range.slice();
         axIn.autorange = ax.autorange;
     }

src/plots/cartesian/layout_defaults.js

@@ -158,7 +158,7 @@ module.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
         axLayoutOut._shapeIndices = [];
 
         // set up some private properties
-        axLayoutOut._name = axName;
+        axLayoutOut._name = axLayoutOut._attr = axName;
         var id = axLayoutOut._id = name2id(axName);
 
         var overlayableAxes = getOverlayableAxes(axLetter, axName);

src/plots/polar/layout_defaults.js

@@ -53,6 +53,7 @@ function handleDefaults(contIn, contOut, coerce, opts) {
         var axIn = contIn[axName];
         var axOut = Template.newContainer(contOut, axName);
         axOut._id = axOut._name = axName;
+        axOut._attr = opts.id + '.' + axName;
         axOut._traceIndices = subplotData.map(function(t) { return t._expandedIndex; });
 
         var dataAttr = constants.axisName2dataArray[axName];

test/jasmine/tests/plot_api_react_test.js

@@ -1087,6 +1087,77 @@ describe('Plotly.react and uirevision attributes', function() {
         .then(done);
     });
 
+    it('respects reverting an explicit cartesian axis range to auto', function(done) {
+        function fig(xRange, yRange) {
+            return {
+                data: [{z: [[1, 2], [3, 4]], type: 'heatmap', x: [0, 1, 2], y: [3, 4, 5]}],
+                layout: {
+                    xaxis: {range: xRange},
+                    yaxis: {range: yRange},
+                    uirevision: 'a'
+                }
+            };
+        }
+
+        function setRanges(xRange, yRange) {
+            return function() {
+                return Registry.call('_guiRelayout', gd, {
+                    'xaxis.range': xRange,
+                    'yaxis.range': yRange
+                });
+            };
+        }
+
+        function checkRanges(xRange, yRange) {
+            return checkState([], {
+                'xaxis.range': [xRange],
+                'yaxis.range': [yRange]
+            });
+        }
+
+        Plotly.newPlot(gd, fig([1, 3], [4, 6]))
+        .then(checkRanges([1, 3], [4, 6]))
+        .then(setRanges([2, 4], [5, 7]))
+        .then(checkRanges([2, 4], [5, 7]))
+        .then(_react(fig(undefined, undefined)))
+        .then(checkRanges([0, 2], [3, 5]))
+        .catch(failTest)
+        .then(done);
+    });
+
+    it('respects reverting an explicit polar axis range to auto', function(done) {
+        function fig(range) {
+            return {
+                data: [{type: 'barpolar', r: [1, 1], theta: [0, 90]}],
+                layout: {
+                    polar: {radialaxis: {range: range}},
+                    uirevision: 'a'
+                }
+            };
+        }
+
+        function setRange(range) {
+            return function() {
+                return Registry.call('_guiRelayout', gd, {
+                    'polar.radialaxis.range': range
+                });
+            };
+        }
+
+        function checkRange(range) {
+            return checkState([], {'polar.radialaxis.range': [range]});
+        }
+
+        Plotly.newPlot(gd, fig([1, 3]))
+        .then(checkRange([1, 3]))
+        .then(setRange([2, 4]))
+        .then(checkRange([2, 4]))
+        .then(_react(fig(undefined)))
+        .then(checkRange([0, 1.05263]))
+        .catch(failTest)
+        .then(done);
+    });
+
     function _run(figFn, editFn, checkInitial, checkEdited) {
         // figFn should take 2 args (main uirevision and partial uirevision)
         // and return a figure {data, layout}