Add ability to rename grouped traces

rreusser · rreusser · commit aef38e556db4 · 2017-07-27T15:17:35.000-07:00
diff --git a/src/components/legend/draw.js b/src/components/legend/draw.js
@@ -31,6 +31,7 @@ var anchorUtils = require('./anchor_utils');
 
 var SHOWISOLATETIP = true;
 var DBLCLICKDELAY = interactConstants.DBLCLICKDELAY;
+var BLANK_STRING_REGEX = /^[\s\r]*$/;
 
 module.exports = function draw(gd) {
     var fullLayout = gd._fullLayout;
@@ -392,24 +393,57 @@ function drawTexts(g, gd) {
                 this.text(text)
                     .call(textLayout);
 
+                var origText = text;
+
                 if(!this.text()) text = ' \u0020\u0020 ';
 
-                var fullInput = legendItem.trace._fullInput || {},
-                    astr;
+                var i, transforms, direction;
+                var fullInput = legendItem.trace._fullInput || {};
+                var needsRedraw = false;
+                var update = {};
 
                 // N.B. this block isn't super clean,
                 // is unfortunately untested at the moment,
                 // and only works for for 'ohlc' and 'candlestick',
                 // but should be generalized for other one-to-many transforms
                 if(['ohlc', 'candlestick'].indexOf(fullInput.type) !== -1) {
-                    var transforms = legendItem.trace.transforms,
-                        direction = transforms[transforms.length - 1].direction;
+                    transforms = legendItem.trace.transforms;
+                    direction = transforms[transforms.length - 1].direction;
+
+                    update[direction + '.name'] = [text];
+                } else {
+                    if(fullInput.transforms) {
+                        for(i = fullInput.transforms.length - 1; i >= 0; i--) {
+                            if(fullInput.transforms[i].type === 'groupby') {
+                                break;
+                            }
+                        }
+
+                        var carr = Lib.keyedContainer(fullInput, 'transforms[' + i + '].groupnames');
+
+                        if(BLANK_STRING_REGEX.test(origText)) {
+                            carr.remove(legendItem.trace._group);
+                            needsRedraw = true;
+                        } else {
+                            carr.set(legendItem.trace._group, [text]);
+                        }
+
+                        update = carr.constructUpdate();
+                    }
+                }
+
+                var p = Plotly.restyle(gd, update, traceIndex);
 
-                    astr = direction + '.name';
+                // If a groupby label is deleted, it seems like we need another redraw in order
+                // to restore the label. Otherwise it simply sets this property and the blank
+                // string is retained.
+                if(needsRedraw) {
+                    p = p.then(function() {
+                        return Plotly.redraw(gd);
+                    });
                 }
-                else astr = 'name';
 
-                Plotly.restyle(gd, astr, text, traceIndex);
+                return p;
             });
     }
     else text.call(textLayout);
diff --git a/src/lib/index.js b/src/lib/index.js
@@ -19,6 +19,7 @@ var BADNUM = numConstants.BADNUM;
 var lib = module.exports = {};
 
 lib.nestedProperty = require('./nested_property');
+lib.keyedContainer = require('./keyed_container');
 lib.isPlainObject = require('./is_plain_object');
 lib.isArray = require('./is_array');
 lib.mod = require('./mod');
diff --git a/src/lib/keyed_container.js b/src/lib/keyed_container.js
@@ -0,0 +1,110 @@
+/**
+* Copyright 2012-2017, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+var nestedProperty = require('./nested_property');
+
+// bitmask for deciding what's updated:
+var NONE = 0;
+var NAME = 1;
+var VALUE = 2;
+var BOTH = 3;
+
+module.exports = function keyedContainer(baseObj, path) {
+    var i, arr;
+    var changeTypes = {};
+
+    if(path && path.length) { arr = nestedProperty(baseObj, path).get();
+    } else {
+        arr = baseObj;
+    }
+
+    path = path || '';
+    arr = arr || [];
+
+    // Construct an index:
+    var indexLookup = {};
+    for(i = 0; i < arr.length; i++) {
+        indexLookup[arr[i].name] = i;
+    }
+
+    var obj = {
+        // NB: this does not actually modify the baseObj
+        set: function(name, value) {
+            var changeType = NONE;
+            var idx = indexLookup[name];
+            if(idx === undefined) {
+                changeType = BOTH;
+                idx = arr.length;
+                indexLookup[name] = idx;
+            } else if(value !== arr[idx].value) {
+                changeType = VALUE;
+            }
+            arr[idx] = {name: name, value: value};
+
+            changeTypes[idx] = changeTypes[idx] | changeType;
+
+            return obj;
+        },
+        get: function(name) {
+            var idx = indexLookup[name];
+            return idx === undefined ? undefined : arr[idx].value;
+        },
+        rename: function(name, newName) {
+            var idx = indexLookup[name];
+
+            if(idx === undefined) return obj;
+            changeTypes[idx] = changeTypes[idx] | NAME;
+
+            indexLookup[newName] = idx;
+            delete indexLookup[name];
+
+            arr[idx].name = newName;
+
+            return obj;
+        },
+        remove: function(name) {
+            var idx = indexLookup[name];
+            if(idx === undefined) return obj;
+            for(i = idx; i < arr.length; i++) {
+                changeTypes[i] = changeTypes[i] | BOTH;
+            }
+            for(i = idx; i < arr.length; i++) {
+                indexLookup[arr[i].name]--;
+            }
+            arr.splice(idx, 1);
+            delete(indexLookup[name]);
+
+            return obj;
+        },
+        constructUpdate: function() {
+            var astr, idx;
+            var update = {};
+            var changed = Object.keys(changeTypes);
+            for(var i = 0; i < changed.length; i++) {
+                idx = changed[i];
+                astr = path + '[' + idx + ']';
+                if(arr[idx]) {
+                    if(changeTypes[idx] & NAME) {
+                        update[astr + '.name'] = arr[idx].name;
+                    }
+                    if(changeTypes[idx] & VALUE) {
+                        update[astr + '.value'] = arr[idx].value;
+                    }
+                } else {
+                    update[astr] = null;
+                }
+            }
+
+            return update;
+        }
+    };
+
+    return obj;
+};
diff --git a/src/plots/plots.js b/src/plots/plots.js
@@ -811,6 +811,11 @@ plots.supplyDataDefaults = function(dataIn, dataOut, layout, fullLayout) {
                 var expandedTrace = expandedTraces[j];
                 var fullExpandedTrace = plots.supplyTraceDefaults(expandedTrace, cnt, fullLayout, i);
 
+                // The group key gets cleared. If set, pass it forward
+                if(expandedTrace._group) {
+                    fullExpandedTrace._group = expandedTrace._group;
+                }
+
                 // mutate uid here using parent uid and expanded index
                 // to promote consistency between update calls
                 expandedTrace.uid = fullExpandedTrace.uid = fullTrace.uid + j;
diff --git a/src/transforms/groupby.js b/src/transforms/groupby.js
@@ -35,6 +35,24 @@ exports.attributes = {
             'with `x` [1, 3] and one trace with `x` [2, 4].'
         ].join(' ')
     },
+    namepattern: {
+        valType: 'string',
+        dflt: '%g (%t)',
+        description: [
+            'Pattern by which grouped traces are named. Available special escape',
+            'sequences are `%g`, which inserts the group name, and `%t`, which',
+            'inserts the trace name. If grouping GDP data by country, for example',
+            'The default "%g (%t)" would return "Monaco (GDP per capita)".'
+        ].join(' ')
+    },
+    groupnames: {
+        valType: 'any',
+        description: [
+            'An array of trace names based on group name. Each entry must be an',
+            'object `{name: "group", value: "trace name"}` which is then applied',
+            'to the particular group, overriding the name derived from `namepattern`.'
+        ].join(' ')
+    },
     styles: {
         _isLinkedToArray: 'style',
         target: {
@@ -83,6 +101,8 @@ exports.supplyDefaults = function(transformIn) {
     if(!enabled) return transformOut;
 
     coerce('groups');
+    coerce('groupnames');
+    coerce('namepattern');
 
     var styleIn = transformIn.styles;
     var styleOut = transformOut.styles = [];
@@ -130,9 +150,15 @@ exports.transform = function(data, state) {
     return newData;
 };
 
+function computeName(pattern, traceName, groupName) {
+    return pattern.replace(/%g/g, groupName)
+        .replace(/%t/g, traceName);
+}
+
 
 function transformOne(trace, state) {
     var i, j, k, attr, srcArray, groupName, newTrace, transforms, arrayLookup;
+    var groupNameObj;
 
     var opts = state.transform;
     var groups = trace.transforms[state.transformIndex].groups;
@@ -153,6 +179,10 @@ function transformOne(trace, state) {
         styleLookup[styles[i].target] = styles[i].value;
     }
 
+    if(opts.groupnames) {
+        groupNameObj = Lib.keyedContainer(opts, 'groupnames');
+    }
+
     // An index to map group name --> expanded trace index
     var indexLookup = {};
 
@@ -162,7 +192,18 @@ function transformOne(trace, state) {
 
         // Start with a deep extend that just copies array references.
         newTrace = newData[i] = Lib.extendDeepNoArrays({}, trace);
-        newTrace.name = groupName;
+        newTrace._group = groupName;
+
+        var suppliedName = null;
+        if(groupNameObj) {
+            suppliedName = groupNameObj.get(groupName);
+        }
+
+        if(suppliedName) {
+            newTrace.name = suppliedName;
+        } else {
+            newTrace.name = computeName(opts.namepattern, trace.name, groupName);
+        }
 
         // In order for groups to apply correctly to other transform data (e.g.
         // a filter transform), we have to break the connection and clone the
diff --git a/test/image/mocks/groupby.json b/test/image/mocks/groupby.json
@@ -0,0 +1,15 @@
+{
+  "data": [
+    {
+      "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
+      "y": [1, 3, 2, 4, 3, 5, 4, 6, 5, 7, 6, 8, 7, 9],
+      "transforms": [{
+        "type": "groupby",
+        "groups": [1, 2, 1, 2, 3, 4, 3, 4, 5, 6, 5, 6, 7, 8]
+      }]
+    }
+  ],
+  "config": {
+    "editable": true
+  }
+}
diff --git a/test/jasmine/tests/lib_test.js b/test/jasmine/tests/lib_test.js
