Add registry methods for transforms

Author: rreusser

src/components/legend/draw.js

@@ -397,7 +397,7 @@ function drawTexts(g, gd) {
 
                 if(!this.text()) text = ' \u0020\u0020 ';
 
-                var i, transforms, direction;
+                var transforms, direction;
                 var fullInput = legendItem.trace._fullInput || {};
                 var needsRedraw = false;
                 var update = {};
@@ -411,14 +411,11 @@ function drawTexts(g, gd) {
                     direction = transforms[transforms.length - 1].direction;
 
                     update[direction + '.name'] = text;
-                } else if(fullInput.transforms) {
-                    for(i = fullInput.transforms.length - 1; i >= 0; i--) {
-                        if(fullInput.transforms[i].type === 'groupby') {
-                            break;
-                        }
-                    }
+                } else if(Registry.hasTransform(fullInput, 'groupby')) {
+                    var groupbyIndices = Registry.getTransformIndices(fullInput, 'groupby');
+                    var index = groupbyIndices[groupbyIndices.length - 1];
 
-                    var carr = Lib.keyedContainer(fullInput, 'transforms[' + i + '].groupnames', 'group', 'name');
+                    var carr = Lib.keyedContainer(fullInput, 'transforms[' + index + '].groupnames', 'group', 'name');
 
                     if(BLANK_STRING_REGEX.test(origText)) {
                         carr.remove(legendItem.trace._group);

src/registry.js

@@ -166,6 +166,48 @@ exports.traceIs = function(traceType, category) {
     return !!_module.categories[category];
 };
 
+/**
+ * Determine if this trace has a transform of the given type and return
+ * array of matching indices.
+ *
+ * @param {object} data
+ *  a trace object (member of data or fullData)
+ * @param {string} type
+ *  type of trace to test
+ * @return {array}
+ *  array of matching indices. If none found, returns []
+ */
+exports.getTransformIndices = function(data, type) {
+    var indices = [];
+    var transforms = data.transforms || [];
+    for(var i = 0; i < transforms.length; i++) {
+        if(transforms[i].type === type) {
+            indices.push(i);
+        }
+    }
+    return indices;
+};
+
+/**
+ * Determine if this trace has a transform of the given type
+ *
+ * @param {object} data
+ *  a trace object (member of data or fullData)
+ * @param {string} type
+ *  type of trace to test
+ * @return {boolean}
+ */
+exports.hasTransform = function(data, type) {
+    var transforms = data.transforms || [];
+    for(var i = 0; i < transforms.length; i++) {
+        if(transforms[i].type === type) {
+            return true;
+        }
+    }
+    return false;
+
+};
+
 /**
  * Retrieve component module method. Falls back on noop if either the
  * module or the method is missing, so the result can always be safely called

test/jasmine/tests/register_test.js

@@ -277,4 +277,54 @@ describe('the register function', function() {
 
         expect(Registry.transformsRegistry['mah-transform']).toBeDefined();
     });
+
+    describe('getTransformIndices', function() {
+        it('returns an empty array if no transforms present', function() {
+            expect(Registry.getTransformIndices({}, 'groupby')).toEqual([]);
+        });
+
+        it('returns an empty array if none present', function() {
+            expect(Registry.getTransformIndices({
+                transforms: [
+                    {type: 'filter'},
+                    {type: 'groupby'}
+                ]
+            }, 'degauss')).toEqual([]);
+        });
+
+        it('returns an empty array if none present', function() {
+            expect(Registry.getTransformIndices({
+                transforms: [
+                    {type: 'filter'},
+                    {type: 'groupby'},
+                    {type: 'groupby'}
+                ]
+            }, 'groupby')).toEqual([1, 2]);
+        });
+    });
+
+    describe('hasTransform', function() {
+        it('returns an false array if no transforms present', function() {
+            expect(Registry.hasTransform({}, 'groupby')).toBe(false);
+        });
+
+        it('returns an empty array if none present', function() {
+            expect(Registry.hasTransform({
+                transforms: [
+                    {type: 'filter'},
+                    {type: 'groupby'}
+                ]
+            }, 'degauss')).toBe(false);
+        });
+
+        it('returns an empty array if none present', function() {
+            expect(Registry.hasTransform({
+                transforms: [
+                    {type: 'filter'},
+                    {type: 'groupby'},
+                    {type: 'groupby'}
+                ]
+            }, 'groupby')).toBe(true);
+        });
+    });
 });