depth printing

Author: danielb2

README.md

@@ -23,6 +23,7 @@ you're dealing with.
     * `arrayIndex` - enables index printing for arrays. default: `true`
     * `indent` - defines the number of spaces to indent default: `4`
     * `align` - determines how to align object keys. default: `left`
+    * `depth` - tells purdy how many times to recurse while formatting the object. This is useful for viewing complicated objects. default: `2`. Set to `null` to recurse indefinitely
 
 
 ### `Purdy.stringify(object, [options])`

lib/index.js

@@ -13,7 +13,6 @@ var internals = {
         BoolTrue: 'green.bold',
         Circular: 'grey.bold',
         Date: 'green',
-        error: 'red',
         Function: 'cyan',
         Key: 'white.bold',
         Null: 'red.bold',
@@ -22,9 +21,12 @@ var internals = {
         String: 'yellow',
         Symbol: 'magenta.bold',
         Undefined: 'red.inverse',
+        depth: 'grey',
+        error: 'red',
         path: 'blue'
     },
     defaults: {
+        depth: 2,
         plain: false,
         path: false,
         indent: 4,
@@ -45,8 +47,8 @@ internals.stringify = function (object, options) {
 
     internals.seen = [];
     internals.path = [];
-    internals.settings = Hoek.applyToDefaults(internals.defaults, options || {});
-    return internals.travel(object, '');
+    internals.settings = Hoek.applyToDefaults(internals.defaults, options || {}, true);
+    return internals.travel(object, '', 0);
 };
 
 
@@ -56,13 +58,13 @@ internals.purdy.stringify = internals.stringify;
 module.exports = internals.purdy;
 
 
-internals.travel = function (object, path) {
+internals.travel = function (object, path, depth) {
 
     var type = toString.call(object).split(' ')[1].slice(0, -1);
     var format = '';
 
     if (internals[type]) {
-        format = internals[type](object, path);
+        format = internals[type](object, path, depth);
     }
     else {
         format = String(object);
@@ -105,7 +107,7 @@ internals.tidyPath = function (path) {
     return internals.colorize(path.slice(1, path.size), 'path');
 };
 
-internals.Object = internals.process = internals.global = function (object, path) {
+internals.Object = internals.process = internals.global = function (object, path, depth) {
 
     var keys = Object.keys(object);
 
@@ -117,6 +119,7 @@ internals.Object = internals.process = internals.global = function (object, path
         return '{}';
     }
 
+    ++depth;
     var index = internals.seen.indexOf(object);
     if (index !== -1) {
         return internals.showCircular(index);
@@ -139,7 +142,14 @@ internals.Object = internals.process = internals.global = function (object, path
         }
         var longest = keyLengths.sort(internals.lengthCompare)[keyLengths.length - 1];
         var keyStr = key.toString();
-        out = out + internals.indent() + '' + (internals.printMember(keyStr, longest) + ':') + ' ' + internals.travel(item, path + '.' + keyStr);
+
+        if (internals.settings.depth === null || internals.settings.depth + 1 >= depth) {
+            out = out + internals.indent() + '' + (internals.printMember(keyStr, longest) + ':') + ' ' + internals.travel(item, path + '.' + keyStr, depth);
+        }
+        else {
+            internals.indentLevel = internals.indentLevel - 1;
+            return  internals.colorize('[Object]', 'depth');
+        }
         if (i !== il - 1) {
             out = out + ',';
         }
@@ -159,12 +169,13 @@ internals.showCircular = function (index) {
 };
 
 
-internals.Array = function (array, path) {
+internals.Array = function (array, path, depth) {
 
     if (array.length === 0) {
         return '[]';
     }
 
+    ++depth;
     var index = internals.seen.indexOf(array);
     if (index !== -1) {
         return internals.showCircular(index);
@@ -183,7 +194,13 @@ internals.Array = function (array, path) {
                 internals.tidyPath(path + '.' + i) + '\n';
         }
         var indexStr = internals.settings.arrayIndex ? '[' + internals.printMember(i, il) + '] ' : '';
-        out = out + internals.indent() + '' + indexStr + internals.travel(item, path + '.' + i);
+        if (internals.settings.depth === null || internals.settings.depth + 1 >= depth) {
+            out = out + internals.indent() + '' + indexStr + internals.travel(item, path + '.' + i, depth);
+        }
+        else {
+            internals.indentLevel = internals.indentLevel - 1;
+            return  internals.colorize('[Object]', 'depth');
+        }
         if (i !== il - 1) {
             out = out + ',';
         }

package.json

@@ -4,7 +4,7 @@
   "description": "pretty print objects in real purdy colors. Allows clearer visualization of objects than you get from most pretty printers due to colors. It will also print out the complete path to an object, something that's extremly useful for debugging. Purdy will also print out the path to access a variable using Hoek format making it useful on accessing values.",
   "main": "lib/index.js",
   "scripts": {
-    "test": "lab -a code -t 98 -r html -o coverage.html -r console -o stdout -v"
+    "test": "lab -a code -t 99 -r html -o coverage.html -r console -o stdout -v"
   },
   "homepage": "https://github.com/danielb2/purdy.js",
   "bugs": "https://github.com/danielb2/purdy.js/issues",

test/purdy.js

@@ -30,7 +30,7 @@ describe('Purdy', function () {
         var obj = {
             theError: error
         };
-        var out = Purdy.stringify(obj);
+        var out = Purdy.stringify(obj, { depth: null });
         expect(out).to.equal('{\n    \u001b[1m\u001b[37mtheError\u001b[39m\u001b[22m: { \u001b[31m[Error: some bad, bad error]\u001b[39m\n        \u001b[1m\u001b[37mwithKey\u001b[39m\u001b[22m: \u001b[33m\'key\'\u001b[39m\n    }\n}');
         done();
     });
@@ -60,7 +60,7 @@ describe('Purdy', function () {
 
         var afunc = function () {
 
-            var out = Purdy.stringify(arguments, { plain: true, arrayIndex: false, indent: 2 });
+            var out = Purdy.stringify(arguments, { depth: null, plain: true, arrayIndex: false, indent: 2 });
             expect(out).to.equal('[\n  \'hello\',\n  \'purdy\'\n]');
             done();
         };
@@ -227,7 +227,7 @@ describe('Purdy', function () {
         };
         var orig = Hoek.clone(obj);
 
-        var out = Purdy.stringify(obj, { plain: false, path: true, align: 'right' });
+        var out = Purdy.stringify(obj, { plain: false, path: true, align: 'right', depth: null });
         expect(out).to.equal('{\n    \u001b[1m\u001b[37mtravel\u001b[39m\u001b[22m: {\n        \u001b[34m// \u001b[39m\u001b[34mtravel.down\u001b[39m\n        \u001b[1m\u001b[37mdown\u001b[39m\u001b[22m: {\n            \u001b[34m// \u001b[39m\u001b[34mtravel.down.a\u001b[39m\n            \u001b[1m\u001b[37m  a\u001b[39m\u001b[22m: [\n                \u001b[34m// \u001b[39m\u001b[34mtravel.down.a.0\u001b[39m\n                [\u001b[1m\u001b[37m0\u001b[39m\u001b[22m] {\n                    \u001b[34m// \u001b[39m\u001b[34mtravel.down.a.0.path\u001b[39m\n                    \u001b[1m\u001b[37mpath\u001b[39m\u001b[22m: \u001b[33m\'to get here\'\u001b[39m\n                }\n            ]\n        }\n    }\n}');
         expect(obj).to.deep.equal(orig);
         done();
@@ -301,5 +301,84 @@ describe('Purdy', function () {
         expect(out).to.equal('{\n    Symbol(blah): \'symbol\'\n}');
         done();
     });
+
+    it('obeys depth printing', function (done) {
+
+        var obj = {
+            count: 1,
+            a: {
+                count: 2,
+                b: {
+                    count: 3,
+                    c: {
+                        count: 4
+                    }
+                }
+            }
+        };
+
+        var out = Purdy.stringify(obj, { depth: 1, arrayIndex: false, plain: true });
+        expect(out).to.equal('{\n    count: 1,\n    a: {\n        count: 2,\n        b: [Object]\n    }\n}');
+        done();
+    });
+
+    it('should handle depth printing for array', function (done) {
+
+        var obj = [[[[[[[[[[]]]]]]]]]];
+
+        var out = Purdy.stringify(obj, { depth: 1, arrayIndex: false, plain: true });
+        expect(out).to.equal('[\n    [\n        [Object]\n    ]\n]');
+        done();
+    });
+
+    it('should print using zero depth', function (done) {
+
+        var obj = [[[[[[[[[[]]]]]]]]]];
+
+        var out = Purdy.stringify(obj, { depth: 0, indent: 1, arrayIndex: false, plain: true });
+        expect(out).to.equal('[\n [Object]\n]');
+        done();
+    });
+
+    it('should handle depth printing for mixed', function (done) {
+
+        var obj = {
+            count: 1,
+            a: {
+                foo: [[[[[[[[[[]]]]]]]]]],
+                count: 2,
+                b: {
+                    count: 3,
+                    c: {
+                        count: 4
+                    }
+                }
+            }
+        };
+
+        var out = Purdy.stringify(obj, { depth: 1, arrayIndex: false, plain: true });
+        expect(out).to.equal('{\n    count: 1,\n    a: {\n        foo: [Object],\n        count: 2,\n        b: [Object]\n    }\n}');
+        done();
+    });
+
+    it('should handle depth printing using null depth', function (done) {
+
+        var obj = {
+            count: 1,
+            a: {
+                count: 2,
+                b: {
+                    count: 3,
+                    c: {
+                        count: 4
+                    }
+                }
+            }
+        };
+
+        var out = Purdy.stringify(obj, { depth: null, arrayIndex: false, plain: true });
+        expect(out).to.equal('{\n    count: 1,\n    a: {\n        count: 2,\n        b: {\n            count: 3,\n            c: {\n                count: 4\n            }\n        }\n    }\n}');
+        done();
+    });
 });