refactor parcoords - better variable names in parcoords plot

Author: archmoj

src/traces/parcoords/plot.js

@@ -19,8 +19,8 @@ module.exports = function plot(gd, cdModule) {
     var success = prepareRegl(gd);
     if(!success) return;
 
-    var gdDimensions = {};
-    var gdDimensionsOriginalOrder = {};
+    var currentDims = {};
+    var initialDims = {};
     var fullIndices = {};
     var inputIndices = {};
 
@@ -30,37 +30,37 @@ module.exports = function plot(gd, cdModule) {
         var trace = d[0].trace;
         fullIndices[i] = trace.index;
         var iIn = inputIndices[i] = trace._fullInput.index;
-        gdDimensions[i] = gd.data[iIn].dimensions;
-        gdDimensionsOriginalOrder[i] = gd.data[iIn].dimensions.slice();
+        currentDims[i] = gd.data[iIn].dimensions;
+        initialDims[i] = gd.data[iIn].dimensions.slice();
     });
 
-    var filterChanged = function(i, originalDimensionIndex, newRanges) {
+    var filterChanged = function(i, initialDimIndex, newRanges) {
         // Have updated `constraintrange` data on `gd.data` and raise `Plotly.restyle` event
         // without having to incur heavy UI blocking due to an actual `Plotly.restyle` call
 
-        var gdDimension = gdDimensionsOriginalOrder[i][originalDimensionIndex];
+        var dim = initialDims[i][initialDimIndex];
         var newConstraints = newRanges.map(function(r) { return r.slice(); });
 
         // Store constraint range in preGUI
         // This one doesn't work if it's stored in pieces in _storeDirectGUIEdit
         // because it's an array of variable dimensionality. So store the whole
         // thing at once manually.
-        var aStr = 'dimensions[' + originalDimensionIndex + '].constraintrange';
+        var aStr = 'dimensions[' + initialDimIndex + '].constraintrange';
         var preGUI = fullLayout._tracePreGUI[gd._fullData[fullIndices[i]]._fullInput.uid];
         if(preGUI[aStr] === undefined) {
-            var initialVal = gdDimension.constraintrange;
+            var initialVal = dim.constraintrange;
             preGUI[aStr] = initialVal || null;
         }
 
-        var fullDimension = gd._fullData[fullIndices[i]].dimensions[originalDimensionIndex];
+        var fullDimension = gd._fullData[fullIndices[i]].dimensions[initialDimIndex];
 
         if(!newConstraints.length) {
-            delete gdDimension.constraintrange;
+            delete dim.constraintrange;
             delete fullDimension.constraintrange;
             newConstraints = null;
         } else {
             if(newConstraints.length === 1) newConstraints = newConstraints[0];
-            gdDimension.constraintrange = newConstraints;
+            dim.constraintrange = newConstraints;
             fullDimension.constraintrange = newConstraints.slice();
             // wrap in another array for restyle event data
             newConstraints = [newConstraints];
@@ -85,7 +85,7 @@ module.exports = function plot(gd, cdModule) {
 
         function visible(dimension) {return !('visible' in dimension) || dimension.visible;}
 
-        function newIdx(visibleIndices, orig, dim) {
+        function newIndex(visibleIndices, orig, dim) {
             var origIndex = orig.indexOf(dim);
             var currentIndex = visibleIndices.indexOf(origIndex);
             if(currentIndex === -1) {
@@ -98,26 +98,26 @@ module.exports = function plot(gd, cdModule) {
         function sorter(orig) {
             return function sorter(d1, d2) {
                 return (
-                    newIdx(visibleIndices, orig, d1) -
-                    newIdx(visibleIndices, orig, d2)
+                    newIndex(visibleIndices, orig, d1) -
+                    newIndex(visibleIndices, orig, d2)
                 );
             };
         }
 
         // drag&drop sorting of the visible dimensions
-        var orig = sorter(gdDimensionsOriginalOrder[i].filter(visible));
-        gdDimensions[i].sort(orig);
+        var orig = sorter(initialDims[i].filter(visible));
+        currentDims[i].sort(orig);
 
         // invisible dimensions are not interpreted in the context of drag&drop sorting as an invisible dimension
         // cannot be dragged; they're interspersed into their original positions by this subsequent merging step
-        gdDimensionsOriginalOrder[i].filter(function(d) {return !visible(d);})
+        initialDims[i].filter(function(d) {return !visible(d);})
              .sort(function(d) {
                  // subsequent splicing to be done left to right, otherwise indices may be incorrect
-                 return gdDimensionsOriginalOrder[i].indexOf(d);
+                 return initialDims[i].indexOf(d);
              })
             .forEach(function(d) {
-                gdDimensions[i].splice(gdDimensions[i].indexOf(d), 1); // remove from the end
-                gdDimensions[i].splice(gdDimensionsOriginalOrder[i].indexOf(d), 0, d); // insert at original index
+                currentDims[i].splice(currentDims[i].indexOf(d), 1); // remove from the end
+                currentDims[i].splice(initialDims[i].indexOf(d), 0, d); // insert at original index
             });
 
         // TODO: we can't really store this part of the interaction state
@@ -127,10 +127,10 @@ module.exports = function plot(gd, cdModule) {
         // Registry.call('_storeDirectGUIEdit',
         //     gd.data[inputIndices[i]],
         //     fullLayout._tracePreGUI[gd._fullData[fullIndices[i]]._fullInput.uid],
-        //     {dimensions: gdDimensions[i]}
+        //     {dimensions: currentDims[i]}
         // );
 
-        gd.emit('plotly_restyle', [{dimensions: [gdDimensions[i]]}, [inputIndices[i]]]);
+        gd.emit('plotly_restyle', [{dimensions: [currentDims[i]]}, [inputIndices[i]]]);
     };
 
     parcoords(