Release 0.11.0

Author: Hexagon

README.md

@@ -4,7 +4,7 @@
 [![Build status](https://travis-ci.org/Hexagon/klon.svg)](https://travis-ci.org/Hexagon/klon) [![npm version](https://badge.fury.io/js/klon.svg)](https://badge.fury.io/js/klon)
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://img.shields.io/badge/license-MIT-blue.svg)
 
-JavaScript helper for deep cloning and deep merging objects as efficiently as possible. Supports and clones complex native objects as well as circular references.
+JavaScript helper for deep cloning and deep merging objects as efficiently as possible. Supports and clones complex native objects as well as circular references. Is also capable of replacing circular references with a string containing "[Circular]".
 
 # Installation
 
@@ -13,15 +13,15 @@ JavaScript helper for deep cloning and deep merging objects as efficiently as po
 # Usage
 
 ```javascript
-clone(source[, destination]);
+clone(source[, destination][, breakCircular]);
 ```
 
 **source** is the object to be copied.
 
 **destination** (optional) is the new object, where all properties from source will be copied to.
 
 ```javascript
-var clone = require('klon'),
+var klon = require('klon'),
 	myObject1 = {
 		a: 1,
 		b: 2,
@@ -38,13 +38,16 @@ var clone = require('klon'),
 	};
 
 // Clone
-var newObject1 = clone(myObject1);
+var newObject1 = klon(myObject1);
 
 // Extend newObject1 with myObject2
-clone(myObject2, newObject1)
+klon(myObject2, newObject1)
 
 // Merge two objects into a new one
-var newObject3 = clone(newObject2, clone(newObject1, {}) );
+var newObject3 = klon(newObject2, klon(newObject1, {}) );
+
+// Clone and break circular references
+var newObject4 = klon(myObject1, {}, true);
 
 ```
 

index.js

@@ -26,7 +26,7 @@ SOFTWARE.
 
 "use strict";
 
-function klon (source, target, trace) {
+function klon (source, target, breakCircular, trace) {
 
     // No need to copy null, undefined or primitive values
     // Shortest way first
@@ -68,8 +68,13 @@ function klon (source, target, trace) {
 
         // Circular reference? Store the circular reference and move on to next property
         if ( circularReference = trace.get(prop) ) {
-            target[key] = circularReference;
-            continue;
+            if ( !breakCircular ) {
+                    target[key] = circularReference;
+                    continue;
+            } else {
+                    target[key] = "[Circular]"
+                    continue;
+            }
         }
 
         // Pure objects and arrays need tracing
@@ -78,7 +83,7 @@ function klon (source, target, trace) {
         }
 
         // Ok, this seem to be a simple value, assign it
-        target[key] = klon(prop, target[key], trace);
+        target[key] = klon(prop, target[key], breakCircular, trace);
 
     }
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "klon",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "JavaScript helper for deep cloning and deep merging objects as efficiently as possible. Supports and clones complex native objects as well as circular references.",
   "author": "Hexagon <github.com/hexagon>",
   "contributors": [{

test/test.js

@@ -81,6 +81,26 @@ describe("Deep Extend / Clone / Merge", function () {
 
     });
 
+    it("Break shallow circular reference", function () {
+        
+        var simpleObject = {
+                a: {
+                    b: {
+
+                    }
+                }
+            },
+            clonedObject;
+
+        // Create a circular reference
+        simpleObject.a.b = simpleObject.a;
+
+        clonedObject = clone(simpleObject, undefined, true);
+
+        clonedObject.a.b.should.equal("[Circular]");
+        
+    });
+
     it("Circular reference", function () {
 
         var simpleObject = {
@@ -112,6 +132,31 @@ describe("Deep Extend / Clone / Merge", function () {
 
     });
 
+    it("Breaking circular reference", function () {
+        
+        var simpleObject = {
+                a: 1,
+                b: {
+                    c: {
+                        d: {
+                            val: 2
+                        }
+                    }
+                },
+                d: 3
+            },
+            clonedObject;
+
+        // Create a circular reference
+        simpleObject.b.c.d.e = simpleObject.b;
+
+        clonedObject = clone(simpleObject, undefined, true);
+
+        // Test that the circular reference works
+        clonedObject.b.c.d.e.should.equal("[Circular]");
+        
+    });
+
     it("Plain string", function () {
 
         var