Refactor

- var → const
- 100% testing coverage
- Little style refactor

lib/index.js

@@ -1,12 +1,12 @@
 'use strict'
 
-var util = require('./util')
-var Args = require('args-js')
-var sliced = require('sliced')
-var nodeify = require('nodeify')
-var promise = require('cb2promise')
+const util = require('./util')
+const Args = require('args-js')
+const sliced = require('sliced')
+const nodeify = require('nodeify')
+const promise = require('cb2promise')
 
-var DEFAULTS_OPTS = {
+const DEFAULTS_OPTS = {
   SAVE: {
     indent: '  '
   },
@@ -24,99 +24,99 @@ function getStringifyParams (params) {
 }
 
 function _checkString (data) {
-  return data instanceof Buffer ? data.toString() : data
+  return data.toString()
 }
 
 function stringifyAsync () {
-  var args = sliced(arguments)
-  var cb = typeof args[args.length - 1] === 'function' ? args.pop() : null
+  const args = sliced(arguments)
+  const cb = typeof args[args.length - 1] === 'function' ? args.pop() : null
 
-  var params = getStringifyParams(args)
-  var data = params.data
-  var replacer = params.replacer
-  var space = params.space
+  const params = getStringifyParams(args)
+  const data = params.data
+  const replacer = params.replacer
+  const space = params.space
 
   if (!cb) return promise(util.stringifyAsync, data, replacer, space)
   return util.stringifyAsync(data, replacer, space, cb)
 }
 
 function stringify () {
-  var params = getStringifyParams(arguments)
-  var data = params.data
-  var replacer = params.replacer
-  var space = params.space
+  const params = getStringifyParams(arguments)
+  const data = params.data
+  const replacer = params.replacer
+  const space = params.space
 
   return util.stringify(data, replacer, space)
 }
 
 function parseAsync () {
-  var args = sliced(arguments)
-  var cb = typeof args[args.length - 1] === 'function' ? args.pop() : null
+  const args = sliced(arguments)
+  const cb = typeof args[args.length - 1] === 'function' ? args.pop() : null
 
-  var params = Args([
-    { data: Args.STRING | Args.Required, _check: _checkString },
+  const params = Args([
+    { data: Args.STRING | Args.Required, _check: (data) => data.toString() },
     { reviver: Args.FUNCTION | Args.Optional },
     { filename: Args.STRING | Args.Optional }
   ], args)
 
-  var data = params.data
-  var reviver = params.reviver
-  var filename = params.filename
+  const data = params.data
+  const reviver = params.reviver
+  const filename = params.filename
 
   if (!cb) return promise(util.parseAsync, data, reviver, filename)
   return util.parseAsync(data, reviver, filename, cb)
 }
 
 function loadAsync () {
-  var params = Args([
+  const params = Args([
     { filepath: Args.STRING | Args.Required },
     { cb: Args.FUNCTION | Args.Optional }
   ], arguments)
 
-  var filepath = params.filepath
-  var cb = params.cb
+  const filepath = params.filepath
+  const cb = params.cb
 
   if (cb) return nodeify(util.loadAsync(filepath), cb)
   return util.loadAsync(filepath)
 }
 
 function load () {
-  var params = Args([
+  const params = Args([
     { filepath: Args.STRING | Args.Required }
   ], arguments)
 
-  var filepath = params.filepath
+  const filepath = params.filepath
 
   return util.load(filepath)
 }
 
 function saveAsync () {
-  var params = Args([
+  const params = Args([
     { filepath: Args.STRING | Args.Required },
     { data: Args.OBJECT | Args.Required },
     { opts: Args.OBJECT | Args.Optional, _default: DEFAULTS_OPTS.SAVE },
     { cb: Args.FUNCTION | Args.Optional }
   ], arguments)
 
-  var filepath = params.filepath
-  var data = params.data
-  var opts = params.opts
-  var cb = params.cb
+  const filepath = params.filepath
+  const data = params.data
+  const opts = params.opts
+  const cb = params.cb
 
   if (cb) return nodeify(util.saveAsync(filepath, data, opts), cb)
-  return util.saveAsync(filepath)
+  return util.saveAsync(filepath, data, opts)
 }
 
 function save () {
-  var params = Args([
+  const params = Args([
     { filepath: Args.STRING | Args.Required },
     { data: Args.OBJECT | Args.Required },
     { opts: Args.OBJECT | Args.Optional, _default: DEFAULTS_OPTS.SAVE }
   ], arguments)
 
-  var filepath = params.filepath
-  var data = params.data
-  var opts = params.opts
+  const filepath = params.filepath
+  const data = params.data
+  const opts = params.opts
 
   return util.save(filepath, data, opts)
 }

lib/util.js

@@ -1,21 +1,23 @@
 'use strict'
 
-var os = require('os')
-var parse = require('parse-json')
-var asyncify = require('async/asyncify')
-var loadJsonFile = require('load-json-file')
-var writeJsonFile = require('write-json-file')
-var stringifySafe = require('json-stringify-safe')
+const os = require('os')
+const parse = require('parse-json')
+const asyncify = require('async/asyncify')
+const loadJsonFile = require('load-json-file')
+const writeJsonFile = require('write-json-file')
+const stringifySafe = require('json-stringify-safe')
 
 function stringify (data, replacer, space) {
   return stringifySafe(data, replacer, space) + os.EOL
 }
 
-module.exports.stringify = stringify
-module.exports.stringifyAsync = asyncify(stringify)
-module.exports.parse = parse
-module.exports.parseAsync = asyncify(parse)
-module.exports.load = loadJsonFile.sync
-module.exports.loadAsync = loadJsonFile
-module.exports.save = writeJsonFile.sync
-module.exports.saveAsync = writeJsonFile
+module.exports = {
+  stringify: stringify,
+  stringifyAsync: asyncify(stringify),
+  parse: parse,
+  parseAsync: asyncify(parse),
+  load: loadJsonFile.sync,
+  loadAsync: loadJsonFile,
+  save: writeJsonFile.sync,
+  saveAsync: writeJsonFile
+}

test/index.js

@@ -1,12 +1,12 @@
 'use strict'
 
-var should = require('should')
-var path = require('path')
-var fs = require('fs')
+const should = require('should')
+const path = require('path')
+const fs = require('fs')
 
-var jsonFuture = require('..')
+const jsonFuture = require('..')
 
-var FIXTURES = {
+const FIXTURES = {
   string: '{\n  "foo": "bar"\n}\n',
   object: {
     foo: 'bar'
@@ -22,69 +22,128 @@ describe('JSON Future ::', function () {
 
   describe('sync', function () {
     it('.parse', function () {
-      var json = jsonFuture.parse(FIXTURES.string)
+      const json = jsonFuture.parse(FIXTURES.string)
       should(json.foo).be.equal(FIXTURES.object.foo)
     })
 
     it('.stringify', function () {
-      var string = jsonFuture.stringify(FIXTURES.object)
+      const string = jsonFuture.stringify(FIXTURES.object)
       should(string).be.equal(FIXTURES.string)
     })
 
     it('.load', function () {
-      var json = jsonFuture.load(FIXTURES.path)
+      const json = jsonFuture.load(FIXTURES.path)
       should(json.foo).be.equal(FIXTURES.object.foo)
     })
 
     it('.save', function () {
       jsonFuture.save(FIXTURES.path2, {hello: 'world'})
-      var json = jsonFuture.load(FIXTURES.path2)
+      const json = jsonFuture.load(FIXTURES.path2)
       should(json.hello).be.equal('world')
     })
   })
 
   describe('async', function () {
     describe('.parseAsync', function () {
-      it('String', function (done) {
-        jsonFuture.parseAsync(FIXTURES.string, function (err, data) {
-          should(data.foo).be.equal(FIXTURES.object.foo)
-          done(err)
+      describe('promise', function () {
+        [
+          ['String', FIXTURES.string],
+          ['Buffer', Buffer.from(FIXTURES.string)]
+        ].forEach(function (pair) {
+          const type = pair[0]
+          const input = pair[1]
+
+          it(type, function (done) {
+            jsonFuture
+              .parseAsync(input)
+              .then(function (json) {
+                should(json.foo).be.equal(FIXTURES.object.foo)
+                done()
+              })
+              .catch(done)
+          })
         })
       })
 
-      it('Buffer', function (done) {
-        var buff = new Buffer(FIXTURES.string)
-        jsonFuture.parseAsync(buff, function (err, data) {
-          should(data.foo).be.equal(FIXTURES.object.foo)
-          done(err)
+      describe('callback', function () {
+        [
+          ['String', FIXTURES.string],
+          ['Buffer', Buffer.from(FIXTURES.string)]
+        ].forEach(function (pair) {
+          const type = pair[0]
+          const input = pair[1]
+
+          it(type, function (done) {
+            jsonFuture.parseAsync(input, function (err, data) {
+              should(data.foo).be.equal(FIXTURES.object.foo)
+              done(err)
+            })
+          })
         })
       })
     })
 
-    it('.stringifyAsync', function (done) {
-      jsonFuture.stringifyAsync(FIXTURES.object, function (err, string) {
-        should(string).be.equal(FIXTURES.string)
-        done(err)
+    describe('.stringifyAsync', function () {
+      it('callback', function (done) {
+        jsonFuture
+          .stringifyAsync(FIXTURES.object)
+          .then(function (string) {
+            should(string).be.equal(FIXTURES.string)
+            done()
+          })
+          .catch(done)
       })
-    })
 
-    it('.loadAsync', function (done) {
-      jsonFuture.loadAsync(FIXTURES.path, function (err, json) {
-        should(json.foo).be.equal(FIXTURES.object.foo)
-        done(err)
+      it('callback', function (done) {
+        jsonFuture.stringifyAsync(FIXTURES.object, function (err, string) {
+          should(string).be.equal(FIXTURES.string)
+          done(err)
+        })
       })
     })
 
-    it('saveAsync', function (done) {
-      jsonFuture.saveAsync(FIXTURES.path2, {
-        hello: 'world2'
-      }, function (err) {
-        if (err) return done(err)
-        jsonFuture.loadAsync(FIXTURES.path2, function (err, json) {
-          should(json.hello).be.equal('world2')
+    describe('.loadAsync', function () {
+      it('promise', function (done) {
+        jsonFuture
+          .loadAsync(FIXTURES.path)
+          .then(function (json) {
+            should(json.foo).be.equal(FIXTURES.object.foo)
+            done()
+          })
+          .catch(done)
+      })
+
+      it('callback', function (done) {
+        jsonFuture.loadAsync(FIXTURES.path, function (err, json) {
+          should(json.foo).be.equal(FIXTURES.object.foo)
           done(err)
         })
       })
     })
+
+    describe('.saveAsync', function () {
+      it('promise', function (done) {
+        jsonFuture
+          .saveAsync(FIXTURES.path2, {hello: 'world2'})
+          .then(() => jsonFuture.loadAsync(FIXTURES.path2))
+          .then((json) => {
+            should(json.hello).be.equal('world2')
+            done()
+          })
+          .catch(done)
+      })
+
+      it('callback', function (done) {
+        jsonFuture.saveAsync(FIXTURES.path2, {
+          hello: 'world2'
+        }, function (err) {
+          if (err) return done(err)
+          jsonFuture.loadAsync(FIXTURES.path2, function (err, json) {
+            should(json.hello).be.equal('world2')
+            done(err)
+          })
+        })
+      })
+    })
   })
 })