Adding circularKeys method

Author: fishcharlie

README.md

@@ -163,6 +163,8 @@ console.log(object);
 
 This function checks to see if an object is circular. If a search key is passed in it will only return `true` if the object is circular and the search key is the key that caused the circularity.
 
+This function will also check all nested objects for circularity.
+
 ```js
 const objectutils = require("js-object-utilities");
 
@@ -179,3 +181,24 @@ console.log(isRandomKeyCircular); // false
 const isArray2KeyCircular = objectutils.isCircular(object, "array2");
 console.log(isArray2KeyCircular); // true
 ```
+
+### objectutils.circularKeys(obj[, searchKey])
+
+This function is identical to `objectutils.isCircular` except it returns an array of keys that are circular.
+
+```js
+const objectutils = require("js-object-utilities");
+
+let object = {};
+object.array = {"first": 1};
+object.array2 = object;
+
+const circularKeys = objectutils.circularKeys(object);
+console.log(circularKeys); // ["array2"]
+
+const randomKeyCircular = objectutils.circularKeys(object, "random");
+console.log(randomKeyCircular); // []
+
+const array2KeyCircular = objectutils.circularKeys(object, "array2");
+console.log(array2KeyCircular); // ["array2"]
+```

lib/circularKeys.ts

@@ -0,0 +1,46 @@
+import {GeneralObject} from "./types";
+
+const originalKey = "object";
+export = <T>(object: GeneralObject<T>, searchKey?: string): string[] => {
+	const keys = [];
+	const stack = [];
+	const stackSet = new Set();
+	const detected: string[] = [];
+
+	function detect (object: GeneralObject<any>, key: string) {
+		if (object && typeof object !== "object") {
+			return;
+		}
+
+		if (stackSet.has(object)) { // it's cyclic! Print the object and its locations.
+			const oldIndex: number = stack.indexOf(object);
+			const l1: string = keys.join(".") + "." + key;
+			// const l2: string = keys.slice(0, oldIndex + 1).join(".");
+			const currentKey: string = l1.replace(`${originalKey}.`, "");
+
+			if (!searchKey || currentKey === searchKey) {
+				detected.push(currentKey);
+				return;
+			} else {
+				return;
+			}
+		}
+
+		keys.push(key);
+		stack.push(object);
+		stackSet.add(object);
+		for (const k in object) { //dive on the object's children
+			if (Object.prototype.hasOwnProperty.call(object, k)) {
+				detect(object[k], k);
+			}
+		}
+
+		keys.pop();
+		stack.pop();
+		stackSet.delete(object);
+		return;
+	}
+
+	detect(object, originalKey);
+	return detected;
+};

lib/index.ts

@@ -8,6 +8,7 @@ import equals = require("./equals");
 import {clearEmpties} from "./clear_empties";
 import {GeneralObject, GeneralObjectOrValue} from "./types";
 import isCircular = require("./isCircular");
+import circularKeys = require("./circularKeys");
 
 export {
 	get,
@@ -19,6 +20,7 @@ export {
 	equals,
 	clearEmpties,
 	isCircular,
+	circularKeys,
 	GeneralObject,
 	GeneralObjectOrValue
 };

lib/isCircular.ts

@@ -1,45 +1,6 @@
+import circularKeys = require("./circularKeys");
 import {GeneralObject} from "./types";
 
-const originalKey = "object";
 export = <T>(object: GeneralObject<T>, searchKey?: string): boolean => {
-	const keys = [];
-	const stack = [];
-	const stackSet = new Set();
-	let detected = false;
-
-	function detect (object: GeneralObject<any>, key: string) {
-		if (object && typeof object !== "object") {
-			return;
-		}
-
-		if (stackSet.has(object)) { // it's cyclic! Print the object and its locations.
-			const oldIndex: number = stack.indexOf(object);
-			const l1: string = keys.join(".") + "." + key;
-			// const l2: string = keys.slice(0, oldIndex + 1).join(".");
-
-			if (!searchKey || l1.replace(`${originalKey}.`, "") === searchKey) {
-				detected = true;
-				return;
-			} else {
-				return;
-			}
-		}
-
-		keys.push(key);
-		stack.push(object);
-		stackSet.add(object);
-		for (const k in object) { //dive on the object's children
-			if (Object.prototype.hasOwnProperty.call(object, k)) {
-				detect(object[k], k);
-			}
-		}
-
-		keys.pop();
-		stack.pop();
-		stackSet.delete(object);
-		return;
-	}
-
-	detect(object, originalKey);
-	return detected;
+	return circularKeys(object, searchKey).length > 0;
 };

test/circularKeys.js

@@ -0,0 +1,96 @@
+const {expect} = require("chai");
+const utils = require("../dist/index");
+
+describe("utils.circularKeys", () => {
+	it("Should be a function", () => {
+		expect(utils.circularKeys).to.be.a("function");
+	});
+
+	const tests = [
+		{
+			"input": [{"hello": "world"}],
+			"output": []
+		},
+		{
+			"input": [{"hello": "world"}, "hello"],
+			"output": []
+		},
+		{
+			"input": [{"hello": "world"}, "random"],
+			"output": []
+		},
+		{
+			"input": [{"data": {"hello": "world"}}],
+			"output": []
+		},
+		{
+			"input": [(() => {
+				let object = {};
+				object.array = {"first": 1};
+				object.array2 = object;
+				return object;
+			})()],
+			"output": ["array2"]
+		},
+		{
+			"input": [(() => {
+				let object = {};
+				object.array = {"first": 1};
+				object.array2 = object;
+				return object;
+			})(), "random"],
+			"output": []
+		},
+		{
+			"input": [(() => {
+				let object = {};
+				object.array = {"first": 1};
+				object.array2 = object;
+				return object;
+			})(), "array2"],
+			"output": ["array2"]
+		},
+		{
+			"input": [{"data": (() => {
+				let object = {};
+				object.array = {"first": 1};
+				object.array2 = object;
+				return object;
+			})()}],
+			"output": ["data.array2"]
+		},
+		{
+			"input": [{"data": (() => {
+				let object = {};
+				object.array = {"first": 1};
+				object.array2 = object;
+				return object;
+			})()}, "random"],
+			"output": []
+		},
+		{
+			"input": [{"data": (() => {
+				let object = {};
+				object.array = {"first": 1};
+				object.array2 = object;
+				return object;
+			})()}, "array2"],
+			"output": []
+		},
+		{
+			"input": [{"data": (() => {
+				let object = {};
+				object.array = {"first": 1};
+				object.array2 = object;
+				return object;
+			})()}, "data.array2"],
+			"output": ["data.array2"]
+		}
+	];
+
+	tests.forEach((test) => {
+		it(`Should return ${test.output} for ${test.input}`, () => {
+			expect(utils.circularKeys(...test.input)).to.eql(test.output);
+		});
+	});
+});