Breaking: modernize syntax and bump standard (Level/community#98)

.github/dependabot.yml

@@ -7,9 +7,7 @@ updates:
     ignore:
       - dependency-name: dependency-check
       - dependency-name: sinon
-      - dependency-name: airtap
       - dependency-name: nyc
-      - dependency-name: standard
 
       # Pinned to 1.1.10 for browser compatibility (later versions depend
       # on `queue-microtask` which uses arrow functions and promises).

lib/batch.js

@@ -1,7 +1,9 @@
-var WriteError = require('level-errors').WriteError
-var catering = require('catering')
-var getCallback = require('./common').getCallback
-var getOptions = require('./common').getOptions
+'use strict'
+
+const WriteError = require('level-errors').WriteError
+const catering = require('catering')
+const getCallback = require('./common').getCallback
+const getOptions = require('./common').getOptions
 
 function Batch (levelup) {
   // TODO (next major): remove this._levelup alias
@@ -18,7 +20,7 @@ Batch.prototype.put = function (key, value) {
     throw new WriteError(e)
   }
 
-  this.ops.push({ type: 'put', key: key, value: value })
+  this.ops.push({ type: 'put', key, value })
   this.length++
 
   return this
@@ -31,7 +33,7 @@ Batch.prototype.del = function (key) {
     throw new WriteError(err)
   }
 
-  this.ops.push({ type: 'del', key: key })
+  this.ops.push({ type: 'del', key })
   this.length++
 
   return this
@@ -51,8 +53,8 @@ Batch.prototype.clear = function () {
 }
 
 Batch.prototype.write = function (options, callback) {
-  var levelup = this._levelup
-  var ops = this.ops
+  const levelup = this._levelup
+  const ops = this.ops
 
   callback = getCallback(options, callback)
   callback = catering.fromCallback(callback)

lib/common.js

@@ -1,3 +1,5 @@
+'use strict'
+
 exports.getCallback = function (options, callback) {
   return typeof options === 'function' ? options : callback
 }

lib/levelup.js

@@ -1,21 +1,23 @@
-var EventEmitter = require('events').EventEmitter
-var inherits = require('util').inherits
-var extend = require('xtend')
-var DeferredLevelDOWN = require('deferred-leveldown')
-var IteratorStream = require('level-iterator-stream')
-var Batch = require('./batch')
-var errors = require('level-errors')
-var supports = require('level-supports')
-var assert = require('assert')
-var catering = require('catering')
-var getCallback = require('./common').getCallback
-var getOptions = require('./common').getOptions
-
-var WriteError = errors.WriteError
-var ReadError = errors.ReadError
-var NotFoundError = errors.NotFoundError
-var OpenError = errors.OpenError
-var InitializationError = errors.InitializationError
+'use strict'
+
+const EventEmitter = require('events').EventEmitter
+const inherits = require('util').inherits
+const extend = require('xtend')
+const DeferredLevelDOWN = require('deferred-leveldown')
+const IteratorStream = require('level-iterator-stream')
+const Batch = require('./batch')
+const errors = require('level-errors')
+const supports = require('level-supports')
+const assert = require('assert')
+const catering = require('catering')
+const getCallback = require('./common').getCallback
+const getOptions = require('./common').getOptions
+
+const WriteError = errors.WriteError
+const ReadError = errors.ReadError
+const NotFoundError = errors.NotFoundError
+const OpenError = errors.OpenError
+const InitializationError = errors.InitializationError
 
 // Possible AbstractLevelDOWN#status values:
 //  - 'new'     - newly created, not opened or closed
@@ -30,8 +32,7 @@ function LevelUP (db, options, callback) {
     return new LevelUP(db, options, callback)
   }
 
-  var error
-  var self = this
+  let error
 
   EventEmitter.call(this)
   this.setMaxListeners(Infinity)
@@ -56,9 +57,9 @@ function LevelUP (db, options, callback) {
   this.options = getOptions(options)
   this._db = db
   this.db = new DeferredLevelDOWN(db)
-  this.open(callback || function (err) {
-    if (err) self.emit('error', err)
-  })
+  this.open(callback || ((err) => {
+    if (err) this.emit('error', err)
+  }))
 
   // Create manifest based on deferred-leveldown's
   this.supports = supports(this.db.supports, {
@@ -70,23 +71,21 @@ function LevelUP (db, options, callback) {
   })
 
   // Experimental: enrich levelup interface
-  Object.keys(this.supports.additionalMethods).forEach(function (method) {
-    if (this[method] != null) return
+  for (const method of Object.keys(this.supports.additionalMethods)) {
+    if (this[method] != null) continue
 
     // Don't do this.db[method].bind() because this.db is dynamic.
-    this[method] = function () {
-      return this.db[method].apply(this.db, arguments)
+    this[method] = function (...args) {
+      return this.db[method](...args)
     }
-  }, this)
+  }
 }
 
 LevelUP.prototype.emit = EventEmitter.prototype.emit
 LevelUP.prototype.once = EventEmitter.prototype.once
 inherits(LevelUP, EventEmitter)
 
 LevelUP.prototype.open = function (opts, callback) {
-  var self = this
-
   if (typeof opts === 'function') {
     callback = opts
     opts = null
@@ -99,39 +98,37 @@ LevelUP.prototype.open = function (opts, callback) {
   }
 
   if (this.isOpen()) {
-    process.nextTick(callback, null, self)
+    process.nextTick(callback, null, this)
     return callback.promise
   }
 
   if (this._isOpening()) {
-    this.once('open', function () { callback(null, self) })
+    this.once('open', () => { callback(null, this) })
     return callback.promise
   }
 
   this.emit('opening')
 
-  this.db.open(opts, function (err) {
+  this.db.open(opts, (err) => {
     if (err) {
       return callback(new OpenError(err))
     }
-    self.db = self._db
-    callback(null, self)
-    self.emit('open')
-    self.emit('ready')
+    this.db = this._db
+    callback(null, this)
+    this.emit('open')
+    this.emit('ready')
   })
 
   return callback.promise
 }
 
 LevelUP.prototype.close = function (callback) {
-  var self = this
-
   callback = catering.fromCallback(callback)
 
   if (this.isOpen()) {
-    this.db.close(function () {
-      self.emit('closed')
-      callback.apply(null, arguments)
+    this.db.close((err, ...rest) => {
+      this.emit('closed')
+      callback(err, ...rest)
     })
     this.emit('closing')
     this.db = new DeferredLevelDOWN(this._db)
@@ -140,8 +137,8 @@ LevelUP.prototype.close = function (callback) {
   } else if (this.db.status === 'closing') {
     this.once('closed', callback)
   } else if (this._isOpening()) {
-    this.once('open', function () {
-      self.close(callback)
+    this.once('open', () => {
+      this.close(callback)
     })
   }
 
@@ -186,8 +183,6 @@ LevelUP.prototype.get = function (key, options, callback) {
 }
 
 LevelUP.prototype.put = function (key, value, options, callback) {
-  var self = this
-
   callback = getCallback(options, callback)
   callback = catering.fromCallback(callback)
 
@@ -197,20 +192,18 @@ LevelUP.prototype.put = function (key, value, options, callback) {
 
   options = getOptions(options)
 
-  this.db.put(key, value, options, function (err) {
+  this.db.put(key, value, options, (err) => {
     if (err) {
       return callback(new WriteError(err))
     }
-    self.emit('put', key, value)
+    this.emit('put', key, value)
     callback()
   })
 
   return callback.promise
 }
 
 LevelUP.prototype.del = function (key, options, callback) {
-  var self = this
-
   callback = getCallback(options, callback)
   callback = catering.fromCallback(callback)
 
@@ -220,11 +213,11 @@ LevelUP.prototype.del = function (key, options, callback) {
 
   options = getOptions(options)
 
-  this.db.del(key, options, function (err) {
+  this.db.del(key, options, (err) => {
     if (err) {
       return callback(new WriteError(err))
     }
-    self.emit('del', key)
+    this.emit('del', key)
     callback()
   })
 
@@ -236,8 +229,6 @@ LevelUP.prototype.batch = function (arr, options, callback) {
     return new Batch(this)
   }
 
-  var self = this
-
   if (typeof arr === 'function') callback = arr
   else callback = getCallback(options, callback)
 
@@ -249,11 +240,11 @@ LevelUP.prototype.batch = function (arr, options, callback) {
 
   options = getOptions(options)
 
-  this.db.batch(arr, options, function (err) {
+  this.db.batch(arr, options, (err) => {
     if (err) {
       return callback(new WriteError(err))
     }
-    self.emit('batch', arr)
+    this.emit('batch', arr)
     callback()
   })
 
@@ -265,8 +256,6 @@ LevelUP.prototype.iterator = function (options) {
 }
 
 LevelUP.prototype.clear = function (options, callback) {
-  var self = this
-
   callback = getCallback(options, callback)
   options = getOptions(options)
   callback = catering.fromCallback(callback)
@@ -275,11 +264,11 @@ LevelUP.prototype.clear = function (options, callback) {
     return callback.promise
   }
 
-  this.db.clear(options, function (err) {
+  this.db.clear(options, (err) => {
     if (err) {
       return callback(new WriteError(err))
     }
-    self.emit('clear', options)
+    this.emit('clear', options)
     callback()
   })
 

package.json

@@ -45,7 +45,7 @@
     "safe-buffer": "^5.1.0",
     "simple-concat": "^1.0.0",
     "sinon": "^7.4.2",
-    "standard": "^15.0.0",
+    "standard": "^16.0.3",
     "tape": "^5.2.2",
     "trickle": "0.0.2"
   },

test/batch-test.js

@@ -1,8 +1,8 @@
-var levelup = require('../lib/levelup')
-var errors = levelup.errors
-var each = require('async-each')
-var series = require('run-series')
-var discardable = require('./util/discardable')
+const levelup = require('../lib/levelup')
+const errors = levelup.errors
+const each = require('async-each')
+const series = require('run-series')
+const discardable = require('./util/discardable')
 
 module.exports = function (test, testCommon) {
   test('array-form batch(): multiple puts', function (t) {
@@ -124,11 +124,11 @@ module.exports = function (test, testCommon) {
 
   test('chained batch(): options', function (t) {
     discardable(t, testCommon, function (db, done) {
-      var batch = db.batch()
-      var underlying = batch
+      const batch = db.batch()
+      let underlying = batch
       while (underlying.batch) underlying = underlying.batch
 
-      var write = underlying.write.bind(underlying)
+      const write = underlying.write.bind(underlying)
       underlying.write = function (options, cb) {
         t.same(options, { foo: 'bar' })
         write(options, cb)
@@ -144,9 +144,9 @@ module.exports = function (test, testCommon) {
 
   testCommon.promises && test('chained batch(): promise interface - options', function (t) {
     discardable(t, testCommon, function (db, done) {
-      var batch = db.batch()
+      const batch = db.batch()
 
-      var write = batch.batch.write.bind(batch.batch)
+      const write = batch.batch.write.bind(batch.batch)
       batch.batch.write = function (options, cb) {
         t.same(options, { foo: 'bar' })
         write(options, cb)
@@ -194,7 +194,7 @@ module.exports = function (test, testCommon) {
 
   test('chained batch(): exposes ops queue length', function (t) {
     discardable(t, testCommon, function (db, done) {
-      var batch = db.batch()
+      const batch = db.batch()
         .put('one', '1')
         .del('two')
         .put('three', '3')
@@ -288,7 +288,7 @@ module.exports = function (test, testCommon) {
 
   test('chained batch() arguments', function (t) {
     discardable(t, testCommon, function (db, done) {
-      var batch = db.batch()
+      const batch = db.batch()
 
       t.test('chained batch() arguments: batch#put() with missing `value`', function (t) {
         throws(t, batch.put.bind(batch, 'foo1'), function (err) {
@@ -360,7 +360,7 @@ module.exports = function (test, testCommon) {
         t.is(err.message, 'write() already called on this batch')
       }
 
-      var batch = db.batch()
+      const batch = db.batch()
       batch.put('foo', 'bar').put('boom', 'bang').del('foo').write(function (err) {
         t.ifError(err, 'no batch error')