Support symbol properties and keys in cloneWithShallow()

Author: kanongil

lib/index.js

@@ -201,19 +201,21 @@ exports.cloneWithShallow = function (source, keys) {
 
     const storage = internals.store(source, keys);    // Move shallow copy items to storage
     const copy = exports.clone(source);               // Deep copy the rest
-    internals.restore(copy, source, storage);       // Shallow copy the stored items and restore
+    internals.restore(copy, source, storage);         // Shallow copy the stored items and restore
     return copy;
 };
 
 
 internals.store = function (source, keys) {
 
-    const storage = {};
+    const storage = new Map();
     for (let i = 0; i < keys.length; ++i) {
         const key = keys[i];
         const value = exports.reach(source, key);
-        if (value !== undefined) {
-            storage[key] = value;
+        if (typeof value === 'object' ||
+            typeof value === 'function') {
+
+            storage.set(key, value);
             internals.reachSet(source, key, undefined);
         }
     }
@@ -224,18 +226,16 @@ internals.store = function (source, keys) {
 
 internals.restore = function (copy, source, storage) {
 
-    const keys = Object.keys(storage);
-    for (let i = 0; i < keys.length; ++i) {
-        const key = keys[i];
-        internals.reachSet(copy, key, storage[key]);
-        internals.reachSet(source, key, storage[key]);
+    for (const [key, value] of storage) {
+        internals.reachSet(copy, key, value);
+        internals.reachSet(source, key, value);
     }
 };
 
 
 internals.reachSet = function (obj, key, value) {
 
-    const path = key.split('.');
+    const path = Array.isArray(key) ? key : key.split('.');
     let ref = obj;
     for (let i = 0; i < path.length; ++i) {
         const segment = path[i];

test/index.js

@@ -749,14 +749,16 @@ describe('cloneWithShallow()', () => {
             },
             c: {
                 d: 6
-            }
+            },
+            e() {}
         };
 
-        const copy = Hoek.cloneWithShallow(source, ['c']);
+        const copy = Hoek.cloneWithShallow(source, ['c', 'e']);
         expect(copy).to.equal(source);
         expect(copy).to.not.shallow.equal(source);
         expect(copy.a).to.not.shallow.equal(source.a);
-        expect(copy.b).to.equal(source.b);
+        expect(copy.c).to.shallow.equal(source.c);
+        expect(copy.e).to.shallow.equal(source.e);
     });
 
     it('returns immutable value', () => {
@@ -791,6 +793,25 @@ describe('cloneWithShallow()', () => {
         expect(copy.a).to.not.shallow.equal(source.a);
         expect(copy.b).to.equal(source.b);
     });
+
+    it('supports symbols', () => {
+
+        const sym = Symbol();
+        const source = {
+            a: {
+                b: 5
+            },
+            [sym]: {
+                d: 6
+            }
+        };
+
+        const copy = Hoek.cloneWithShallow(source, [[sym]]);
+        expect(copy).to.equal(source);
+        expect(copy).to.not.shallow.equal(source);
+        expect(copy.a).to.not.shallow.equal(source.a);
+        expect(copy[sym]).to.equal(source[sym]);
+    });
 });
 
 describe('applyToDefaultsWithShallow()', () => {