New “space” option to enable pretty printing (same as ES5)

Author: rprieto

index.js

@@ -3,6 +3,8 @@ var json = typeof JSON !== 'undefined' ? JSON : require('jsonify');
 module.exports = function (obj, opts) {
     if (!opts) opts = {};
     if (typeof opts === 'function') opts = { cmp: opts };
+    var space = opts.space || '';
+    if (typeof space === 'number') space = Array(space+1).join(' ');
     var cmp = opts.cmp && (function (f) {
         return function (node) {
             return function (a, b) {
@@ -13,27 +15,31 @@ module.exports = function (obj, opts) {
         };
     })(opts.cmp);
 
-    return (function stringify (node) {
+    return (function stringify (node, level) {
+        var indent = space ? ('\n' + new Array(level + 1).join(space)) : '';
+        var colonSeparator = space ? ': ' : ':';
         if (typeof node !== 'object' || node === null) {
             return json.stringify(node);
         }
         if (isArray(node)) {
             var out = [];
             for (var i = 0; i < node.length; i++) {
-                out.push(stringify(node[i]));
+                var item = stringify(node[i], level+1);
+                out.push(indent + space + item);
             }
-            return '[' + out.join(',') + ']';
+            return '[' + out.join(',') + indent + ']';
         }
         else {
             var keys = objectKeys(node).sort(cmp && cmp(node));
             var out = [];
             for (var i = 0; i < keys.length; i++) {
                 var key = keys[i];
-                out.push(stringify(key) + ':' + stringify(node[key]));
+                var keyValue = stringify(key,0) + colonSeparator + stringify(node[key],level+1);
+                out.push(indent + space + keyValue);
             }
-            return '{' + out.join(',') + '}';
+            return '{' + out.join(',') + indent + '}';
         }
-    })(obj);
+    })(obj, 0);
 };
 
 var isArray = Array.isArray || function (x) {

readme.markdown

@@ -33,6 +33,10 @@ var stringify = require('json-stable-stringify')
 
 Return a deterministic stringified string `str` from the object `obj`.
 
+## options
+
+### cmp
+
 If `opts` is given, you can supply an `opts.cmp` to have a custom comparison
 function for object keys. Your function `opts.cmp` is called with these
 parameters:
@@ -77,6 +81,34 @@ which outputs:
 {"d":6,"c":5,"b":[{"z":3,"y":2,"x":1},9],"a":10}
 ```
 
+### space
+
+If you specify `opts.space`, it will indent the output for pretty-printing. Valid values are strings (e.g. `{space: \t}`) or a number of spaces (`{space: 3}`).
+
+For example:
+
+```js
+var obj = { b: 1, a: { foo: 'bar', and: [1, 2, 3] } };
+var s = stringify(obj, { space: '  ' });
+console.log(s);
+```
+
+which outputs:
+
+```
+{
+  "a": {
+    "and": [
+      1,
+      2,
+      3
+    ],
+    "foo": "bar"
+  },
+  "b": 1
+}
+```
+
 # install
 
 With [npm](https://npmjs.org) do:

test/space.js

@@ -0,0 +1,59 @@
+var test = require('tape');
+var stringify = require('../');
+
+test('space parameter', function (t) {
+    t.plan(1);
+    var obj = { one: 1, two: 2 };
+    t.equal(stringify(obj, {space: '  '}), ''
+        + '{\n'
+        + '  "one": 1,\n'
+        + '  "two": 2\n'
+        + '}'
+    );
+});
+
+test('space parameter (with tabs)', function (t) {
+    t.plan(1);
+    var obj = { one: 1, two: 2 };
+    t.equal(stringify(obj, {space: '\t'}), ''
+        + '{\n'
+        + '\t"one": 1,\n'
+        + '\t"two": 2\n'
+        + '}'
+    );
+});
+
+test('space parameter (with a number)', function (t) {
+    t.plan(1);
+    var obj = { one: 1, two: 2 };
+    t.equal(stringify(obj, {space: 3}), ''
+        + '{\n'
+        + '   "one": 1,\n'
+        + '   "two": 2\n'
+        + '}'
+    );
+});
+
+test('space parameter (nested objects)', function (t) {
+    t.plan(1);
+    var obj = { one: 1, two: { b: 4, a: [2,3] } };
+    t.equal(stringify(obj, {space: '  '}), ''
+        + '{\n'
+        + '  "one": 1,\n'
+        + '  "two": {\n'
+        + '    "a": [\n'
+        + '      2,\n'
+        + '      3\n'
+        + '    ],\n'
+        + '    "b": 4\n'
+        + '  }\n'
+        + '}'
+    );
+});
+
+test('space parameter (same as native)', function (t) {
+    t.plan(1);
+    // for this test, properties need to be in alphabetical order
+    var obj = { one: 1, two: { a: [2,3], b: 4 } };
+    t.equal(stringify(obj, {space: '  '}), JSON.stringify(obj, null, '  '));
+});