Layout grids

src/lib/coerce.js

@@ -257,19 +257,56 @@ exports.valObjectMeta = {
             'An {array} of plot information.'
         ].join(' '),
         requiredOpts: ['items'],
-        otherOpts: ['dflt', 'freeLength'],
+        // set dimensions=2 for a 2D array
+        // `items` may be a single object instead of an array, in which case
+        // `freeLength` must be true.
+        otherOpts: ['dflt', 'freeLength', 'dimensions'],
         coerceFunction: function(v, propOut, dflt, opts) {
+
+            // simplified coerce function just for array items
+            function coercePart(v, opts, dflt) {
+                var out;
+                var propPart = {set: function(v) { out = v; }};
+
+                if(dflt === undefined) dflt = opts.dflt;
+
+                exports.valObjectMeta[opts.valType].coerceFunction(v, propPart, dflt, opts);
+
+                return out;
+            }
+
+            var twoD = opts.dimensions === 2;
+
             if(!Array.isArray(v)) {
                 propOut.set(dflt);
                 return;
             }
 
-            var items = opts.items,
-                vOut = [];
+            var items = opts.items;
+            var vOut = [];
+            var arrayItems = Array.isArray(items);
+            var len = arrayItems ? items.length : v.length;
+
+            var i, j, len2, vNew;
+
             dflt = Array.isArray(dflt) ? dflt : [];
 
-            for(var i = 0; i < items.length; i++) {
-                exports.coerce(v, vOut, items, '[' + i + ']', dflt[i]);
+            if(twoD) {
+                for(i = 0; i < len; i++) {
+                    vOut[i] = [];
+                    var row = Array.isArray(v[i]) ? v[i] : [];
+                    len2 = arrayItems ? items[i].length : row.length;
+                    for(j = 0; j < len2; j++) {
+                        vNew = coercePart(row[j], arrayItems ? items[i][j] : items, (dflt[i] || [])[j]);
+                        if(vNew !== undefined) vOut[i][j] = vNew;
+                    }
+                }
+            }
+            else {
+                for(i = 0; i < len; i++) {
+                    vNew = coercePart(v[i], arrayItems ? items[i] : items, dflt[i]);
+                    if(vNew !== undefined) vOut[i] = vNew;
+                }
             }
 
             propOut.set(vOut);
@@ -278,15 +315,25 @@ exports.valObjectMeta = {
             if(!Array.isArray(v)) return false;
 
             var items = opts.items;
+            var arrayItems = Array.isArray(items);
+            var twoD = opts.dimensions === 2;
 
             // when free length is off, input and declared lengths must match
             if(!opts.freeLength && v.length !== items.length) return false;
 
             // valid when all input items are valid
             for(var i = 0; i < v.length; i++) {
-                var isItemValid = exports.validate(v[i], opts.items[i]);
-
-                if(!isItemValid) return false;
+                if(twoD) {
+                    if(!Array.isArray(v[i]) || (!opts.freeLength && v[i].length !== items[i].length)) {
+                        return false;
+                    }
+                    for(var j = 0; j < v[i].length; j++) {
+                        if(!exports.validate(v[i][j], arrayItems ? items[i][j] : items)) {
+                            return false;
+                        }
+                    }
+                }
+                else if(!exports.validate(v[i], arrayItems ? items[i] : items)) return false;
             }
 
             return true;

src/plot_api/plot_schema.js

@@ -383,7 +383,8 @@ function recurseIntoValObject(valObject, parts, i) {
     }
 
     // now recurse as far as we can. Occasionally we have an attribute
-    // setting an internal part below what's
+    // setting an internal part below what's in the schema; just return
+    // the innermost schema item we find.
     for(; i < parts.length; i++) {
         var newValObject = valObject[parts[i]];
         if(Lib.isPlainObject(newValObject)) valObject = newValObject;
@@ -398,8 +399,23 @@ function recurseIntoValObject(valObject, parts, i) {
         else if(valObject.valType === 'info_array') {
             i++;
             var index = parts[i];
-            if(!isIndex(index) || index >= valObject.items.length) return false;
-            valObject = valObject.items[index];
+            if(!isIndex(index)) return false;
+
+            var items = valObject.items;
+            if(Array.isArray(items)) {
+                if(index >= items.length) return false;
+                if(valObject.dimensions === 2) {
+                    i++;
+                    if(parts.length === i) return valObject;
+                    var index2 = parts[i];
+                    if(!isIndex(index2)) return false;
+                    valObject = items[index][index2];
+                }
+                else valObject = items[index];
+            }
+            else {
+                valObject = items;
+            }
         }
     }
 

test/image/mocks/grouped_bar.json

@@ -33,11 +33,6 @@
     "xaxis": {
       "type": "category"
     },
-    "barmode": "group",
-    "categories": [
-      "giraffes",
-      "orangutans",
-      "monkeys"
-    ]
+    "barmode": "group"
   }
 }

test/jasmine/tests/annotations_test.js

@@ -1208,7 +1208,10 @@ describe('annotation effects', function() {
         })
         .then(function() {
             expect(gd._fullLayout.annotations[0].x).toBe('2018-01-29 13:29:41.4857');
-            expect(gd._fullLayout.annotations[0].y).toBe('2017-02-02 06:36:46.8112');
+            // AJ loosened this test - expected '2017-02-02 06:36:46.8112'
+            // but when I run it I get '2017-02-02 06:28:39.9586'.
+            // must be different fonts altering autoranging
+            expect(gd._fullLayout.annotations[0].y.substr(0, 10)).toBe('2017-02-02');
         })
         .catch(failTest)
         .then(done);

test/jasmine/tests/gl3d_plot_interact_test.js

@@ -1020,8 +1020,8 @@ describe('@gl Test gl3d annotations', function() {
         camera.eye = {x: x, y: y, z: z};
         scene.setCamera(camera);
         // need a fairly long delay to let the camera update here
-        // 200 was not robust for me (AJ), 300 seems to be.
-        return delay(300)();
+        // 300 was not robust for me (AJ), 500 seems to be.
+        return delay(500)();
     }
 
     it('should move with camera', function(done) {

test/jasmine/tests/lib_test.js

@@ -797,6 +797,77 @@ describe('Test lib.js:', function() {
                 expect(coerce({domain: [0, 0.5, 1]}, {}, infoArrayAttrs, 'domain'))
                     .toEqual([0, 0.5]);
             });
+
+            it('supports bounded freeLength attributes', function() {
+                var attrs = {
+                    x: {
+                        valType: 'info_array',
+                        freeLength: true,
+                        items: [
+                            {valType: 'integer', min: 0},
+                            {valType: 'integer', max: -1}
+                        ],
+                        dflt: [1, -2]
+                    },
+                };
+                expect(coerce({}, {}, attrs, 'x')).toEqual([1, -2]);
+                expect(coerce({x: []}, {}, attrs, 'x')).toEqual([1, -2]);
+                expect(coerce({x: [5]}, {}, attrs, 'x')).toEqual([5, -2]);
+                expect(coerce({x: [-5]}, {}, attrs, 'x')).toEqual([1, -2]);
+                expect(coerce({x: [5, -5]}, {}, attrs, 'x')).toEqual([5, -5]);
+                expect(coerce({x: [3, -3, 3]}, {}, attrs, 'x')).toEqual([3, -3]);
+            });
+
+            it('supports unbounded freeLength attributes', function() {
+                var attrs = {
+                    x: {
+                        valType: 'info_array',
+                        freeLength: true,
+                        items: {valType: 'integer', min: 0, dflt: 1}
+                    }
+                };
+                expect(coerce({}, {}, attrs, 'x')).toBeUndefined();
+                expect(coerce({x: []}, {}, attrs, 'x')).toEqual([]);
+                expect(coerce({x: [3]}, {}, attrs, 'x')).toEqual([3]);
+                expect(coerce({x: [-3]}, {}, attrs, 'x')).toEqual([1]);
+                expect(coerce({x: [-1, 4, 'hi', 5]}, {}, attrs, 'x'))
+                    .toEqual([1, 4, 1, 5]);
+            });
+
+            it('supports 2D fixed-size arrays', function() {
+                var attrs = {
+                    x: {
+                        valType: 'info_array',
+                        dimensions: 2,
+                        items: [
+                            [{valType: 'integer', min: 0, max: 2}, {valType: 'integer', min: 3, max: 5}],
+                            [{valType: 'integer', min: 6, max: 8}, {valType: 'integer', min: 9, max: 11}]
+                        ],
+                        dflt: [[1, 4], [7, 10]]
+                    }
+                };
+                expect(coerce({}, {}, attrs, 'x')).toEqual([[1, 4], [7, 10]]);
+                expect(coerce({x: []}, {}, attrs, 'x')).toEqual([[1, 4], [7, 10]]);
+                expect(coerce({x: [[0, 3], [8, 11]]}, {}, attrs, 'x'))
+                    .toEqual([[0, 3], [8, 11]]);
+                expect(coerce({x: [[10, 5, 10], [6], [1, 2, 3]]}, {}, attrs, 'x'))
+                    .toEqual([[1, 5], [6, 10]]);
+            });
+
+            it('supports unbounded 2D freeLength arrays', function() {
+                var attrs = {
+                    x: {
+                        valType: 'info_array',
+                        freeLength: true,
+                        dimensions: 2,
+                        items: {valType: 'integer', min: 0, dflt: 1}
+                    }
+                };
+                expect(coerce({}, {}, attrs, 'x')).toBeUndefined();
+                expect(coerce({x: []}, {}, attrs, 'x')).toEqual([]);
+                expect(coerce({x: [[], [0], [-1, 2], [5, 'a', 4, 6.6]]}, {}, attrs, 'x'))
+                    .toEqual([[], [0], [1, 2], [5, 1, 4, 1]]);
+            });
         });
 
         describe('subplotid valtype', function() {