fix: omit name property to compare functions to support on-the-fly arrow functions

Author: jankapunkt

src/index.js

@@ -1,7 +1,7 @@
 // //////////////////////////////////////////////////////////////////////////////// //
 // MIT License
 //
-// Copyright (c) 2018 Jan Küster
+// Copyright (c) 2018 - today Jan Küster
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -154,11 +154,12 @@ scope.Set.prototype.add =
  * @private
  */
 function resolve (obj, circ = new originals.constructor([obj])) {
-  if (typeof obj === 'undefined' ||
-    typeof obj === 'string' ||
-    typeof obj === 'number' ||
-    typeof obj === 'boolean' ||
-    obj === null) {
+  const type = typeof obj
+
+  if (
+    ['undefined', 'string', 'number', 'boolean'].includes(type) ||
+    obj === null
+  ) {
     return obj
   }
 
@@ -167,15 +168,18 @@ function resolve (obj, circ = new originals.constructor([obj])) {
     obj = Array.from(obj)
   }
 
-  if (typeof obj === 'function') {
+  if (type === 'function') {
     const fctObj = { fctStr: String(obj).replace(/\s+/g, '') } // function body to string
     // resolve all function properties / attached references
-    fctObj.refs = Object.getOwnPropertyNames(obj).map(key => originals.has.call(circ, obj[key]) ? 'circular' : resolve(obj[key], circ))
+    fctObj.refs = Object
+      .getOwnPropertyNames(obj)
+      .filter(prop => prop !== 'name')
+      .map(key => originals.has.call(circ, obj[key]) ? 'circular' : resolve(obj[key], circ))
     return fctObj
   }
 
   const isArray = Array.isArray(obj)
-  if (typeof obj !== 'object' && !isArray) {
+  if (type !== 'object' && !isArray) {
     return obj
   }
 
@@ -224,12 +228,14 @@ function resolve (obj, circ = new originals.constructor([obj])) {
  */
 scope.Set.prototype.has = function has (value) {
   const valType = typeof value
+
   if (valType === 'string' || valType === 'number' || valType === 'boolean') {
     return originals.has.call(this, value)
   }
 
   const iterator = this.values()
   let element
+
   while ((element = iterator.next().value) !== undefined) {
     const elType = typeof element
 
@@ -258,9 +264,11 @@ scope.Set.prototype.has = function has (value) {
     //   version of both and compare their strings.
     // - functions are string-ed and their properties are resolved
     //   like objects
-    if ((elType === 'function' && valType === 'function') ||
+    if (
+      (elType === 'function' && valType === 'function') ||
       (!setCompare && elType === 'object' && valType === 'object') ||
-      (Array.isArray(element) && Array.isArray(value))) {
+      (Array.isArray(element) && Array.isArray(value))
+    ) {
       const sortedElmnt = resolve(element)
       const sortedValue = resolve(value)
 

src/index.tests.js

@@ -88,9 +88,8 @@ describe('Relations', function () {
       assert.isTrue(set([{ 1: [{ foo: 'bar' }] }]).has([{ 1: [{ foo: 'bar' }] }]))
       assert.isTrue(set('foo').has('foo'))
       assert.isTrue(set(NaN).has(NaN))
-      assert.isTrue(set(isInt).has(function isInt (n) {
-        return Number.isInteger(n)
-      }))
+      assert.isTrue(set(isInt).has(isInt))
+      assert.isTrue(set(isInt).has(n => Number.isInteger(n)))
     })
 
     it('returns false if a set has not a given element', function () {
@@ -102,7 +101,9 @@ describe('Relations', function () {
       assert.isFalse(set('foo').has('foo '))
       assert.isFalse(set([undefined]).has(null))
       assert.isFalse(set([null]).has(undefined))
-      assert.isFalse(set(isInt).has(n => Number.isInteger(n)))
+      assert.isFalse(set(isInt).has(function isInt (n) {
+        return Number.isInteger(n)
+      }))
     })
 
     it('works recursively for nested sets', function () {
@@ -112,10 +113,10 @@ describe('Relations', function () {
       assert.isTrue(set(set([1, 2, 3]), set([4, 5, 6])).has(set([1, 2, 3])))
       assert.isFalse(set(set([1, 2, 3]), set([4, 5, 6])).has(set([1, 2, 3, 4])))
 
-      assert.isTrue(set(set(isInt)).has(set(function isInt (n) {
+      assert.isTrue(set(set(isInt)).has(set(n => Number.isInteger(n))))
+      assert.isFalse(set(set(isInt)).has(set(function isInt (n) {
         return Number.isInteger(n)
       })))
-      assert.isFalse(set(set(isInt)).has(set(n => Number.isInteger(n))))
 
       const s1 = set(3)
       const s2 = set(3)