add two example transform modules

plotly · etpinard · Jul 22, 2016 · May 3, 2016 · May 3, 2016 · May 3, 2016
commit 2697975cb392ec8dc0a72c6440f9e36dd9a7693a
diff --git a/test/jasmine/assets/transforms/filter.js b/test/jasmine/assets/transforms/filter.js
@@ -0,0 +1,161 @@
+'use strict';
+
+// var Lib = require('@src/lib');
+var Lib = require('../../../../src/lib');
+
+/*eslint no-unused-vars: 0*/
+
+
+// so that Plotly.register knows what to do with it
+exports.moduleType = 'transform';
+
+// determines to link between transform type and transform module
+exports.name = 'filter';
+
+// ... as trace attributes
+exports.attributes = {
+    operation: {
+        valType: 'enumerated',
+        values: ['=', '<', '>'],
+        dflt: '='
+    },
+    value: {
+        valType: 'number',
+        dflt: 0
+    },
+    filtersrc: {
+        valType: 'enumerated',
+        values: ['x', 'y'],
+        dflt: 'x'
+    }
+};
+
+/**
+ * Supply transform attributes defaults
+ *
+ * @param {object} transformIn
+ *  object linked to trace.transforms[i] with 'type' set to exports.name
+ * @param {object} fullData
+ *  the plot's full data
+ * @param {object} layout
+ *  the plot's (not-so-full) layout
+ *
+ * @return {object} transformOut
+ *  copy of transformIn that contains attribute defaults
+ */
+exports.supplyDefaults = function(transformIn, fullData, layout) {
+    var transformOut = {};
+
+    function coerce(attr, dflt) {
+        return Lib.coerce(transformIn, transformOut, exports.attributes, attr, dflt);
+    }
+
+    coerce('operation');
+    coerce('value');
+    coerce('filtersrc');
+
+    // or some more complex logic using fullData and layout
+
+    return transformOut;
+};
+
+/**
+ * Apply transform !!!
+ *
+ * @param {array} data
+ *  array of transformed traces (is [fullTrace] upon first transform)
+ *
+ * @param {object} state
+ *  state object which includes:
+ *      - transform {object} full transform attributes
+ *      - fullTrace {object} full trace object which is being transformed
+ *      - fullData {array} full pre-transform(s) data array
+ *      - layout {object} the plot's (not-so-full) layout
+ *
+ * @return {object} newData
+ *  array of transformed traces
+ */
+exports.transform = function(data, state) {
+
+    // one-to-one case
+
+    var newData = data.map(function(trace) {
+        return transformOne(trace, state);
+    });
+
+    return newData;
+};
+
+function transformOne(trace, state) {
+    var newTrace = Lib.extendDeep({}, trace);
+
+    var opts = state.transform;
+    var src = opts.filtersrc;
+    var filterFunc = getFilterFunc(opts);
+    var len = trace[src].length;
+    var arrayAttrs = findArrayAttributes(trace);
+
+    arrayAttrs.forEach(function(attr) {
+        Lib.nestedProperty(newTrace, attr).set([]);
+    });
+
+    function fill(attr, i) {
+        var arr = Lib.nestedProperty(trace, attr).get();
+        var newArr = Lib.nestedProperty(newTrace, attr).get();
+
+        newArr.push(arr[i]);
+    }
+
+    for(var i = 0; i < len; i++) {
+        var v = trace[src][i];
+
+        if(!filterFunc(v)) continue;
+
+        for(var j = 0; j < arrayAttrs.length; j++) {
+            fill(arrayAttrs[j], i);
+        }
+    }
+
+    return newTrace;
+}
+
+function getFilterFunc(opts) {
+    var value = opts.value;
+
+    switch(opts.operation) {
+        case '=':
+            return function(v) { return v === value; };
+        case '<':
+            return function(v) { return v < value; };
+        case '>':
+            return function(v) { return v > value; };
+    }
+}
+
+function findArrayAttributes(obj, root) {
+    root = root || '';
+
+    var list = [];
+
+    Object.keys(obj).forEach(function(k) {
+        var val = obj[k];
+
+        if(k.charAt(0) === '_') return;
+
+        if(k === 'transforms') {
+            val.forEach(function(item, i) {
+                list = list.concat(
+                    findArrayAttributes(item, root + k + '[' + i + ']' + '.')
+                );
+            });
+        }
+        else if(Lib.isPlainObject(val)) {
+            list = list.concat(findArrayAttributes(val, root + k + '.'));
+        }
+        else if(Array.isArray(val)) {
+            list.push(root + k);
+        }
+    });
+
+    return list;
+}
diff --git a/test/jasmine/assets/transforms/groupby.js b/test/jasmine/assets/transforms/groupby.js
@@ -0,0 +1,125 @@
+'use strict';
+
+// var Lib = require('@src/lib');
+var Lib = require('../../../../src/lib');
+
+/*eslint no-unused-vars: 0*/
+
+
+// so that Plotly.register knows what to do with it
+exports.moduleType = 'transform';
+
+// determines to link between transform type and transform module
+exports.name = 'groupby';
+
+// ... as trace attributes
+exports.attributes = {
+    active: {
+        valType: 'boolean',
+        dflt: true
+    },
+    groups: {
+        valType: 'data_array',
+        dflt: []
+    },
+    groupColors: {
+        valType: 'any',
+        dflt: {}
+    }
+};
+
+/**
+ * Supply transform attributes defaults
+ *
+ * @param {object} transformIn
+ *  object linked to trace.transforms[i] with 'type' set to exports.name
+ * @param {object} fullData
+ *  the plot's full data
+ * @param {object} layout
+ *  the plot's (not-so-full) layout
+ *
+ * @return {object} transformOut
+ *  copy of transformIn that contains attribute defaults
+ */
+exports.supplyDefaults = function(transformIn, fullData, layout) {
+    var transformOut = {};
+
+    function coerce(attr, dflt) {
+        return Lib.coerce(transformIn, transformOut, exports.attributes, attr, dflt);
+    }
+
+    var active = coerce('active');
+
+    if(!active) return transformOut;
+
+    coerce('groups');
+    coerce('groupColors');
+
+    // or some more complex logic using fullData and layout
+
+    return transformOut;
+};
+
+/**
+ * Apply transform !!!
+ *
+ * @param {array} data
+ *  array of transformed traces (is [fullTrace] upon first transform)
+ *
+ * @param {object} state
+ *  state object which includes:
+ *      - transform {object} full transform attributes
+ *      - fullTrace {object} full trace object which is being transformed
+ *      - fullData {array} full pre-transform(s) data array
+ *      - layout {object} the plot's (not-so-full) layout
+ *
+ * @return {object} newData
+ *  array of transformed traces
+ */
+exports.transform = function(data, state) {
+
+    // one-to-many case
+
+    var newData = [];
+
+    data.forEach(function(trace) {
+        newData = newData.concat(transformOne(trace, state));
+    });
+
+    return newData;
+};
+
+function transformOne(trace, state) {
+    var opts = state.transform;
+    var groups = opts.groups;
+
+    var groupNames = groups.filter(function(g, i, self) {
+        return self.indexOf(g) === i;
+    });
+
+    var newData = new Array(groupNames.length);
+    var len = Math.min(trace.x.length, trace.y.length, groups.length);
+
+    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 = [];
+
+        for(var j = 0; j < len; j++) {
+            if(groups[j] !== groupName) continue;
+
+            newTrace.x.push(trace.x[j]);
+            newTrace.y.push(trace.y[j]);
+        }
+
+        newTrace.name = groupName;
+        newTrace.marker.color = opts.groupColors[groupName];
+    }
+
+    return newData;
+}