Fixes the issue by punting on generators completely

Author: searls

package.json

@@ -69,7 +69,8 @@
       "it",
       "expect",
       "td",
-      "assert"
+      "assert",
+      "ES_SUPPORT"
     ],
     "ignore": [
       "dist",

src/imitate/overwrite-children/gather-props.js

@@ -1,12 +1,12 @@
 import _ from '../../wrap/lodash'
 
-import isPrimitiveLike from './is-primitive-like'
+import isFakeable from './is-fakeable'
 
 export default (thing) => {
   const originalThing = thing
   const props = {}
 
-  while (!isPrimitiveLike(thing) && !isNativePrototype(thing)) {
+  while (isFakeable(thing) && !isNativePrototype(thing)) {
     Object.getOwnPropertyNames(thing).forEach((propName) => {
       if (!props[propName] && propName !== 'constructor') {
         props[propName] = Object.getOwnPropertyDescriptor(thing, propName)

src/imitate/overwrite-children/index.js

@@ -1,12 +1,12 @@
 import _ from '../../wrap/lodash'
 
-import isPrimitiveLike from './is-primitive-like'
+import isFakeable from './is-fakeable'
 import gatherProps from './gather-props'
 import copyProps from './copy-props'
 import chainPrototype from './chain-prototype'
 
 export default (original, target, overwriteChild) => {
-  if (isPrimitiveLike(target)) return
+  if (!isFakeable(target)) return
 
   if (_.isArray(target)) {
     _.each(original, (item, index) =>

src/imitate/overwrite-children/is-primitive-like.js renamed to src/imitate/overwrite-children/is-fakeable.js

@@ -1,7 +1,11 @@
 import _ from '../../wrap/lodash'
+import isGenerator from '../is-generator'
 
 export default (thing) =>
-  !_.isObject(thing) || _.compact([
+  !(!_.isObject(thing) || isBoxedType(thing) || isGenerator(thing))
+
+const isBoxedType = (thing) =>
+  _.compact([
     Boolean,
     Date,
     Number,

test/helper.js

@@ -19,11 +19,13 @@ module.exports = {
   afterAll: function () {}
 }
 
-global.ES_GENERATOR_SUPPORT = (function () {
-  try {
-    eval('(function* () {})')
-    return true
-  } catch (e) {
-    return false
-  }
-})()
+global.ES_SUPPORT = {
+  GENERATORS: (function () {
+    try {
+      eval('(function* () {})') // eslint-disable-line
+      return true
+    } catch (e) {
+      return false
+    }
+  })()
+}

test/safe/imitate/index.test.js

@@ -93,42 +93,60 @@ module.exports = {
     assert.equal(explain(result.shirt).name, 'pants.shirt')
     assert.equal(explain(result.shirt.tie).name, 'pants.shirt.tie')
   },
-  'names prototypal things okay': () => {
-    class Thing {
-      doStuff () {}
-    }
-    Thing.prototype.doStuff.bar = { baz: function () {} }
-
-    const result = subject(Thing)
-
-    assert.equal(explain(result).name, 'Thing')
-    assert.equal(explain(result.prototype.doStuff).name, 'Thing.prototype.doStuff')
-    assert.equal(explain(result.prototype.doStuff.bar.baz).name, 'Thing.prototype.doStuff.bar.baz')
-  },
-  'name array things okay': () => {
+  'skips over generator functions, even their custom properties': () => {
+    // This is currently unsupported, expect to kill this test someday
+    if (!ES_SUPPORT.GENERATORS) return
     const original = {
-      items: [
-        function () {},
-        function withName () {},
-        () => false,
-        {
-          biz: function () {}
-        }
-      ]
+      func: eval('(function* () {})') // eslint-disable-line
     }
+    const otherRef = {}
+    original.func.customProp = otherRef
 
     const result = subject(original)
 
-    assert.equal(explain(result.items[0]).name, '.items[0]')
-    assert.equal(explain(result.items[1]).name, '.items[1]')
-    assert.equal(explain(result.items[2]).name, '.items[2]')
-    assert.equal(explain(result.items[3].biz).name, '.items[3].biz')
+    assert.strictEqual(result.func, original.func)
+    assert.strictEqual(result.func.customProp, otherRef) // e.g. NOT cloned
   },
-  'other top level things are named fine': () => {
-    assert.equal(explain(subject([() => 1])[0]).name, '[0]')
-    const foo = (function () { return function () {} })()
-    foo.bar = function () {}
-    assert.equal(explain(subject(foo)).name, '(anonymous function)')
-    assert.equal(explain(subject(foo).bar).name, '.bar')
+  'naming stuff': {
+    'prototypal things': () => {
+      class Thing {
+        doStuff () {}
+      }
+      Thing.prototype.doStuff.bar = { baz: function () {} }
+
+      const result = subject(Thing)
+
+      assert.equal(explain(result).name, 'Thing')
+      assert.equal(explain(result.prototype.doStuff).name,
+        'Thing.prototype.doStuff')
+      assert.equal(explain(result.prototype.doStuff.bar.baz).name,
+        'Thing.prototype.doStuff.bar.baz')
+    },
+    'array things': () => {
+      const original = {
+        items: [
+          function () {},
+          function withName () {},
+          () => false,
+          {
+            biz: function () {}
+          }
+        ]
+      }
+
+      const result = subject(original)
+
+      assert.equal(explain(result.items[0]).name, '.items[0]')
+      assert.equal(explain(result.items[1]).name, '.items[1]')
+      assert.equal(explain(result.items[2]).name, '.items[2]')
+      assert.equal(explain(result.items[3].biz).name, '.items[3].biz')
+    },
+    'other top level things': () => {
+      assert.equal(explain(subject([() => 1])[0]).name, '[0]')
+      const foo = (function () { return function () {} })()
+      foo.bar = function () {}
+      assert.equal(explain(subject(foo)).name, '(anonymous function)')
+      assert.equal(explain(subject(foo).bar).name, '.bar')
+    }
   }
 }

test/unit/imitate/is-generator.test.js

@@ -9,15 +9,15 @@ module.exports = {
     assert.strictEqual(result, false)
   },
   'returns true if passed a generator (when generators supported)': () => {
-    if (!ES_GENERATOR_SUPPORT) return
-    const func = eval('(function* () {})') //esline-disable-line
+    if (!ES_SUPPORT.GENERATORS) return
+    const func = eval('(function* () {})') // eslint-disable-line
 
     const result = subject(func)
 
     assert.strictEqual(result, true)
   },
   'returns false when generators are not supported': () => {
-    if (ES_GENERATOR_SUPPORT) return
+    if (ES_SUPPORT.GENERATORS) return
     // Not much of a test, ¯\_(ツ)_/¯
     assert.strictEqual(subject(), false)
   }

test/unit/imitate/overwrite-children/index.test.js

@@ -1,16 +1,16 @@
-let gatherProps, copyProps, isPrimitiveLike, chainPrototype, subject
+let gatherProps, copyProps, isFakeable, chainPrototype, subject
 module.exports = {
   beforeEach: () => {
     gatherProps = td.replace('../../../../src/imitate/overwrite-children/gather-props').default
     copyProps = td.replace('../../../../src/imitate/overwrite-children/copy-props').default
-    isPrimitiveLike = td.replace('../../../../src/imitate/overwrite-children/is-primitive-like').default
+    isFakeable = td.replace('../../../../src/imitate/overwrite-children/is-fakeable').default
     chainPrototype = td.replace('../../../../src/imitate/overwrite-children/chain-prototype').default
     subject = require('../../../../src/imitate/overwrite-children').default
 
-    td.when(isPrimitiveLike(td.matchers.anything())).thenReturn(false)
+    td.when(isFakeable(td.matchers.anything())).thenReturn(true)
   },
-  'target is primitive-like (then do nothing)': () => {
-    td.when(isPrimitiveLike('some target')).thenReturn(true)
+  'target is not fakeable (then do nothing)': () => {
+    td.when(isFakeable('some target')).thenReturn(false)
 
     subject('some original', 'some target', () => { throw new Error('do not fire!') })
 

test/unit/imitate/overwrite-children/is-fakeable.test.js

@@ -0,0 +1,36 @@
+import subject from '../../../../src/imitate/overwrite-children/is-fakeable'
+
+module.exports = {
+  'identifies primitive things': () => {
+    assert.equal(subject(), false)
+    assert.equal(subject(true), false)
+    assert.equal(subject(false), false)
+    assert.equal(subject(undefined), false)
+    assert.equal(subject(null), false)
+    assert.equal(subject(1), false)
+    assert.equal(subject('hi'), false)
+    assert.equal(subject(NaN), false)
+  },
+  'identifies symbols': () => {
+    if (!global.Symbol) return
+
+    assert.equal(subject(Symbol.species), false)
+  },
+  'identifies boxed types and basic value types': () => {
+    assert.equal(subject(new String('hi')), false) // eslint-disable-line
+    assert.equal(subject(new Boolean(false)), false)  // eslint-disable-line
+    assert.equal(subject(new Number(0)), false)  // eslint-disable-line
+    assert.equal(subject(/hi/), false)
+    assert.equal(subject(new Date()), false)
+  },
+  'gives functions, arrays, and custom objects a pass': () => {
+    assert.equal(subject(new Object()), true) // eslint-disable-line
+    assert.equal(subject(function () {}), true)
+    assert.equal(subject([]), true)
+    assert.equal(subject({}), true)
+  },
+  'generators are not fakeable': () => {
+    if (!ES_SUPPORT.GENERATORS) return
+    assert.equal(subject(eval('(function* (){})')), false) // eslint-disable-line
+  }
+}