[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/lib/coerce.js

@@ -12,12 +12,17 @@
 var isNumeric = require('fast-isnumeric');
 var tinycolor = require('tinycolor2');
 var nestedProperty = require('./nested_property');
+var isPlainObject = require('./is_plain_object');
 
 var getColorscale = require('../components/colorscale/get_scale');
 var colorscaleNames = Object.keys(require('../components/colorscale/scales'));
 
 var idRegex = /^([2-9]|[1-9][0-9]+)$/;
 
+function isValObject(obj) {
+    return obj && obj.valType !== undefined;
+}
+
 exports.valObjects = {
     data_array: {
         // You can use *dflt=[] to force said array to exist though.
@@ -355,3 +360,52 @@ exports.validate = function(value, opts) {
     valObject.coerceFunction(value, propMock, failed, opts);
     return out !== failed;
 };
+
+/*
+ * returns true for a valid value object and false for tree nodes in the attribute hierarchy
+ */
+exports.isValObject = isValObject;
+
+exports.IS_SUBPLOT_OBJ = '_isSubplotObj';
+exports.IS_LINKED_TO_ARRAY = '_isLinkedToArray';
+exports.DEPRECATED = '_deprecated';
+
+// list of underscore attributes to keep in schema as is
+exports.UNDERSCORE_ATTRS = [exports.IS_SUBPLOT_OBJ, exports.IS_LINKED_TO_ARRAY, exports.DEPRECATED];
+
+/**
+ * Crawl the attribute tree, recursively calling a callback function
+ *
+ * @param {object} attrs
+ *  The node of the attribute tree (e.g. the root) from which recursion originates
+ * @param {Function} callback
+ *  A callback function with the signature:
+ *          @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
+ * @param {Number} [specifiedLevel]
+ *  The level in the tree, in order to let the callback function detect descend or backtrack,
+ *  typically unsupplied (implied 0), just used by the self-recursive call.
+ *  The necessity arises because the tree traversal is not controlled by callback return values.
+ *  The decision to not use callback return values for controlling tree pruning arose from
+ *  the goal of keeping the crawler backwards compatible. Observe that one of the pruning conditions
+ *  precedes the callback call.
+ *
+ * @return {object} transformOut
+ *  copy of transformIn that contains attribute defaults
+ */
+exports.crawl = function(attrs, callback, specifiedLevel) {
+    var level = specifiedLevel || 0;
+    Object.keys(attrs).forEach(function(attrName) {
+        var attr = attrs[attrName];
+
+        if(exports.UNDERSCORE_ATTRS.indexOf(attrName) !== -1) return;
+
+        callback(attr, attrName, attrs, level);
+
+        if(isValObject(attr)) return;
+        if(isPlainObject(attr)) exports.crawl(attr, callback, level + 1);
+    });
+};

src/lib/index.js

@@ -23,6 +23,12 @@ lib.coerce = coerceModule.coerce;
 lib.coerce2 = coerceModule.coerce2;
 lib.coerceFont = coerceModule.coerceFont;
 lib.validate = coerceModule.validate;
+lib.isValObject = coerceModule.isValObject;
+lib.crawl = coerceModule.crawl;
+lib.IS_SUBPLOT_OBJ = coerceModule.IS_SUBPLOT_OBJ;
+lib.IS_LINKED_TO_ARRAY = coerceModule.IS_LINKED_TO_ARRAY;
+lib.DEPRECATED = coerceModule.DEPRECATED;
+lib.UNDERSCORE_ATTRS = coerceModule.UNDERSCORE_ATTRS;
 
 var datesModule = require('./dates');
 lib.dateTime2ms = datesModule.dateTime2ms;

src/plot_api/plot_schema.js

@@ -23,13 +23,7 @@ var extendDeep = Lib.extendDeep;
 var extendDeepAll = Lib.extendDeepAll;
 
 var NESTED_MODULE = '_nestedModules',
-    COMPOSED_MODULE = '_composedModules',
-    IS_SUBPLOT_OBJ = '_isSubplotObj',
-    IS_LINKED_TO_ARRAY = '_isLinkedToArray',
-    DEPRECATED = '_deprecated';
-
-// list of underscore attributes to keep in schema as is
-var UNDERSCORE_ATTRS = [IS_SUBPLOT_OBJ, IS_LINKED_TO_ARRAY, DEPRECATED];
+    COMPOSED_MODULE = '_composedModules';
 
 var plotSchema = {
     traces: {},
@@ -56,22 +50,9 @@ PlotSchema.get = function() {
     return plotSchema;
 };
 
-PlotSchema.crawl = function(attrs, callback) {
-    Object.keys(attrs).forEach(function(attrName) {
-        var attr = attrs[attrName];
-
-        if(UNDERSCORE_ATTRS.indexOf(attrName) !== -1) return;
+PlotSchema.crawl = Lib.crawl;
 
-        callback(attr, attrName, attrs);
-
-        if(PlotSchema.isValObject(attr)) return;
-        if(Lib.isPlainObject(attr)) PlotSchema.crawl(attr, callback);
-    });
-};
-
-PlotSchema.isValObject = function(obj) {
-    return obj && obj.valType !== undefined;
-};
+PlotSchema.isValObject = Lib.isValObject;
 
 function getTraceAttributes(type) {
     var globalAttributes = Plots.attributes,
@@ -131,13 +112,13 @@ function getLayoutAttributes() {
     // FIXME polar layout attributes
     layoutAttributes = assignPolarLayoutAttrs(layoutAttributes);
 
-    // add IS_SUBPLOT_OBJ attribute
+    // add crawler.IS_SUBPLOT_OBJ attribute
     layoutAttributes = handleSubplotObjs(layoutAttributes);
 
     layoutAttributes = removeUnderscoreAttrs(layoutAttributes);
     mergeValTypeAndRole(layoutAttributes);
 
-    // generate IS_LINKED_TO_ARRAY structure
+    // generate crawler.IS_LINKED_TO_ARRAY structure
     handleLinkedToArray(layoutAttributes);
 
     plotSchema.layout = { layoutAttributes: layoutAttributes };
@@ -158,7 +139,7 @@ function getTransformAttributes(name) {
 function getDefs() {
     plotSchema.defs = {
         valObjects: Lib.valObjects,
-        metaKeys: UNDERSCORE_ATTRS.concat(['description', 'role'])
+        metaKeys: Lib.UNDERSCORE_ATTRS.concat(['description', 'role'])
     };
 }
 
@@ -241,7 +222,7 @@ function mergeValTypeAndRole(attrs) {
         }
     }
 
-    PlotSchema.crawl(attrs, callback);
+    Lib.crawl(attrs, callback);
 }
 
 // helper methods
@@ -267,7 +248,7 @@ function getModule(arg) {
 function removeUnderscoreAttrs(attributes) {
     Object.keys(attributes).forEach(function(k) {
         if(k.charAt(0) === '_' &&
-            UNDERSCORE_ATTRS.indexOf(k) === -1) delete attributes[k];
+            Lib.UNDERSCORE_ATTRS.indexOf(k) === -1) delete attributes[k];
     });
     return attributes;
 }
@@ -321,7 +302,7 @@ function handleSubplotObjs(layoutAttributes) {
                 isSubplotObj = subplotRegistry.attrRegex.test(k);
             }
 
-            if(isSubplotObj) layoutAttributes[k][IS_SUBPLOT_OBJ] = true;
+            if(isSubplotObj) layoutAttributes[k][Lib.IS_SUBPLOT_OBJ] = true;
         });
     });
 
@@ -331,17 +312,17 @@ function handleSubplotObjs(layoutAttributes) {
 function handleLinkedToArray(layoutAttributes) {
 
     function callback(attr, attrName, attrs) {
-        if(attr[IS_LINKED_TO_ARRAY] !== true) return;
+        if(attr[Lib.IS_LINKED_TO_ARRAY] !== true) return;
 
         // TODO more robust logic
         var itemName = attrName.substr(0, attrName.length - 1);
 
-        delete attr[IS_LINKED_TO_ARRAY];
+        delete attr[Lib.IS_LINKED_TO_ARRAY];
 
         attrs[attrName] = { items: {} };
         attrs[attrName].items[itemName] = attr;
         attrs[attrName].role = 'object';
     }
 
-    PlotSchema.crawl(layoutAttributes, callback);
+    Lib.crawl(layoutAttributes, callback);
 }

src/plots/plots.js

@@ -786,6 +786,41 @@ 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,
@@ -796,7 +831,9 @@ function applyTransforms(fullTrace, fullData, layout) {
                 transform: transform,
                 fullTrace: fullTrace,
                 fullData: fullData,
-                layout: layout
+                attributeSets: attributeSets,
+                layout: layout,
+                transformIndex: i
             });
         }
     }

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'
+        values: ['x', 'y', 'ids'],
+        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; };
     }
 }