deferred-leveldown - npm Package Compare versions

Comparing version 2.0.1 to 2.0.2

deferred-iterator.js

 var util = require('util')
-  , AbstractIterator = require('abstract-leveldown').AbstractIterator
+var AbstractIterator = require('abstract-leveldown').AbstractIterator
 
-
 function DeferredIterator (options) {
@@ -23,4 +22,3 @@ AbstractIterator.call(this, options)
 DeferredIterator.prototype._operation = function (method, args) {
-  if (this._iterator)
-    return this._iterator[method].apply(this._iterator, args)
+  if (this._iterator) return this._iterator[method].apply(this._iterator, args)
   this._operations.push({ method: method, args: args })
@@ -35,2 +33,2 @@ }
 
-module.exports = DeferredIterator;
+module.exports = DeferredIterator

deferred-leveldown.js

@@ -1,12 +0,11 @@
-var util              = require('util')
-  , AbstractLevelDOWN = require('abstract-leveldown').AbstractLevelDOWN
-  , DeferredIterator  = require('./deferred-iterator')
+var util = require('util')
+var AbstractLevelDOWN = require('abstract-leveldown').AbstractLevelDOWN
+var DeferredIterator = require('./deferred-iterator')
+var deferrables = 'put get del batch approximateSize'.split(' ')
 
-  , deferrables       = 'put get del batch approximateSize'.split(' ')
-
 function DeferredLevelDOWN (db) {
   AbstractLevelDOWN.call(this, '')
-  this._db         = db
+  this._db = db
   this._operations = []
-  this._iterators  = []
+  this._iterators = []
 }
@@ -72,3 +71,11 @@
 
-module.exports                  = DeferredLevelDOWN
+DeferredLevelDOWN.prototype._serializeKey = function (key) {
+  return key
+}
+
+DeferredLevelDOWN.prototype._serializeValue = function (value) {
+  return value
+}
+
+module.exports = DeferredLevelDOWN
 module.exports.DeferredIterator = DeferredIterator

package.json

 {
   "name": "deferred-leveldown",
   "description": "For handling delayed-open on LevelDOWN compatible libraries",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "contributors": [
@@ -36,8 +36,9 @@ "Rod Vagg <[e-mail]> (https://github.com/rvagg)",
   "devDependencies": {
+    "standard": "^10.0.3",
     "tape": "^4.7.0"
   },
   "scripts": {
-    "test": "node test.js"
+    "test": "standard && node test.js"
   },
   "license": "MIT"
 }

README.md

@@ -5,9 +5,9 @@ # deferred-leveldown
 
-<img alt="LevelDB Logo" height="100" src="http://leveldb.org/img/logo.svg">
+[![level badge][level-badge]](https://github.com/level/awesome)
+[![npm](https://img.shields.io/npm/v/deferred-leveldown.svg)](https://www.npmjs.com/package/deferred-leveldown)
+[![Build Status](https://travis-ci.org/Level/deferred-leveldown.svg?branch=master)](https://travis-ci.org/Level/deferred-leveldown)
+[![david](https://img.shields.io/david/level/deferred-leveldown.svg)](https://david-dm.org/level/deferred-leveldown)
+[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
+[![npm](https://img.shields.io/npm/dm/deferred-leveldown.svg)](https://www.npmjs.com/package/deferred-leveldown)
 
-[![Build Status](https://secure.travis-ci.org/Level/deferred-leveldown.png)](http://travis-ci.org/rvagg/deferred-leveldown)
-[![Greenkeeper badge](https://badges.greenkeeper.io/Level/deferred-leveldown.svg)](https://greenkeeper.io/)
-
-[![NPM](https://nodei.co/npm/deferred-leveldown.png?compact)](https://nodei.co/npm/deferred-leveldown/)
-
 `deferred-leveldown` implements the basic [abstract-leveldown](https://github.com/Level/abstract-leveldown) API so it can be used as a drop-in replacement where `leveldown` is needed.
@@ -70,1 +70,3 @@
 `deferred-leveldown` is licensed under the MIT license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE.md file for more details.
+
+[level-badge]: http://leveldb.org/img/badge.svg

test.js

@@ -1,27 +0,44 @@
-var test              = require('tape')
-  , DeferredLevelDOWN = require('./')
+var test = require('tape')
+var DeferredLevelDOWN = require('./')
 
+test('deferred open gets correct options', function (t) {
+  var OPTIONS = { foo: 'BAR' }
+  var db = {
+    open: function (options, callback) {
+      t.same(options, OPTIONS, 'options passed on to open')
+      process.nextTick(callback)
+    }
+  }
+
+  var ld = new DeferredLevelDOWN(db)
+  ld.open(OPTIONS, function (err) {
+    t.error(err, 'no error')
+    t.end()
+  })
+})
+
 test('single operation', function (t) {
   var called = false
   var db = {
-      put: function (key, value, options, callback) {
-        t.equal(key, 'foo', 'correct key')
-        t.equal(value, 'bar', 'correct value')
-        t.deepEqual({}, options, 'empty options')
-        callback('called')
-      }
-    , open: function (options, callback) {
-        process.nextTick(callback)
-      }
+    put: function (key, value, options, callback) {
+      t.equal(key, 'foo', 'correct key')
+      t.equal(value, 'bar', 'correct value')
+      t.deepEqual({}, options, 'empty options')
+      callback(null, 'called')
+    },
+    open: function (options, callback) {
+      process.nextTick(callback)
+    }
   }
 
   var ld = new DeferredLevelDOWN(db)
-  ld.put('foo', 'bar', function (v) {
+  ld.put('foo', 'bar', function (err, v) {
+    t.error(err, 'no error')
     called = v
   })
+
   t.ok(called === false, 'not called')
 
   ld.open(function (err) {
-    t.error(err)
-
+    t.error(err, 'no error')
     t.ok(called === 'called', 'function called')
@@ -35,65 +52,86 @@ t.end()
   var db = {
-      put: function (key, value, options, callback) {
-        if (puts++ === 0) {
-          t.equal(key, 'foo1', 'correct key')
-          t.equal(value, 'bar1', 'correct value')
-          t.deepEqual(options, {}, 'empty options')
-        } else {
-          t.equal(key, 'foo2', 'correct key')
-          t.equal(value, 'bar2', 'correct value')
-          t.deepEqual(options, {}, 'empty options')
-        }
-        callback('put' + puts)
-      }
-    , get: function (key, options, callback) {
-        if (gets++ === 0) {
-          t.equal('woo1', key, 'correct key')
-          t.deepEqual(options, { asBuffer: true }, 'empty options')
-        } else {
-          t.equal('woo2', key, 'correct key')
-          t.deepEqual(options, { asBuffer: true }, 'empty options')
-        }
-        callback('gets' + gets)
-      }
-    , del: function (key, options, callback) {
-        t.equal('blergh', key, 'correct key')
+    put: function (key, value, options, callback) {
+      if (puts++ === 0) {
+        t.equal(key, 'foo1', 'correct key')
+        t.equal(value, 'bar1', 'correct value')
         t.deepEqual(options, {}, 'empty options')
-        callback('del')
+      } else {
+        t.equal(key, 'foo2', 'correct key')
+        t.equal(value, 'bar2', 'correct value')
+        t.deepEqual(options, {}, 'empty options')
       }
-    , batch: function (arr, options, callback) {
-        if (batches++ === 0) {
-          t.deepEqual(arr, [
-              { type: 'put', key: 'k1', value: 'v1' }
-            , { type: 'put', key: 'k2', value: 'v2' }
-          ], 'correct batch')
-        } else {
-          t.deepEqual(arr, [
-              { type: 'put', key: 'k3', value: 'v3' }
-            , { type: 'put', key: 'k4', value: 'v4' }
-          ], 'correct batch')
-        }
-        callback('batches' + batches)
+      callback(null, 'put' + puts)
+    },
+    get: function (key, options, callback) {
+      if (gets++ === 0) {
+        t.equal('woo1', key, 'correct key')
+        t.deepEqual(options, { asBuffer: true }, 'empty options')
+      } else {
+        t.equal('woo2', key, 'correct key')
+        t.deepEqual(options, { asBuffer: true }, 'empty options')
       }
-    , open: function (options, callback) {
-        process.nextTick(callback)
+      callback(null, 'gets' + gets)
+    },
+    del: function (key, options, callback) {
+      t.equal('blergh', key, 'correct key')
+      t.deepEqual(options, {}, 'empty options')
+      callback(null, 'del')
+    },
+    batch: function (arr, options, callback) {
+      if (batches++ === 0) {
+        t.deepEqual(arr, [
+          { type: 'put', key: 'k1', value: 'v1' },
+          { type: 'put', key: 'k2', value: 'v2' }
+        ], 'correct batch')
+      } else {
+        t.deepEqual(arr, [
+          { type: 'put', key: 'k3', value: 'v3' },
+          { type: 'put', key: 'k4', value: 'v4' }
+        ], 'correct batch')
       }
+      callback()
+    },
+    open: function (options, callback) {
+      process.nextTick(callback)
+    }
   }
 
   var ld = new DeferredLevelDOWN(db)
-    , puts    = 0
-    , gets    = 0
-    , batches = 0
+  var puts = 0
+  var gets = 0
+  var batches = 0
 
-  ld.put('foo1', 'bar1', function (v) { calls.push({ type: 'put', key: 'foo1', v: v }) })
-  ld.get('woo1', function (v) { calls.push({ type: 'get', key: 'woo1', v: v }) })
-  ld.put('foo2', 'bar2', function (v) { calls.push({ type: 'put', key: 'foo2', v: v }) })
-  ld.get('woo2', function (v) { calls.push({ type: 'get', key: 'woo2', v: v }) })
-  ld.del('blergh', function (v) { calls.push({ type: 'del', key: 'blergh', v: v }) })
+  ld.put('foo1', 'bar1', function (err, v) {
+    t.error(err, 'no error')
+    calls.push({ type: 'put', key: 'foo1', v: v })
+  })
+  ld.get('woo1', function (err, v) {
+    t.error(err, 'no error')
+    calls.push({ type: 'get', key: 'woo1', v: v })
+  })
+  ld.put('foo2', 'bar2', function (err, v) {
+    t.error(err, 'no error')
+    calls.push({ type: 'put', key: 'foo2', v: v })
+  })
+  ld.get('woo2', function (err, v) {
+    t.error(err, 'no error')
+    calls.push({ type: 'get', key: 'woo2', v: v })
+  })
+  ld.del('blergh', function (err, v) {
+    t.error(err, 'no error')
+    calls.push({ type: 'del', key: 'blergh', v: v })
+  })
   ld.batch([
-      { type: 'put', key: 'k1', value: 'v1' }
-    , { type: 'put', key: 'k2', value: 'v2' }
-   ], function () { calls.push({ type: 'batch', keys: 'k1,k2' }) })
-  ld.batch().put('k3', 'v3').put('k4', 'v4').write(function () {
-    calls.push({ type: 'batch', keys: 'k3,k4' })
+    { type: 'put', key: 'k1', value: 'v1' },
+    { type: 'put', key: 'k2', value: 'v2' }
+  ], function () {
+    calls.push({ type: 'batch', keys: 'k1,k2' })
   })
+  ld
+    .batch()
+    .put('k3', 'v3')
+    .put('k4', 'v4')
+    .write(function () {
+      calls.push({ type: 'batch', keys: 'k3,k4' })
+    })
 
@@ -103,13 +141,13 @@ t.ok(calls.length === 0, 'not called')
   ld.open(function (err) {
-    t.error(err)
+    t.error(err, 'no error')
 
     t.equal(calls.length, 7, 'all functions called')
     t.deepEqual(calls, [
-        { type: 'put', key: 'foo1', v: 'put1' }
-      , { type: 'get', key: 'woo1', v: 'gets1' }
-      , { type: 'put', key: 'foo2', v: 'put2' }
-      , { type: 'get', key: 'woo2', v: 'gets2' }
-      , { type: 'del', key: 'blergh', v: 'del' }
-      , { type: 'batch', keys: 'k1,k2' }
-      , { type: 'batch', keys: 'k3,k4' }
+      { type: 'put', key: 'foo1', v: 'put1' },
+      { type: 'get', key: 'woo1', v: 'gets1' },
+      { type: 'put', key: 'foo2', v: 'put2' },
+      { type: 'get', key: 'woo2', v: 'gets2' },
+      { type: 'del', key: 'blergh', v: 'del' },
+      { type: 'batch', keys: 'k1,k2' },
+      { type: 'batch', keys: 'k3,k4' }
     ], 'calls correctly behaved')
@@ -121,2 +159,82 @@
 
+test('keys and values should not be serialized', function (t) {
+  var DATA = []
+  var ITEMS = [
+    123,
+    'a string',
+    Buffer.from('w00t'),
+    { an: 'object' }
+  ]
+  ITEMS.forEach(function (k) {
+    ITEMS.forEach(function (v) {
+      DATA.push({ key: k, value: v })
+    })
+  })
+
+  function Db (m, fn) {
+    var db = {
+      open: function (options, cb) {
+        process.nextTick(cb)
+      }
+    }
+    var wrapper = function () {
+      fn.apply(null, arguments)
+    }
+    db[m] = wrapper
+    return new DeferredLevelDOWN(db)
+  }
+
+  function noop () {}
+
+  t.test('put', function (t) {
+    var calls = []
+    var ld = Db('put', function (key, value, cb) {
+      calls.push({ key: key, value: value })
+    })
+    DATA.forEach(function (d) { ld.put(d.key, d.value, noop) })
+    ld.open(function (err) {
+      t.error(err, 'no error')
+      t.same(calls, DATA, 'value ok')
+      t.end()
+    })
+  })
+
+  t.test('get', function (t) {
+    var calls = []
+    var ld = Db('get', function (key, cb) { calls.push(key) })
+    ITEMS.forEach(function (key) { ld.get(key, noop) })
+    ld.open(function (err) {
+      t.error(err, 'no error')
+      t.same(calls, ITEMS, 'value ok')
+      t.end()
+    })
+  })
+
+  t.test('del', function (t) {
+    var calls = []
+    var ld = Db('del', function (key, cb) { calls.push(key) })
+    ITEMS.forEach(function (key) { ld.del(key, noop) })
+    ld.open(function (err) {
+      t.error(err, 'no error')
+      t.same(calls, ITEMS, 'value ok')
+      t.end()
+    })
+  })
+
+  t.test('approximateSize', function (t) {
+    var calls = []
+    var ld = Db('approximateSize', function (start, end, cb) {
+      calls.push({ start: start, end: end })
+    })
+    ITEMS.forEach(function (key) { ld.approximateSize(key, key, noop) })
+    ld.open(function (err) {
+      t.error(err, 'no error')
+      t.same(calls, ITEMS.map(function (i) {
+        return { start: i, end: i }
+      }), 'value ok')
+      t.end()
+    })
+  })
+})
+
 test('iterators', function (t) {
@@ -126,15 +244,15 @@ t.plan(8)
   var db = {
-      iterator: function (options) {
-        return {
-            next : function (cb) {
-              cb(null, 'key', 'value')
-            }
-          , end : function (cb) {
-            process.nextTick(cb)
-          }
+    iterator: function (options) {
+      return {
+        next: function (cb) {
+          cb(null, 'key', 'value')
+        },
+        end: function (cb) {
+          process.nextTick(cb)
         }
       }
-    , open: function (options, callback) {
-        process.nextTick(callback)
-      }
+    },
+    open: function (options, callback) {
+      process.nextTick(callback)
+    }
   }
@@ -147,3 +265,3 @@ var ld = new DeferredLevelDOWN(db)
     nextFirst = true
-    t.error(err)
+    t.error(err, 'no error')
     t.equal(key, 'key')
@@ -154,3 +272,3 @@ t.equal(value, 'value')
   it.end(function (err) {
-    t.error(err)
+    t.error(err, 'no error')
     t.ok(nextFirst)
@@ -160,8 +278,5 @@ })
   ld.open(function (err) {
-    t.error(err)
-
+    t.error(err, 'no error')
     var it2 = ld.iterator()
-    it2.end(function (err) {
-      t.error(err)
-    })
+    it2.end(t.error.bind(t))
   })
@@ -171,2 +286,1 @@
 })
-

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

18552

increased by18.31%

Lines of code

343

increased by48.48%

Number of lines in readme file

71

increased by2.9%

Worsened metrics

Dev dependency count

2

increased by100%

No dependency changes