[WIP] Frame + Animate API

src/lib/extend.js

@@ -13,15 +13,19 @@ var isPlainObject = require('./is_plain_object.js');
 var isArray = Array.isArray;
 
 exports.extendFlat = function() {
-    return _extend(arguments, false, false);
+    return _extend(arguments, false, false, false);
 };
 
 exports.extendDeep = function() {
-    return _extend(arguments, true, false);
+    return _extend(arguments, true, false, false);
 };
 
 exports.extendDeepAll = function() {
-    return _extend(arguments, true, true);
+    return _extend(arguments, true, true, false);
+};
+
+exports.extendDeepNoArrays = function() {
+    return _extend(arguments, true, false, true);
 };
 
 /*
@@ -41,7 +45,7 @@ exports.extendDeepAll = function() {
  *   Warning: this might result in infinite loops.
  *
  */
-function _extend(inputs, isDeep, keepAllKeys) {
+function _extend(inputs, isDeep, keepAllKeys, noArrayCopies) {
     var target = inputs[0],
         length = inputs.length;
 
@@ -54,8 +58,13 @@ function _extend(inputs, isDeep, keepAllKeys) {
             src = target[key];
             copy = input[key];
 
+            // Stop early and just transfer the array if array copies are disallowed:
+            if(noArrayCopies && isArray(copy)) {
+                target[key] = copy;
+            }
+
             // recurse if we're merging plain objects or arrays
-            if(isDeep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
+            else if(isDeep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
                 if(copyIsArray) {
                     copyIsArray = false;
                     clone = src && isArray(src) ? src : [];
@@ -64,7 +73,7 @@ function _extend(inputs, isDeep, keepAllKeys) {
                 }
 
                 // never move original objects, clone them
-                target[key] = _extend([clone, copy], isDeep, keepAllKeys);
+                target[key] = _extend([clone, copy], isDeep, keepAllKeys, noArrayCopies);
             }
 
             // don't bring in undefined values, except for extendDeepAll

src/lib/index.js

@@ -57,6 +57,7 @@ var extendModule = require('./extend');
 lib.extendFlat = extendModule.extendFlat;
 lib.extendDeep = extendModule.extendDeep;
 lib.extendDeepAll = extendModule.extendDeepAll;
+lib.extendDeepNoArrays = extendModule.extendDeepNoArrays;
 
 var loggersModule = require('./loggers');
 lib.log = loggersModule.log;
@@ -541,6 +542,39 @@ lib.objectFromPath = function(path, value) {
 
     return obj;
 };
+/**
+ * Iterate through an object in-place, converting dotted properties to objects.
+ *
+ * @example
+ * lib.expandObjectPaths('nested.test[2].path', 'value');
+ * // returns { nested: { test: [null, null, { path: 'value' }]}
+ *
+ */
+// Store this to avoid recompiling regex on every prop since this may happen many
+// many times for animations.
+// TODO: Premature optimization? Remove?
+var dottedPropertyRegex = /^([^\.]*)\../;
+
+lib.expandObjectPaths = function(data) {
+    var match, key, prop, datum;
+    if(typeof data === 'object' && !Array.isArray(data)) {
+        for(key in data) {
+            if(data.hasOwnProperty(key)) {
+                if((match = key.match(dottedPropertyRegex))) {
+                    datum = data[key];
+                    prop = match[1];
+
+                    delete data[key];
+
+                    data[prop] = lib.extendDeepNoArrays(data[prop] || {}, lib.objectFromPath(key, lib.expandObjectPaths(datum))[prop]);
+                } else {
+                    data[key] = lib.expandObjectPaths(data[key]);
+                }
+            }
+        }
+    }
+    return data;
+};
 
 /**
  * Converts value to string separated by the provided separators.

src/lib/merge_keyframes.js → src/lib/merge_frames.js

@@ -21,7 +21,7 @@ var extend = require('./extend');
  *
  * Returns: a third object with the merged content
  */
-module.exports = function mergeKeyframes(target, source) {
+module.exports = function mergeFrames(target, source) {
     var result;
 
     result = extend.extendDeep({}, target);

test/jasmine/tests/extend_test.js

@@ -2,6 +2,7 @@ var extendModule = require('@src/lib/extend.js');
 var extendFlat = extendModule.extendFlat;
 var extendDeep = extendModule.extendDeep;
 var extendDeepAll = extendModule.extendDeepAll;
+var extendDeepNoArrays = extendModule.extendDeepNoArrays;
 
 var str = 'me a test',
     integer = 10,
@@ -418,3 +419,23 @@ describe('extendDeepAll', function() {
         expect(ori.arr[2]).toBe(undefined);
     });
 });
+
+describe('extendDeepNoArrays', function() {
+    'use strict';
+
+    it('does not copy arrays', function() {
+        var src = {foo: {bar: [1, 2, 3], baz: [5, 4, 3]}};
+        var tar = {foo: {bar: [4, 5, 6], bop: [8, 2, 1]}};
+        var ext = extendDeepNoArrays(tar, src);
+
+        expect(ext).not.toBe(src);
+        expect(ext).toBe(tar);
+
+        expect(ext.foo).not.toBe(src.foo);
+        expect(ext.foo).toBe(tar.foo);
+
+        expect(ext.foo.bar).toBe(src.foo.bar);
+        expect(ext.foo.baz).toBe(src.foo.baz);
+        expect(ext.foo.bop).toBe(tar.foo.bop);
+    });
+});

test/jasmine/tests/lib_test.js

@@ -475,6 +475,69 @@ describe('Test lib.js:', function() {
         });
     });
 
+    describe('expandObjectPaths', function() {
+        it('returns the original object', function() {
+            var x = {};
+            expect(Lib.expandObjectPaths(x)).toBe(x);
+        });
+
+        it('unpacks top-level paths', function() {
+            var input = {'marker.color': 'red', 'marker.size': [1, 2, 3]};
+            var expected = {marker: {color: 'red', size: [1, 2, 3]}};
+            expect(Lib.expandObjectPaths(input)).toEqual(expected);
+        });
+
+        it('unpacks recursively', function() {
+            var input = {'marker.color': {'red.certainty': 'definitely'}};
+            var expected = {marker: {color: {red: {certainty: 'definitely'}}}};
+            expect(Lib.expandObjectPaths(input)).toEqual(expected);
+        });
+
+        it('unpacks deep paths', function() {
+            var input = {'foo.bar.baz': 'red'};
+            var expected = {foo: {bar: {baz: 'red'}}};
+            expect(Lib.expandObjectPaths(input)).toEqual(expected);
+        });
+
+        it('unpacks non-top-level deep paths', function() {
+            var input = {color: {'foo.bar.baz': 'red'}};
+            var expected = {color: {foo: {bar: {baz: 'red'}}}};
+            expect(Lib.expandObjectPaths(input)).toEqual(expected);
+        });
+
+        it('merges dotted properties into objects', function() {
+            var input = {marker: {color: 'red'}, 'marker.size': 8};
+            var expected = {marker: {color: 'red', size: 8}};
+            expect(Lib.expandObjectPaths(input)).toEqual(expected);
+        });
+
+        it('merges objects into dotted properties', function() {
+            var input = {'marker.size': 8, marker: {color: 'red'}};
+            var expected = {marker: {color: 'red', size: 8}};
+            expect(Lib.expandObjectPaths(input)).toEqual(expected);
+        });
+
+        it('retains the identity of nested objects', function() {
+            var input = {marker: {size: 8}};
+            var origNested = input.marker;
+            var expanded = Lib.expandObjectPaths(input);
+            var newNested = expanded.marker;
+
+            expect(input).toBe(expanded);
+            expect(origNested).toBe(newNested);
+        });
+
+        it('retains the identity of nested arrays', function() {
+            var input = {'marker.size': [1, 2, 3]};
+            var origArray = input['marker.size'];
+            var expanded = Lib.expandObjectPaths(input);
+            var newArray = expanded.marker.size;
+
+            expect(input).toBe(expanded);
+            expect(origArray).toBe(newArray);
+        });
+    });
+
     describe('coerce', function() {
         var coerce = Lib.coerce,
             out;

test/jasmine/tests/keyframe_computation.js → test/jasmine/tests/merge_frame_test.js

@@ -1,12 +1,12 @@
-var mergeKeyframes = require('@src/lib/merge_keyframes');
+var mergeFrames = require('@src/lib/merge_frames');
 
-describe('Test mergeKeyframes', function() {
+describe('Test mergeFrames', function() {
     'use strict';
 
     it('returns a new object', function() {
         var f1 = {};
         var f2 = {};
-        var result = mergeKeyframes(f1, f2);
+        var result = mergeFrames(f1, f2);
         expect(result).toEqual({});
         expect(result).not.toBe(f1);
         expect(result).not.toBe(f2);
@@ -15,15 +15,15 @@ describe('Test mergeKeyframes', function() {
     it('overrides properties of target with those of source', function() {
         var tar = {xaxis: {range: [0, 1]}};
         var src = {xaxis: {range: [3, 4]}};
-        var out = mergeKeyframes(tar, src);
+        var out = mergeFrames(tar, src);
 
         expect(out).toEqual({xaxis: {range: [3, 4]}});
     });
 
     it('merges dotted properties', function() {
         var tar = {};
         var src = {'xaxis.range': [0, 1]};
-        var out = mergeKeyframes(tar, src);
+        var out = mergeFrames(tar, src);
 
         expect(out).toEqual({'xaxis.range': [0, 1]});
     });
@@ -32,15 +32,15 @@ describe('Test mergeKeyframes', function() {
         it('xaxis.range', function() {
             var tar = {xaxis: {range: [0, 1]}};
             var src = {'xaxis.range': [3, 4]};
-            var out = mergeKeyframes(tar, src);
+            var out = mergeFrames(tar, src);
 
             expect(out).toEqual({xaxis: {range: [3, 4]}});
         });
 
         it('xaxis.range.0', function() {
             var tar = {xaxis: {range: [0, 1]}};
             var src = {'xaxis.range.0': 3};
-            var out = mergeKeyframes(tar, src);
+            var out = mergeFrames(tar, src);
 
             expect(out).toEqual({xaxis: {range: [3, 1]}});
         });