Prop equal against circular structures

Gruntfile.js

@@ -60,7 +60,8 @@ grunt.initConfig({
 		},
 		all: [
 			"<%= jshint.all %>",
-			"!test/deepEqual.js"
+			"!test/deepEqual.js",
+			"!test/propEqual.js"
 		]
 	},
 	search: {

src/assert.js

@@ -87,15 +87,11 @@ QUnit.assert = Assert.prototype = {
 	},
 
 	propEqual: function( actual, expected, message ) {
-		actual = objectValues( actual );
-		expected = objectValues( expected );
-		this.push( QUnit.equiv( actual, expected ), actual, expected, message );
+		this.push( QUnit.equiv.props( actual, expected ), actual, expected, message );
 	},
 
 	notPropEqual: function( actual, expected, message ) {
-		actual = objectValues( actual );
-		expected = objectValues( expected );
-		this.push( !QUnit.equiv( actual, expected ), actual, expected, message );
+		this.push( !QUnit.equiv.props( actual, expected ), actual, expected, message );
 	},
 
 	deepEqual: function( actual, expected, message ) {

src/core.js

@@ -56,24 +56,6 @@ var QUnit,
 		} else {
 			return errorString;
 		}
-	},
-	/**
-	 * Makes a clone of an object using only Array or Object as base,
-	 * and copies over the own enumerable properties.
-	 *
-	 * @param {Object} obj
-	 * @return {Object} New object with only the own properties (recursively).
-	 */
-	objectValues = function( obj ) {
-		var key, val,
-			vals = QUnit.is( "array", obj ) ? [] : {};
-		for ( key in obj ) {
-			if ( hasOwn.call( obj, key ) ) {
-				val = obj[ key ];
-				vals[ key ] = val === Object( val ) ? objectValues( val ) : val;
-			}
-		}
-		return vals;
 	};
 
 QUnit = {};

src/equiv.js

@@ -2,6 +2,25 @@
 // Author: Philippe Rathé <[email protected]>
 QUnit.equiv = (function() {
 
+	/**
+	 * Gets the keys of an object which are both enumerable and own
+	 *
+	 * @param {Object} obj
+	 * @return {Array} Array with the enumerable and own keys of the object given
+	 */
+	function ownObjectKeys( obj ) {
+		var i,
+			keys = [];
+
+		for ( i in obj ) {
+			if ( hasOwn.call( obj, i ) ) {
+				keys.push( i );
+			}
+		}
+
+		return keys;
+	}
+
 	// Call the o related callback with the given arguments.
 	function bindCallbacks( o, callbacks, args ) {
 		var prop = QUnit.objectType( o );
@@ -17,6 +36,12 @@ QUnit.equiv = (function() {
 	// the real equiv function
 	var innerEquiv,
 
+		// the function that performs deep equivalence checks
+		deepEquiv,
+
+		// the function that performs property equivalence checks
+		propEquiv,
+
 		// stack to decide between skip/abort functions
 		callers = [],
 
@@ -116,7 +141,7 @@ QUnit.equiv = (function() {
 								}
 							}
 						}
-						if ( !loop && !innerEquiv( a[ i ], b[ i ] ) ) {
+						if ( !loop && !deepEquiv( a[ i ], b[ i ] ) ) {
 							parents.pop();
 							parentsB.pop();
 							return false;
@@ -171,7 +196,7 @@ QUnit.equiv = (function() {
 							}
 						}
 						aProperties.push( i );
-						if ( !loop && !innerEquiv( a[ i ], b[ i ] ) ) {
+						if ( !loop && !deepEquiv( a[ i ], b[ i ] ) ) {
 							eq = false;
 							break;
 						}
@@ -186,12 +211,11 @@ QUnit.equiv = (function() {
 					}
 
 					// Ensures identical properties name
-					return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
+					return eq && deepEquiv( aProperties.sort(), bProperties.sort() );
 				}
 			};
 		}());
-
-	innerEquiv = function() { // can take multiple arguments
+	deepEquiv = function ( ) { // can take multiple arguments
 		var args = [].slice.apply( arguments );
 		if ( args.length < 2 ) {
 			return true; // end transition
@@ -212,8 +236,75 @@ QUnit.equiv = (function() {
 
 			// apply transition with (1..n) arguments
 		}( args[ 0 ], args[ 1 ] ) ) &&
-			innerEquiv.apply( this, args.splice( 1, args.length - 1 ) ) );
-	};
+			deepEquiv.apply( this, args.splice( 1, args.length - 1 ) ) );
+	},
+	propEquiv = function ( ) {
+		var args = [].slice.apply( arguments );
+		if ( args.length < 2 ) {
+			return true;
+		}
+
+		return ( (function ( a, b ) {
+			if ( !QUnit.is( "object", a ) || !QUnit.is( "object", b ) ) {
+				// if the test author submits parameters that are not objects, check for deepEquiv
+				return deepEquiv( a, b );
+			} else {
+				/*jshint forin:false */
+				var i, j, loop, aCircular, bCircular, currentProperty, subEquiv,
+				// Default to true
+				eq = true,
+				aProperties = ownObjectKeys( a ),
+				bProperties = ownObjectKeys( b );
+
+				// stack constructor before traversing properties
+				callers.push( a.constructor );
+
+				// track reference to avoid circular references
+				parents.push( a );
+				parentsB.push( b );
+
+				for ( i = 0; i < aProperties.length; i++ ){
+					currentProperty = aProperties[i];
+					loop = false;
+					for ( j = 0; j < parents.length; j++ ) {
+
+						aCircular = parents[j] === a[currentProperty];
+						bCircular = parentsB[j] === b[currentProperty];
+
+						if ( aCircular || bCircular ){
+							if ( a[ currentProperty ] === b[ currentProperty ] ||
+									aCircular && bCircular ){
+								loop = true;
+							} else {
+								eq = false;
+								break;
+							}
+						}
+
+					}
+
+					// we'll only use prop equivalence to compare objects
+					subEquiv = QUnit.is( "object", a[ currentProperty ] ) ?
+						propEquiv : deepEquiv;
+
+					if ( !loop && !subEquiv( a[ currentProperty ], b[ currentProperty ] ) ) {
+						eq = false;
+						break;
+					}
+				}
+				parents.pop();
+				parentsB.pop();
+				callers.pop(); // unstack, we are done
+
+				// ensure both objects have the same properties
+				return eq && deepEquiv(aProperties.sort(), bProperties.sort());
+			}
+		}( args[ 0 ], args[ 1 ] ) ) &&
+			propEquiv.apply(this, args.splice( 1, args.length - 1 ) ) );
+
+	},
+	innerEquiv = deepEquiv; // default equivalence check
+	innerEquiv.props = propEquiv;
 
 	return innerEquiv;
 }());

test/assert.js

@@ -46,83 +46,6 @@ QUnit.test( "notStrictEqual", function( assert ) {
 	assert.notStrictEqual( "foo", { toString: function() { return "foo"; } } );
 });
 
-QUnit.test( "propEqual", function( assert ) {
-	assert.expect( 5 );
-	var objectCreate = Object.create || function( origin ) {
-		function O() {}
-		O.prototype = origin;
-		var r = new O();
-		return r;
-	};
-
-	function Foo( x, y, z ) {
-		this.x = x;
-		this.y = y;
-		this.z = z;
-	}
-	Foo.prototype.doA = function() {};
-	Foo.prototype.doB = function() {};
-	Foo.prototype.bar = "prototype";
-
-	function Bar() {
-	}
-	Bar.prototype = objectCreate( Foo.prototype );
-	Bar.prototype.constructor = Bar;
-
-	assert.propEqual(
-		new Foo( 1, "2", [] ),
-		{
-			x: 1,
-			y: "2",
-			z: []
-		}
-	);
-
-	assert.notPropEqual(
-		new Foo( "1", 2, 3 ),
-		{
-			x: 1,
-			y: "2",
-			z: 3
-		},
-		"Primitive values are strictly compared"
-	);
-
-	assert.notPropEqual(
-		new Foo( 1, "2", [] ),
-		{
-			x: 1,
-			y: "2",
-			z: {}
-		},
-		"Array type is preserved"
-	);
-
-	assert.notPropEqual(
-		new Foo( 1, "2", {} ),
-		{
-			x: 1,
-			y: "2",
-			z: []
-		},
-		"Empty array is not the same as empty object"
-	);
-
-	assert.propEqual(
-		new Foo( 1, "2", new Foo( [ 3 ], new Bar(), null ) ),
-		{
-			x: 1,
-			y: "2",
-			z: {
-				x: [ 3 ],
-				y: {},
-				z: null
-			}
-		},
-		"Complex nesting of different types, inheritance and constructors"
-	);
-});
-
 QUnit.test( "throws", function( assert ) {
 	assert.expect( 16 );
 	function CustomError( message ) {

test/deepEqual.js

@@ -1,4 +1,4 @@
-QUnit.module( "equiv" );
+QUnit.module( "deepEquiv" );
 
 QUnit.test( "Primitive types and constants", function( assert ) {
 	assert.equal( QUnit.equiv( null, null ), true, "null" );

test/index.html

@@ -13,6 +13,7 @@
 	<script src="dump.js"></script>
 	<script src="modules.js"></script>
 	<script src="deepEqual.js"></script>
+	<script src="propEqual.js"></script>
 	<script src="globals.js"></script>
 	<script src="swarminject.js"></script>
 </head>