transforms: make findArrayAttributes a lib function

- instead of calling it for every transform trace
- call findArrayAttributes in transform function

- make findArrayAttributes 'aware' of array attribute in trace
  so that it lists only the array attributes present in given trace

Author: etpinard

src/lib/coerce.js

@@ -409,3 +409,53 @@ exports.crawl = function(attrs, callback, specifiedLevel) {
         if(isPlainObject(attr)) exports.crawl(attr, callback, level + 1);
     });
 };
+
+/**
+ * Find all data array attributes in a given trace object - including
+ * `arrayOk` attributes.
+ *
+ * @param {object} trace
+ *  full trace object that contains a reference to `_module.attributes`
+ *
+ * @return {array} arrayAttributes
+ *  list of array attributes for the given trace
+ */
+exports.findArrayAttributes = function(trace) {
+    var arrayAttributes = [],
+        stack = [];
+
+    /**
+     * A closure that gathers attribute paths into its enclosed arraySplitAttributes
+     * Attribute paths are collected iff their leaf node is a splittable attribute
+     *
+     * @callback callback
+     * @param {object} attr an attribute
+     * @param {String} attrName name string
+     * @param {object[]} attrs all the attributes
+     * @param {Number} level the recursion level, 0 at the root
+     *
+     * @closureVariable {String[][]} arrayAttributes the set of gathered attributes
+     *   Example of filled closure variable (expected to be initialized to []):
+     *        [["marker","size"],["marker","line","width"],["marker","line","color"]]
+     */
+    function callback(attr, attrName, attrs, level) {
+        stack = stack.slice(0, level).concat([attrName]);
+
+        var splittableAttr = attr.valType === 'data_array' || attr.arrayOk === true;
+        if(!splittableAttr) return;
+
+        var astr = toAttrString(stack);
+        var val = nestedProperty(trace, astr).get();
+        if(!Array.isArray(val)) return;
+
+        arrayAttributes.push(astr);
+    }
+
+    function toAttrString(stack) {
+        return stack.join('.');
+    }
+
+    exports.crawl(trace._module.attributes, callback);
+
+    return arrayAttributes;
+};

src/lib/index.js

@@ -25,6 +25,7 @@ lib.coerceFont = coerceModule.coerceFont;
 lib.validate = coerceModule.validate;
 lib.isValObject = coerceModule.isValObject;
 lib.crawl = coerceModule.crawl;
+lib.findArrayAttributes = coerceModule.findArrayAttributes;
 lib.IS_SUBPLOT_OBJ = coerceModule.IS_SUBPLOT_OBJ;
 lib.IS_LINKED_TO_ARRAY = coerceModule.IS_LINKED_TO_ARRAY;
 lib.DEPRECATED = coerceModule.DEPRECATED;

src/plots/plots.js

@@ -786,41 +786,6 @@ function applyTransforms(fullTrace, fullData, layout) {
     var container = fullTrace.transforms,
         dataOut = [fullTrace];
 
-    var attributeSets = dataOut.map(function(trace) {
-
-        var arraySplitAttributes = [];
-
-        var stack = [];
-
-        /**
-         * A closure that gathers attribute paths into its enclosed arraySplitAttributes
-         * Attribute paths are collected iff their leaf node is a splittable attribute
-         * @callback callback
-         * @param {object} attr an attribute
-         * @param {String} attrName name string
-         * @param {object[]} attrs all the attributes
-         * @param {Number} level the recursion level, 0 at the root
-         * @closureVariable {String[][]} arraySplitAttributes the set of gathered attributes
-         *   Example of filled closure variable (expected to be initialized to []):
-         *        [["marker","size"],["marker","line","width"],["marker","line","color"]]
-         */
-        function callback(attr, attrName, attrs, level) {
-
-            stack = stack.slice(0, level).concat([attrName]);
-
-            var splittableAttr = attr.valType === 'data_array' || attr.arrayOk === true;
-            if(splittableAttr) {
-                arraySplitAttributes.push(stack.slice());
-            }
-        }
-
-        Lib.crawl(trace._module.attributes, callback);
-
-        return arraySplitAttributes.map(function(path) {
-            return path.join('.');
-        });
-    });
-
     for(var i = 0; i < container.length; i++) {
         var transform = container[i],
             type = transform.type,
@@ -831,7 +796,6 @@ function applyTransforms(fullTrace, fullData, layout) {
                 transform: transform,
                 fullTrace: fullTrace,
                 fullData: fullData,
-                attributeSets: attributeSets,
                 layout: layout,
                 transformIndex: i
             });

src/transforms/groupby.js

@@ -103,8 +103,7 @@ function pasteArray(newTrace, trace, j, a) {
     );
 }
 
-function transformOne(trace, state, attributeSet) {
-
+function transformOne(trace, state) {
     var opts = state.transform;
     var groups = trace.transforms[state.transformIndex].groups;
 
@@ -119,10 +118,9 @@ function transformOne(trace, state, attributeSet) {
     var newData = new Array(groupNames.length);
     var len = groups.length;
 
-    var style = opts.style || {};
+    var arrayAttrs = Lib.findArrayAttributes(trace);
 
-    var arrayAttributes = attributeSet
-        .filter(function(array) {return Array.isArray(Lib.nestedProperty(trace, array).get());});
+    var style = opts.style || {};
 
     for(var i = 0; i < groupNames.length; i++) {
         var groupName = groupNames[i];
@@ -131,12 +129,12 @@ function transformOne(trace, state, attributeSet) {
         // maybe we could abstract this out
         var newTrace = newData[i] = Lib.extendDeep({}, trace);
 
-        arrayAttributes.forEach(initializeArray.bind(null, newTrace));
+        arrayAttrs.forEach(initializeArray.bind(null, newTrace));
 
         for(var j = 0; j < len; j++) {
             if(groups[j] !== groupName) continue;
 
-            arrayAttributes.forEach(pasteArray.bind(0, newTrace, trace, j));
+            arrayAttrs.forEach(pasteArray.bind(0, newTrace, trace, j));
         }
 
         newTrace.name = groupName;