Optimize and refactor groupby

Author: rreusser

src/transforms/groupby.js

@@ -116,43 +116,23 @@ exports.supplyDefaults = function(transformIn) {
  *  array of transformed traces
  */
 exports.transform = function(data, state) {
+    var newTraces, i, j;
     var newData = [];
 
-    for(var i = 0; i < data.length; i++) {
-        newData = newData.concat(transformOne(data[i], state));
+    for(i = 0; i < data.length; i++) {
+        newTraces = transformOne(data[i], state);
+
+        for(j = 0; j < newTraces.length; j++) {
+            newData.push(newTraces[j]);
+        }
     }
 
     return newData;
 };
 
-function initializeArray(newTrace, a) {
-    Lib.nestedProperty(newTrace, a).set([]);
-}
-
-function pasteArray(newTrace, trace, j, a) {
-    Lib.nestedProperty(newTrace, a).set(
-        Lib.nestedProperty(newTrace, a).get().concat([
-            Lib.nestedProperty(trace, a).get()[j]
-        ])
-    );
-}
-
-// 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
-// transforms so that each group writes grouped values into a different
-// destination. This function does not break the array reference
-// connection between the split transforms it creates. That's handled in
-// initialize, which creates a new empty array for each arrayAttr.
-function cloneTransforms(newTrace) {
-    var transforms = newTrace.transforms;
-    newTrace.transforms = [];
-    for(var j = 0; j < transforms.length; j++) {
-        newTrace.transforms[j] = Lib.extendDeepNoArrays({}, transforms[j]);
-    }
-}
 
 function transformOne(trace, state) {
-    var i, j;
+    var i, j, k, attr, srcArray, groupName, newTrace, transforms;
     var opts = state.transform;
     var groups = trace.transforms[state.transformIndex].groups;
 
@@ -172,22 +152,31 @@ function transformOne(trace, state) {
         styleLookup[styles[i].target] = styles[i].value;
     }
 
-    for(i = 0; i < groupNames.length; i++) {
-        var groupName = groupNames[i];
-
-        var newTrace = newData[i] = Lib.extendDeepNoArrays({}, trace);
-
-        cloneTransforms(newTrace);
+    var newDataByGroup = {};
 
-        arrayAttrs.forEach(initializeArray.bind(null, newTrace));
+    for(i = 0; i < groupNames.length; i++) {
+        groupName = groupNames[i];
 
-        for(j = 0; j < len; j++) {
-            if(groups[j] !== groupName) continue;
+        // Start with a deep extend that just copies array references.
+        newTrace = newData[i] = newDataByGroup[groupName] = Lib.extendDeepNoArrays({}, trace);
+        newTrace.name = groupName;
 
-            arrayAttrs.forEach(pasteArray.bind(null, newTrace, trace, j));
+        // 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
+        // transforms so that each group writes grouped values into a different
+        // destination. This function does not break the array reference
+        // connection between the split transforms it creates. That's handled in
+        // initialize, which creates a new empty array for each arrayAttr.
+        transforms = newTrace.transforms;
+        newTrace.transforms = [];
+        for(j = 0; j < transforms.length; j++) {
+            newTrace.transforms[j] = Lib.extendDeepNoArrays({}, transforms[j]);
         }
 
-        newTrace.name = groupName;
+        // Initialize empty arrays for the arrayAttrs, to be split in the next step
+        for(j = 0; j < arrayAttrs.length; j++) {
+            Lib.nestedProperty(newTrace, arrayAttrs[j]).set([]);
+        }
 
         Plots.clearExpandedTraceDefaultColors(newTrace);
 
@@ -196,5 +185,21 @@ function transformOne(trace, state) {
         newTrace = Lib.extendDeepNoArrays(newTrace, styleLookup[groupName] || {});
     }
 
+
+    // For each array attribute including those nested inside this and other
+    // transforms (small note that we technically only need to do this for
+    // transforms that have not yet been applied):
+    for(k = 0; k < arrayAttrs.length; k++) {
+        attr = arrayAttrs[k];
+
+        // Get the input data:
+        srcArray = Lib.nestedProperty(trace, attr).get();
+
+        // And push each value onto the appropriate destination for this group:
+        for(j = 0; j < len; j++) {
+            Lib.nestedProperty(newDataByGroup[groups[j]], attr).get().push(srcArray[j]);
+        }
+    }
+
     return newData;
 }