[WIP] Transforms [rebase of timelyportfolio's work]

lib/filter.js

@@ -0,0 +1,9 @@
+/**
+* Copyright 2012-2016, 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.
+*/
+
+module.exports = require('../src/transforms/filter');

lib/index.js

@@ -30,4 +30,9 @@ Plotly.register([
     require('./scattermapbox')
 ]);
 
+// add transforms
+Plotly.register([
+    require('./filter')
+]);
+
 module.exports = Plotly;

src/plot_api/plot_schema.js

@@ -56,16 +56,17 @@ PlotSchema.get = function() {
     return plotSchema;
 };
 
-PlotSchema.crawl = function(attrs, callback) {
+PlotSchema.crawl = function (attrs, callback, specifiedLevel) {
+    var level = specifiedLevel || 0;
     Object.keys(attrs).forEach(function(attrName) {
         var attr = attrs[attrName];
 
         if(UNDERSCORE_ATTRS.indexOf(attrName) !== -1) return;
 
-        callback(attr, attrName, attrs);
+        callback(attr, attrName, attrs, level);
 
         if(PlotSchema.isValObject(attr)) return;
-        if(Lib.isPlainObject(attr)) PlotSchema.crawl(attr, callback);
+        if(Lib.isPlainObject(attr)) PlotSchema.crawl(attr, callback, level + 1);
     });
 };
 

src/plots/plots.js

@@ -9,6 +9,7 @@
 
 'use strict';
 
+var PlotSchema = require('./../plot_api/plot_schema')
 var d3 = require('d3');
 var isNumeric = require('fast-isnumeric');
 
@@ -786,6 +787,27 @@ function applyTransforms(fullTrace, fullData, layout) {
     var container = fullTrace.transforms,
         dataOut = [fullTrace];
 
+    var attributeSets = dataOut.map(function(trace) {
+
+        var arraySplitAttributes = [];
+
+        var stack = [];
+
+        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());
+            }
+        }
+
+        PlotSchema.crawl(trace._module.attributes, callback);
+
+        return arraySplitAttributes;
+    });
+
     for(var i = 0; i < container.length; i++) {
         var transform = container[i],
             type = transform.type,
@@ -796,6 +818,7 @@ function applyTransforms(fullTrace, fullData, layout) {
                 transform: transform,
                 fullTrace: fullTrace,
                 fullData: fullData,
+                attributeSets: attributeSets,
                 layout: layout
             });
         }

test/jasmine/assets/transforms/filter.js → src/transforms/filter.js

@@ -1,11 +1,20 @@
+/**
+* Copyright 2012-2016, 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 isNumeric = require('fast-isnumeric');
+
 // var Lib = require('@src/lib');
-var Lib = require('../../../../src/lib');
+var Lib = require('../lib');
 
 /* eslint no-unused-vars: 0*/
 
-
 // so that Plotly.register knows what to do with it
 exports.moduleType = 'transform';
 
@@ -16,17 +25,21 @@ exports.name = 'filter';
 exports.attributes = {
     operation: {
         valType: 'enumerated',
-        values: ['=', '<', '>'],
+        values: ['=', '<', '>', 'within', 'notwithin', 'in', 'notin'],
         dflt: '='
     },
     value: {
-        valType: 'number',
+        valType: 'any',
         dflt: 0
     },
     filtersrc: {
         valType: 'enumerated',
         values: ['x', 'y'],
-        dflt: 'x'
+        dflt: 'x',
+        ids: {
+            valType: 'data_array',
+            description: 'A list of keys for object constancy of data points during animation'
+        }
     }
 };
 
@@ -54,6 +67,16 @@ exports.supplyDefaults = function(transformIn, fullData, layout) {
     coerce('value');
     coerce('filtersrc');
 
+    // numeric values as character should be converted to numeric
+    if(Array.isArray(transformOut.value)) {
+        transformOut.value = transformOut.value.map(function(v) {
+            if(isNumeric(v)) v = +v;
+            return v;
+        });
+    } else {
+        if(isNumeric(transformOut.value)) transformOut.value = +transformOut.value;
+    }
+
     // or some more complex logic using fullData and layout
 
     return transformOut;
@@ -121,6 +144,16 @@ function transformOne(trace, state) {
 
 function getFilterFunc(opts) {
     var value = opts.value;
+    // if value is not array then coerce to
+    //   an array of [value,value] so the
+    //   filter function will work
+    //   but perhaps should just error out
+    var valueArr = [];
+    if(!Array.isArray(value)) {
+        valueArr = [value, value];
+    } else {
+        valueArr = value;
+    }
 
     switch(opts.operation) {
         case '=':
@@ -129,6 +162,30 @@ function getFilterFunc(opts) {
             return function(v) { return v < value; };
         case '>':
             return function(v) { return v > value; };
+        case 'within':
+            return function(v) {
+                // if character then ignore with no side effect
+                function notDateNumber(d) {
+                    return !(isNumeric(d) || Lib.isDateTime(d));
+                }
+                if(valueArr.some(notDateNumber)) {
+                    return true;
+                }
+
+                // keep the = ?
+                return v >= Math.min.apply(null, valueArr) &&
+                      v <= Math.max.apply(null, valueArr);
+            };
+        case 'notwithin':
+            return function(v) {
+                // keep the = ?
+                return !(v >= Math.min.apply(null, valueArr) &&
+                      v <= Math.max.apply(null, valueArr));
+            };
+        case 'in':
+            return function(v) { return valueArr.indexOf(v) >= 0; };
+        case 'notin':
+            return function(v) { return valueArr.indexOf(v) === -1; };
     }
 }
 

test/jasmine/assets/transforms/groupby.js → src/transforms/groupby.js

@@ -1,7 +1,15 @@
+/**
+* Copyright 2012-2016, 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 Lib = require('@src/lib');
-var Lib = require('../../../../src/lib');
+var Lib = require('../lib');
 
 /* eslint no-unused-vars: 0*/
 
@@ -22,7 +30,7 @@ exports.attributes = {
         valType: 'data_array',
         dflt: []
     },
-    groupColors: {
+    style: {
         valType: 'any',
         dflt: {}
     }
@@ -53,7 +61,7 @@ exports.supplyDefaults = function(transformIn, fullData, layout) {
     if(!active) return transformOut;
 
     coerce('groups');
-    coerce('groupColors');
+    coerce('style');
 
     // or some more complex logic using fullData and layout
 
@@ -82,14 +90,16 @@ exports.transform = function(data, state) {
 
     var newData = [];
 
-    data.forEach(function(trace) {
-        newData = newData.concat(transformOne(trace, state));
+    data.forEach(function(trace, i) {
+
+        newData = newData.concat(transformOne(trace, state, state.attributeSets[i]));
     });
 
     return newData;
 };
 
-function transformOne(trace, state) {
+function transformOne(trace, state, attributeSet) {
+
     var opts = state.transform;
     var groups = opts.groups;
 
@@ -98,28 +108,67 @@ 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 = attributeSet
+        .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;
-        newTrace.marker.color = opts.groupColors[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;
+}

test/jasmine/assets/assert_dims.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var d3 = require('d3');
+
+module.exports = function assertDims(dims) {
+    var traces = d3.selectAll('.trace');
+
+    expect(traces.size())
+        .toEqual(dims.length, 'to have correct number of traces');
+
+    traces.each(function(_, i) {
+        var trace = d3.select(this);
+        var points = trace.selectAll('.point');
+
+        expect(points.size())
+            .toEqual(dims[i], 'to have correct number of pts in trace ' + i);
+    });
+};

test/jasmine/assets/assert_style.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var d3 = require('d3');
+
+module.exports = function assertStyle(dims, color, opacity) {
+    var N = dims.reduce(function(a, b) {
+        return a + b;
+    });
+
+    var traces = d3.selectAll('.trace');
+    expect(traces.size())
+        .toEqual(dims.length, 'to have correct number of traces');
+
+    expect(d3.selectAll('.point').size())
+        .toEqual(N, 'to have correct total number of points');
+
+    traces.each(function(_, i) {
+        var trace = d3.select(this);
+        var points = trace.selectAll('.point');
+
+        expect(points.size())
+            .toEqual(dims[i], 'to have correct number of pts in trace ' + i);
+
+        points.each(function() {
+            var point = d3.select(this);
+
+            expect(point.style('fill'))
+                .toEqual(color[i], 'to have correct pt color');
+            expect(+point.style('opacity'))
+                .toEqual(opacity[i], 'to have correct pt opacity');
+        });
+    });
+};

test/jasmine/tests/plotschema_test.js

@@ -2,8 +2,8 @@ var Plotly = require('@lib/index');
 var Lib = require('@src/lib');
 
 Plotly.register([
-    // until they become official
-    require('../assets/transforms/filter')
+    require('@src/transforms/filter'),
+    require('@src/transforms/groupby')
 ]);
 
 describe('plot schema', function() {