Dependency Update & Lint

Author: moaxaca

.eslintignore

@@ -1 +1 @@
-test/
+node_modules/

.eslintrc

@@ -1,9 +1,13 @@
 {
   "root": true,
-  "extends": [
-    "airbnb"
-  ],
+  "extends": ["eslint:recommended"],
+  "parserOptions": {
+    "ecmaVersion": 8,
+    "sourceType": "script"
+  },
   "env": {
-    "node": true
+    "es6": true,
+    "node": true,
+    "mocha": true
   }
 }

LICENSE.md LICENSE

@@ -1,29 +1,27 @@
-const asyncRedis = require("../src");
+/* eslint no-console: 0 */
+const asyncRedis = require('../src');
+
 const client = asyncRedis.createClient();
 
-client.on("error", function (err) {
-  console.log("Error " + err);
+client.on('error', (err) => {
+  console.log(`Error ${err}`);
 });
 
-let addToSet = async () => {
-  let key = 'exampleSet';
-  let values = [
+const addToSet = async () => {
+  const key = 'exampleSet';
+  const values = [
     'item_1',
     'item_2',
     'item_3',
     'item_4',
     'item_5',
   ];
-  let promises = values.map((value) => {
-    return client.sadd(key, value);
-  });
+  const promises = values.map(value => client.sadd(key, value));
   await Promise.all(promises);
-  return await client.smembers(key);
+  return client.smembers(key);
 };
 
-let flush = async () => {
-  return await client.flushall();
-};
+const flush = async () => client.flushall();
 
 addToSet()
   .then((results) => {

examples/create-redis.js

@@ -1,54 +1,51 @@
 {
   "private": false,
-  "version": "1.1.7",
+  "author": "Matthew Oaxaca",
+  "license": "MIT",
+  "version": "1.1.8",
   "name": "async-redis",
   "keywords": [
     "redis",
     "async",
     "promise",
     "es6"
   ],
-  "author": "Matthew Oaxaca",
-  "license": "MIT",
   "description": "Light wrapper over redis_node with first class async & promise support.",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/moaxaca/async-redis.git"
+  },
+  "bugs": {
+    "url": "https://github.com/moaxaca/async-redis/issues"
+  },
   "main": "src/index.js",
-  "typings": "./index.d.ts",
+  "typings": "src/index.d.ts",
   "engines": {
     "node": ">=7.6.0"
   },
+  "directories": {
+    "example": "examples",
+    "test": "test"
+  },
   "scripts": {
     "coveralls": "nyc yarn test && nyc report --reporter=text-lcov | coveralls",
-    "lint": "eslint --fix --ext .js, src",
+    "lint": "eslint --fix --ext .js, .",
     "test": "mocha",
+    "test:unit": "mocha",
     "version:patch": "npm version patch",
     "version:minor": "npm version minor",
     "version:major": "npm version major"
   },
   "dependencies": {
-    "redis": "^3.0.0",
-    "redis-commands": "^1.3.1"
+    "redis": "^3.0.2",
+    "redis-commands": "^1.6.0"
   },
   "devDependencies": {
-    "chai": "^3.5.0",
+    "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
-    "coveralls": "^3.0.0",
-    "eslint": "^4.17.0",
-    "eslint-config-airbnb": "^16.1.0",
-    "eslint-plugin-import": "^2.8.0",
-    "eslint-plugin-jsx-a11y": "^6.0.3",
-    "eslint-plugin-react": "^7.6.1",
-    "mocha": "^3.2.0",
-    "nyc": "^11.4.1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/moaxaca/async-redis.git"
-  },
-  "bugs": {
-    "url": "https://github.com/moaxaca/async-redis/issues"
-  },
-  "directories": {
-    "example": "examples",
-    "test": "test"
+    "coveralls": "^3.1.0",
+    "eslint": "^7.6.0",
+    "mocha": "^8.1.0",
+    "nyc": "^15.1.0"
   }
 }

package.json

@@ -1,5 +1,3 @@
-/* eslint func-names: ["error", "as-needed"] */
-
 const redis = require('redis');
 const commands = require('redis-commands').list;
 const objectDecorator = require('./object-decorator');
@@ -11,13 +9,9 @@ const AsyncRedis = function (args) {
 
 AsyncRedis.createClient = (...args) => new AsyncRedis(args);
 
-// this is the set of commands to NOT promisify
 const commandsToSkipSet = new Set(['multi']);
-// this is the set of commands to promisify
 const commandSet = new Set(commands.filter(c => !commandsToSkipSet.has(c)));
-// this is the set of commands that return a Multi
 const queueCommandSet = new Set(['batch', 'multi']);
-// this is the set of Multi commands to promisify
 const multiCommandSet = new Set(['exec', 'exec_atomic']);
 
 const promisify = function (object, method) {
@@ -31,16 +25,13 @@ const promisify = function (object, method) {
     });
     method.apply(object, args);
   });
-}
+};
 
 AsyncRedis.decorate = redisClient => objectDecorator(redisClient, (name, method) => {
-  const asyncClient = Object.create(redisClient);
-  
   if (commandSet.has(name)) {
     return promisify(redisClient, method);
   } else if (queueCommandSet.has(name)) {
     return (...args) => {
-      // Decorate the Multi object
       const multi = method.apply(redisClient, args);
       return objectDecorator(multi, (multiName, multiMethod) => {
         if (multiCommandSet.has(multiName)) {

src/index.js

@@ -1,33 +1,33 @@
 const { assert } = require('chai');
 const AsyncRedis = require('../../../src');
 
-describe('Commands - Common', function () {
+describe('Commands - Common', () => {
   let redisClient;
 
-  beforeEach(async() => {
+  beforeEach(async () => {
     redisClient = new AsyncRedis();
   });
 
-  afterEach(async() => {
+  afterEach(async () => {
     redisClient.flushall();
   });
 
-  describe('test set method', function () {
+  describe('test set method', () => {
     it('should return ok', async () => {
-      let status = await redisClient.set('hello', 'world');
+      const status = await redisClient.set('hello', 'world');
       assert.equal(status, 'OK');
     });
   });
 
-  describe('test get method', function () {
+  describe('test get method', () => {
     it('should return value', async () => {
       await redisClient.set('hello', 'world');
       const value = await redisClient.get('hello');
       assert.equal(value, 'world');
     });
   });
 
-  describe('test del method', function () {
+  describe('test del method', () => {
     it('should return true', async () => {
       await redisClient.set('hello', 'world');
       const status = await redisClient.del('hello');
@@ -40,25 +40,24 @@ describe('Commands - Common', function () {
     });
   });
 
-  describe('test del method', function () {
+  describe('test del method', () => {
     it('should return true', async () => {
       await redisClient.set('hello', 'world');
       const status = await redisClient.del('hello');
       assert.equal(status, true);
     });
   });
 
-  describe('test rejection', function () {
+  describe('test rejection', () => {
     it('should reject promise on throw', async () => {
-      let promise = redisClient.set('hello');
+      const promise = redisClient.set('hello');
       assert.isRejected(promise, Error);
     });
   });
 
-  describe('test multi not a promise', function () {
+  describe('test multi not a promise', () => {
     it('should be not equal', async () => {
-      let notAPromise = redisClient.multi();
-      console.log(notAPromise);
+      const notAPromise = redisClient.multi();
       assert.notEqual(Promise.resolve(notAPromise), notAPromise);
     });
   });

test/integration/commands/common.spec.js

@@ -2,7 +2,7 @@ const { assert } = require('chai');
 const { RedisClient } = require('redis');
 const AsyncRedis = require('../../src');
 
-describe('AsyncRedis.createClient', function () {
+describe('AsyncRedis.createClient', () => {
   const options = {
     host: '127.0.0.1',
     port: 6379,

test/integration/create-client.spec.js

@@ -3,13 +3,13 @@ const redis = require('redis');
 const redisCommands = require('redis-commands');
 const AsyncRedis = require('../../src');
 
-describe('AsyncRedis.decorate', function () {
+describe('AsyncRedis.decorate', () => {
   const client = redis.createClient();
   const asyncRedisClient = AsyncRedis.decorate(client);
 
   it('should have decorated every command', async () => {
     const commands = redisCommands.list;
-    commands.forEach(command => {
+    commands.forEach((command) => {
       assert.isFunction(asyncRedisClient[command], `redis.${command} isn't decorated`);
     });
   });

test/integration/decorate-redis.spec.js

@@ -1,37 +1,29 @@
-"use strict";
-
 const { assert } = require('chai');
 const objectDecorator = require('../../src/object-decorator');
 
-const Mock = function () {
-  this.add = function(a, b) {
-    return a + b;
-  };
-  this.subtract = function(a, b) {
-    return a - b;
-  };
+const Mock = () => {
+  this.add = (a, b) => a + b;
+  this.subtract = (a, b) => a - b;
 };
 
-describe('Object Decorator', function () {
+describe('Object Decorator', () => {
   it('should decorate a method', async () => {
-    let mock = new Mock();
-    let mockTwo = new Mock();
+    const mock = new Mock();
+    const mockTwo = new Mock();
     objectDecorator(mock, (name, method) => {
-      switch(name) {
+      switch (name) {
         case 'add':
           return (...args) => {
-            let a = args[0] + 1;
-            let b  = args[1] + 1;
+            const a = args[0] + 1;
+            const b = args[1] + 1;
             return method(a, b);
           };
-          break;
         case 'subtract':
           return (...args) => {
-            let a = args[0];
-            let b  = args[1] + 1;
+            const a = args[0];
+            const b = args[1] + 1;
             return method(a, b);
           };
-          break;
         default:
           return method;
       }