hierarchical property split (squashed)

Author: monfera

src/transforms/groupby.js

@@ -91,13 +91,20 @@ exports.transform = function(data, state) {
     var newData = [];
 
     data.forEach(function(trace) {
-        newData = newData.concat(transformOne(trace, state));
+
+        var splittingAttributes = [];
+
+        var attributes = trace._module.attributes;
+        crawl(attributes, splittingAttributes);
+
+        newData = newData.concat(transformOne(trace, state, splittingAttributes));
     });
 
     return newData;
 };
 
-function transformOne(trace, state) {
+function transformOne(trace, state, splittingAttributes) {
+
     var opts = state.transform;
     var groups = opts.groups;
 
@@ -106,30 +113,100 @@ function transformOne(trace, state) {
     });
 
     var newData = new Array(groupNames.length);
-    var len = Math.min(trace.x.length, trace.y.length, groups.length);
+    var len = groups.length;
 
     var style = opts.style || {};
 
+    var topLevelAttributes = splittingAttributes
+        .filter(function(array) {return Array.isArray(getDeepProp(trace, array));});
+
+    var initializeArray = function(newTrace, a) {
+        setDeepProp(newTrace, a, []);
+    };
+
+    var pasteArray = function(newTrace, trace, j, a) {
+        getDeepProp(newTrace, a).push(getDeepProp(trace, a)[j]);
+    };
+
+    // fixme the O(n**3) complexity
     for(var i = 0; i < groupNames.length; i++) {
         var groupName = groupNames[i];
 
         // TODO is this the best pattern ???
         // maybe we could abstract this out
         var newTrace = newData[i] = Lib.extendDeep({}, trace);
 
-        newTrace.x = [];
-        newTrace.y = [];
+        topLevelAttributes.forEach(initializeArray.bind(null, newTrace));
 
         for(var j = 0; j < len; j++) {
             if(groups[j] !== groupName) continue;
 
-            newTrace.x.push(trace.x[j]);
-            newTrace.y.push(trace.y[j]);
+            topLevelAttributes.forEach(pasteArray.bind(0, newTrace, trace, j));
         }
 
         newTrace.name = groupName;
+
+        //  there's no need to coerce style[groupName] here
+        // as another round of supplyDefaults is done on the transformed traces
         newTrace = Lib.extendDeep(newTrace, style[groupName] || {});
     }
 
     return newData;
 }
+
+function getDeepProp(thing, propArray) {
+    var result = thing;
+    var i;
+    for(i = 0; i < propArray.length; i++) {
+        result = result[propArray[i]];
+        if(result === void(0)) {
+            return result;
+        }
+    }
+    return result;
+}
+
+function setDeepProp(thing, propArray, value) {
+    var current = thing;
+    var i;
+    for(i = 0; i < propArray.length - 1; i++) {
+        if(current[propArray[i]] === void(0)) {
+            current[propArray[i]] = {};
+        }
+        current = current[propArray[i]];
+    }
+    current[propArray[propArray.length - 1]] = value;
+}
+
+// fixme check if similar functions in plot_schema.js can be reused
+function crawl(attrs, list, path) {
+    path = path || [];
+
+    Object.keys(attrs).forEach(function(attrName) {
+        var attr = attrs[attrName];
+        var _path = path.slice();
+        _path.push(attrName);
+
+        if(attrName.charAt(0) === '_') return;
+
+        callback(attr, list, _path);
+
+        if(isValObject(attr)) return;
+        if(isPlainObject(attr)) crawl(attr, list, _path);
+    });
+}
+
+function isValObject(obj) {
+    return obj && obj.valType !== undefined;
+}
+
+function callback(attr, list, path) {
+    // see schema.defs for complete list of 'val types'
+    if(attr.valType === 'data_array' || attr.arrayOk === true) {
+        list.push(path);
+    }
+}
+
+function isPlainObject(obj) {
+    return Object.prototype.toString.call(obj) === '[object Object]';
+}

test/jasmine/tests/transform_groupby_test.js

@@ -366,14 +366,22 @@ describe('groupby', function() {
                 Plotly.plot(gd, data).then(function() {
 
                     expect(gd.data.length).toEqual(1);
+                    expect(gd.data[0].ids).toEqual(['q', 'w', 'r', 't', 'y', 'u', 'i']);
                     expect(gd.data[0].x).toEqual([1, -1, -2, 0, 1, 2, 3]);
                     expect(gd.data[0].y).toEqual([0, 1, 2, 3, 5, 4, 6]);
+                    expect(gd.data[0].marker.line.width).toEqual([4, 2, 4, 2, 2, 3, 3]);
 
                     expect(gd._fullData.length).toEqual(2);
+
+                    expect(gd._fullData[0].ids).toEqual(['q', 'w', 't', 'i']);
                     expect(gd._fullData[0].x).toEqual([1, -1, 0, 3]);
                     expect(gd._fullData[0].y).toEqual([0, 1, 3, 6]);
+                    expect(gd._fullData[0].marker.line.width).toEqual([4, 2, 2, 3]);
+
+                    expect(gd._fullData[1].ids).toEqual(['r', 'y', 'u']);
                     expect(gd._fullData[1].x).toEqual([-2, 1, 2]);
                     expect(gd._fullData[1].y).toEqual([2, 5, 4]);
+                    expect(gd._fullData[1].marker.line.width).toEqual([4, 2, 3]);
 
                     assertDims([4, 3]);
 
@@ -385,8 +393,10 @@ describe('groupby', function() {
         // basic test
         var mockData1 = [{
             mode: 'markers',
+            ids: ['q', 'w', 'r', 't', 'y', 'u', 'i'],
             x: [1, -1, -2, 0, 1, 2, 3],
             y: [0, 1, 2, 3, 5, 4, 6],
+            marker: {line: {width: [4, 2, 4, 2, 2, 3, 3]}},
             transforms: [{
                 type: 'groupby',
                 groups: ['a', 'a', 'b', 'a', 'b', 'b', 'a'],
@@ -397,8 +407,10 @@ describe('groupby', function() {
         // heterogenously present attributes
         var mockData2 = [{
             mode: 'markers',
+            ids: ['q', 'w', 'r', 't', 'y', 'u', 'i'],
             x: [1, -1, -2, 0, 1, 2, 3],
             y: [0, 1, 2, 3, 5, 4, 6],
+            marker: {line: {width: [4, 2, 4, 2, 2, 3, 3]}},
             transforms: [{
                 type: 'groupby',
                 groups: ['a', 'a', 'b', 'a', 'b', 'b', 'a'],
@@ -408,25 +420,22 @@ describe('groupby', function() {
                             color: 'orange',
                             size: 20,
                             line: {
-                                color: 'red',
-                                width: 1
+                                color: 'red'
                             }
                         }
                     },
                     b: {
-                        mode: 'markers+lines', // heterogeonos attributes are OK: group "a" doesn't need to define this
+                        mode: 'markers+lines', // heterogeonos attributes are OK: group 'a' doesn't need to define this
                         marker: {
                             color: 'cyan',
                             size: 15,
                             line: {
-                                color: 'purple',
-                                width: 4
+                                color: 'purple'
                             },
                             opacity: 0.5,
                             symbol: 'triangle-up'
                         },
                         line: {
-                            width: 1,
                             color: 'purple'
                         }
                     }
@@ -437,12 +446,13 @@ describe('groupby', function() {
         // attributes set at top level and partially overridden in the group item level
         var mockData3 = [{
             mode: 'markers+lines',
+            ids: ['q', 'w', 'r', 't', 'y', 'u', 'i'],
             x: [1, -1, -2, 0, 1, 2, 3],
             y: [0, 1, 2, 3, 5, 4, 6],
             marker: {
-                color: 'darkred', // general "default" color
+                color: 'darkred', // general 'default' color
                 line: {
-                    width: 8,
+                    width: [4, 2, 4, 2, 2, 3, 3],
                     // a general, not overridden array will be interpreted per group
                     color: ['orange', 'red', 'green', 'cyan']
                 }
@@ -461,8 +471,10 @@ describe('groupby', function() {
 
         var mockData4 = [{
             mode: 'markers+lines',
+            ids: ['q', 'w', 'r', 't', 'y', 'u', 'i'],
             x: [1, -1, -2, 0, 1, 2, 3],
             y: [0, 1, 2, 3, 5, 4, 6],
+            marker: {line: {width: [4, 2, 4, 2, 2, 3, 3]}},
             transforms: [{
                 type: 'groupby',
                 groups: ['a', 'a', 'b', 'a', 'b', 'b', 'a'],
@@ -472,20 +484,39 @@ describe('groupby', function() {
 
         var mockData5 = [{
             mode: 'markers+lines',
+            ids: ['q', 'w', 'r', 't', 'y', 'u', 'i'],
             x: [1, -1, -2, 0, 1, 2, 3],
             y: [0, 1, 2, 3, 5, 4, 6],
+            marker: {
+                line: {width: [4, 2, 4, 2, 2, 3, 3]},
+                size: 10,
+                color: ['red', '#eee', 'lightgreen', 'blue', 'red', '#eee', 'lightgreen']
+            },
             transforms: [{
                 type: 'groupby',
                 groups: ['a', 'a', 'b', 'a', 'b', 'b', 'a']
             }]
         }];
 
-        // this passes OK as expected
+        var mockData6 = [{
+            mode: 'markers+lines',
+            ids: ['q', 'w', 'r', 't', 'y', 'u', 'i'],
+            x: [1, -1, -2, 0, 1, 2, 3],
+            y: [0, 1, 2, 3, 5, 4, 6],
+            marker: {line: {width: [4, 2, 4, 2, 2, 3, 3]}},
+            transforms: [{
+                type: 'groupby',
+                groups: ['a', 'a', 'b', 'a', 'b', 'b', 'a'],
+                style: { a: {marker: {color: 'red'}}, b: {marker: {color: 'blue'}} }
+            }]
+        }];
+
         it('`data` preserves user supplied input but `gd._fullData` reflects the grouping', test(mockData1));
         it('passes with lots of attributes and heterogenous attrib presence', test(mockData2));
         it('passes with group styles partially overriding top level aesthetics', test(mockData3));
         it('passes with no explicit styling for the individual group', test(mockData4));
         it('passes with no explicit styling in the group transform at all', test(mockData5));
+        it('passes with no explicit styling in the group transform at all', test(mockData6));
 
     });