Enable maxDepth option for tracking depth

README.md

@@ -37,11 +37,15 @@ define(function (require, exports, module) {
 ## Usage
 
 ```javascript
-javascriptStringify(value[, replacer [, space]])
+javascriptStringify(value[, replacer [, space [, options]]])
 ```
 
 The API is similar to `JSON.stringify`. However, any value returned by the replacer will be used literally. For this reason, the replacer is passed three arguments - `value`, `indentation` and `stringify`. If you need to continue the stringification process inside your replacer, you can call `stringify` with the updated value.
 
+The `options` object allows some additional configuration:
+
+* **maxDepth** The maximum depth to stringify to
+
 ### Examples
 
 ```javascript
@@ -52,6 +56,8 @@ javascriptStringify('foo'); // "'foo'"
 javascriptStringify({ x: 5, y: 6});       // "{x:5,y:6}"
 javascriptStringify([1, 2, 3, 'string']); // "[1,2,3,'string']"
 
+javascriptStringify({ a: { b: { c: 1 } } }, null, null, { maxDepth: 2 }); // "{a:{b:{}}}"
+
 /**
  * Invalid key names are automatically stringified.
  */

javascript-stringify.js

@@ -223,46 +223,59 @@
    * @param  {Object}          value
    * @param  {Function}        [replacer]
    * @param  {(Number|String)} [space]
+   * @param  {Object} [options]
    * @return {String}
    */
-  return function (value, replacer, space) {
+  return function (value, replacer, space, options) {
+    options = options || {}
+
     // Convert the spaces into a string.
     if (typeof space !== 'string') {
       space = new Array(Math.max(0, space|0) + 1).join(' ');
     }
 
+    var maxDepth = options.maxDepth || 200;
+
+    var depth = 0;
+    var cache = [];
+
     /**
      * Handle recursion by checking if we've visited this node every iteration.
      *
      * @param  {*}      value
-     * @param  {Array}  cache
      * @return {String}
      */
-    var recurse = function (value, cache, next) {
+    var recurse = function (value, next) {
       // If we've already visited this node before, break the recursion.
-      if (cache.indexOf(value) > -1) {
+      if (cache.indexOf(value) > -1 || depth > maxDepth) {
         return;
       }
 
       // Push the value into the values cache to avoid an infinite loop.
+      depth++;
       cache.push(value);
 
       // Stringify the value and fallback to
       return next(value, space, function (value) {
-        return recurse(value, cache.slice(), next);
+        var result = recurse(value, next);
+
+        depth--;
+        cache.pop();
+
+        return result;
       });
     };
 
     // If the user defined a replacer function, make the recursion function
     // a double step process - `replacer -> stringify -> replacer -> etc`.
     if (typeof replacer === 'function') {
-      return recurse(value, [], function (value, space, next) {
+      return recurse(value, function (value, space, next) {
         return replacer(value, space, function (value) {
           return stringify(value, space, next);
         });
       });
     }
 
-    return recurse(value, [], stringify);
+    return recurse(value, stringify);
   };
 });

test.js

@@ -2,13 +2,13 @@ var expect    = require('chai').expect;
 var stringify = require('./');
 
 describe('javascript-stringify', function () {
-  describe('types', function () {
-    var test = function (input, result, indent) {
-      return function () {
-        expect(stringify(input, null, indent)).to.equal(result);
-      };
+  var test = function (input, result, indent, options) {
+    return function () {
+      expect(stringify(input, null, indent, options)).to.equal(result);
     };
+  };
 
+  describe('types', function () {
     describe('booleans', function () {
       it('should be stringified', test(true, 'true'));
     });
@@ -106,7 +106,17 @@ describe('javascript-stringify', function () {
       var obj = [1, 2, 3];
       obj.push(obj);
 
-      expect(stringify(obj)).to.equal("[1,2,3,undefined]");
+      expect(stringify(obj)).to.equal('[1,2,3,undefined]');
+    });
+
+    it('should use multiple references', function () {
+      var obj = {}
+      var child = {};
+
+      obj.a = child;
+      obj.b = child;
+
+      expect(stringify(obj)).to.equal('{a:{},b:{}}');
     });
   });
 
@@ -210,4 +220,15 @@ describe('javascript-stringify', function () {
       expect(string).to.equal('[object Object]');
     });
   });
+
+  describe('max depth', function () {
+    var obj = { a: { b: { c: 1 } } };
+
+    it('should get all object', test(obj, '{a:{b:{c:1}}}'));
+
+    it(
+      'should get part of the object',
+      test(obj, '{a:{b:{}}}', null, { maxDepth: 2 })
+    );
+  });
 });