resolves #1178 - add preservegaps filter options

Author: etpinard

src/transforms/filter.js

@@ -102,7 +102,17 @@ exports.attributes = {
             '*value* is expected to be an array with as many items as',
             'the desired set elements.'
         ].join(' ')
-    }
+    },
+    preservegaps: {
+        valType: 'boolean',
+        dflt: false,
+        description: [
+            'Determines whether or not gaps in data arrays produced by the filter operation',
+            'are preserved or not.',
+            'Setting this to *true* might be useful when plotting a line chart',
+            'with `connectgaps` set to *true*.'
+        ].join(' ')
+    },
 };
 
 exports.supplyDefaults = function(transformIn) {
@@ -115,6 +125,7 @@ exports.supplyDefaults = function(transformIn) {
     var enabled = coerce('enabled');
 
     if(enabled) {
+        coerce('preservegaps');
         coerce('operation');
         coerce('value');
         coerce('target');
@@ -150,36 +161,47 @@ exports.calcTransform = function(gd, trace, opts) {
     var d2cTarget = (target === 'x' || target === 'y' || target === 'z') ?
         target : filterArray;
 
-    var dataToCoord = getDataToCoordFunc(gd, trace, d2cTarget),
-        filterFunc = getFilterFunc(opts, dataToCoord, targetCalendar),
-        arrayAttrs = PlotSchema.findArrayAttributes(trace),
-        originalArrays = {};
-
-    // copy all original array attribute values,
-    // and clear arrays in trace
-    for(var k = 0; k < arrayAttrs.length; k++) {
-        var attr = arrayAttrs[k],
-            np = Lib.nestedProperty(trace, attr);
+    var dataToCoord = getDataToCoordFunc(gd, trace, d2cTarget);
+    var filterFunc = getFilterFunc(opts, dataToCoord, targetCalendar);
+    var arrayAttrs = PlotSchema.findArrayAttributes(trace);
+    var originalArrays = {};
 
-        originalArrays[attr] = Lib.extendDeep([], np.get());
-        np.set([]);
+    function forAllAttrs(fn, index) {
+        for(var j = 0; j < arrayAttrs.length; j++) {
+            var np = Lib.nestedProperty(trace, arrayAttrs[j]);
+            fn(np, index);
+        }
     }
 
-    function fill(attr, i) {
-        var oldArr = originalArrays[attr],
-            newArr = Lib.nestedProperty(trace, attr).get();
-
-        newArr.push(oldArr[i]);
+    var initFn;
+    var fillFn;
+    if(opts.preservegaps) {
+        initFn = function(np) {
+            originalArrays[np.astr] = Lib.extendDeep([], np.get());
+            np.set(new Array(len));
+        };
+        fillFn = function(np, index) {
+            var val = originalArrays[np.astr][index];
+            np.get()[index] = val;
+        };
+    } else {
+        initFn = function(np) {
+            originalArrays[np.astr] = Lib.extendDeep([], np.get());
+            np.set([]);
+        };
+        fillFn = function(np, index) {
+            var val = originalArrays[np.astr][index];
+            np.get().push(val);
+        };
     }
 
-    for(var i = 0; i < len; i++) {
-        var v = filterArray[i];
+    // copy all original array attribute values, and clear arrays in trace
+    forAllAttrs(initFn);
 
-        if(!filterFunc(v)) continue;
-
-        for(var j = 0; j < arrayAttrs.length; j++) {
-            fill(arrayAttrs[j], i);
-        }
+    // loop through filter array, fill trace arrays if passed
+    for(var i = 0; i < len; i++) {
+        var passed = filterFunc(filterArray[i]);
+        if(passed) forAllAttrs(fillFn, i);
     }
 };
 

test/jasmine/tests/transform_filter_test.js

@@ -30,6 +30,7 @@ describe('filter transforms defaults:', function() {
         expect(traceOut.transforms).toEqual([{
             type: 'filter',
             enabled: true,
+            preservegaps: false,
             operation: '=',
             value: 0,
             target: 'x',
@@ -320,6 +321,22 @@ describe('filter transforms calc:', function() {
         expect(out[0].y).toEqual([1]);
     });
 
+    it('should preserve gaps in data when `preservegaps` is turned on', function() {
+        var out = _transform([Lib.extendDeep({}, base, {
+            transforms: [{
+                type: 'filter',
+                preservegaps: true,
+                operation: '>',
+                value: 0,
+                target: 'x'
+            }]
+        })]);
+
+        expect(out[0].x).toEqual([undefined, undefined, undefined, undefined, 1, 2, 3]);
+        expect(out[0].y).toEqual([undefined, undefined, undefined, undefined, 2, 3, 1]);
+        expect(out[0].marker.color).toEqual([undefined, undefined, undefined, undefined, 0.2, 0.3, 0.4]);
+    });
+
     describe('filters should handle numeric values', function() {
         var _base = Lib.extendDeep({}, base);
 

test/jasmine/tests/transform_multi_test.js

@@ -31,6 +31,7 @@ describe('general transforms:', function() {
             operation: '=',
             value: 0,
             target: 'x',
+            preservegaps: false,
             _module: Filter
         }]);
     });
@@ -66,23 +67,23 @@ describe('general transforms:', function() {
 
         traceOut = Plots.supplyTraceDefaults(traceIn, 0, layout);
 
-        expect(traceOut.transforms[0]).toEqual({
+        expect(traceOut.transforms[0]).toEqual(jasmine.objectContaining({
             type: 'filter',
             enabled: true,
             operation: '=',
             value: 0,
             target: 'x',
             _module: Filter
-        }, '- global first');
+        }), '- global first');
 
-        expect(traceOut.transforms[1]).toEqual({
+        expect(traceOut.transforms[1]).toEqual(jasmine.objectContaining({
             type: 'filter',
             enabled: true,
             operation: '>',
             value: 0,
             target: 'x',
             _module: Filter
-        }, '- trace second');
+        }), '- trace second');
 
         expect(layout._transformModules).toEqual([Filter]);
     });
@@ -118,14 +119,14 @@ describe('general transforms:', function() {
         }], msg);
 
         msg = 'supplying the transform defaults';
-        expect(dataOut[1].transforms[0]).toEqual({
+        expect(dataOut[1].transforms[0]).toEqual(jasmine.objectContaining({
             type: 'filter',
             enabled: true,
             operation: '>',
             value: 0,
             target: 'x',
             _module: Filter
-        }, msg);
+        }), msg);
 
         msg = 'keeping refs to user data';
         expect(dataOut[1]._input.x).toEqual([-2, -1, -2, 0, 1, 2, 3], msg);
@@ -144,6 +145,7 @@ describe('general transforms:', function() {
             operation: '>',
             value: 0,
             target: 'x',
+            preservegaps: false,
             _module: Filter
         }], msg);