Add eslint and use ES6

.eslintrc.js

@@ -0,0 +1,15 @@
+module.exports = {
+  env: {
+    node: true,
+    mocha: true,
+  },
+  extends: [
+    'airbnb-base',
+  ],
+  rules: {
+    'func-names': 0,
+    'no-use-before-define': 0,
+    'no-plusplus': 0,
+    'strict': 0,
+  },
+}

config/base.js

@@ -35,5 +35,5 @@ module.exports = {
     'ember/use-ember-get-and-set': 1,
     'ember/avoid-leaking-state-in-components': 2,
     'ember/use-brace-expansion': 1,
-  }
+  },
 };

config/recommended.js

@@ -12,6 +12,6 @@ module.exports = {
     'prefer-arrow-callback': 0,
     'prefer-rest-params': 0,
     'consistent-return': 0,
-    'generator-star-spacing': [2, "after"],
-  }
+    'generator-star-spacing': [2, 'after'],
+  },
 };

index.js

@@ -1,19 +1,20 @@
 'use strict';
 
-var resolve = require('path').resolve;
-var requireIndex = require('requireindex');
+const resolve = require('path').resolve;
+const requireIndex = require('requireindex');
 
-var rules = requireIndex(resolve(__dirname, 'lib/rules'));
-var configs = requireIndex(resolve(__dirname, 'config'));
+const rules = requireIndex(resolve(__dirname, 'lib/rules'));
+const configs = requireIndex(resolve(__dirname, 'config'));
 
-var ember = require(resolve(__dirname, 'lib/utils/ember'));
-var utils = require(resolve(__dirname, 'lib/utils/utils'));
+/* eslint-disable import/no-dynamic-require */
+const ember = require(resolve(__dirname, 'lib/utils/ember'));
+const utils = require(resolve(__dirname, 'lib/utils/utils'));
 
 module.exports = {
-  rules: rules,
-  configs: configs,
+  rules,
+  configs,
   utils: {
-    ember: ember,
-    utils: utils
-  }
+    ember,
+    utils,
+  },
 };

lib/rules/alias-model-in-controller.js

@@ -1,31 +1,29 @@
 'use strict';
 
-var utils = require('../utils/utils');
-var ember = require('../utils/ember');
+const utils = require('../utils/utils');
+const ember = require('../utils/ember');
 
 //------------------------------------------------------------------------------
 // Controllers - Alias your model
 //------------------------------------------------------------------------------
 
-module.exports = function(context) {
+module.exports = function (context) {
+  const message = 'Alias your model';
 
-  var message = 'Alias your model';
-
-  var report = function(node) {
+  const report = function (node) {
     context.report(node, message);
   };
 
   return {
-    CallExpression: function(node) {
+    CallExpression(node) {
       if (!ember.isEmberController(node)) return;
 
-      var callee = node.callee;
-      var properties = ember.getModuleProperties(node);
-      var aliasPresent = false;
+      const properties = ember.getModuleProperties(node);
+      let aliasPresent = false;
 
-      properties.forEach(function(property) {
-        var parsedCallee = utils.parseCallee(property.value);
-        var parsedArgs = utils.parseArgs(property.value);
+      properties.forEach((property) => {
+        const parsedCallee = utils.parseCallee(property.value);
+        const parsedArgs = utils.parseArgs(property.value);
 
         if (
           parsedCallee.length &&
@@ -38,9 +36,8 @@ module.exports = function(context) {
 
 
       if (!aliasPresent) {
-        report(node)
+        report(node);
       }
-    }
+    },
   };
-
 };

lib/rules/avoid-leaking-state-in-components.js

@@ -1,7 +1,6 @@
 'use strict';
 
-var utils = require('../utils/utils');
-var ember = require('../utils/ember');
+const ember = require('../utils/ember');
 
 //------------------------------------------------------------------------------
 // Components rule - Avoid leaking state
@@ -11,20 +10,20 @@ var ember = require('../utils/ember');
 module.exports = {
   meta: {
     schema: [{
-      type: "array",
-      items: { type: "string" },
+      type: 'array',
+      items: { type: 'string' },
     }],
   },
 
-  create: function(context) {
-    var ignoredProperties = context.options[0] || [];
+  create(context) {
+    let ignoredProperties = context.options[0] || [];
 
-    var message = {
+    const message = {
       array: 'Avoid using arrays as default properties',
       object: 'Avoid using objects as default properties',
     };
 
-    var report = function(node, messageType) {
+    const report = function (node, messageType) {
       context.report(node, message[messageType]);
     };
 
@@ -39,23 +38,21 @@ module.exports = {
     ]);
 
     return {
-      CallExpression: function(node) {
+      CallExpression(node) {
         if (!ember.isEmberComponent(node)) return;
 
-        var properties = ember.getModuleProperties(node);
+        const properties = ember.getModuleProperties(node);
 
         properties
-          .filter(function(property) {
-            return ignoredProperties.indexOf(property.key.name) === -1;
-          })
-          .forEach(function(property) {
+          .filter(property => ignoredProperties.indexOf(property.key.name) === -1)
+          .forEach((property) => {
             if (ember.isObjectProp(property)) {
               report(property, 'object');
             } else if (ember.isArrayProp(property)) {
               report(property, 'array');
             }
           });
-      }
+      },
     };
   },
 };

lib/rules/closure-actions.js

@@ -1,29 +1,27 @@
 'use strict';
 
-var utils = require('../utils/utils');
+const utils = require('../utils/utils');
 
 //------------------------------------------------------------------------------
 // Components - Closure actions
 //------------------------------------------------------------------------------
 
-module.exports = function(context) {
+module.exports = function (context) {
+  const message = 'Use closure actions, unless you need bubbling';
 
-  var message = 'Use closure actions, unless you need bubbling';
-
-  var report = function(node) {
+  const report = function (node) {
     context.report(node, message);
   };
 
   return {
-    MemberExpression: function(node) {
-      var isSendAction = utils.isThisExpression(node.object) &&
+    MemberExpression(node) {
+      const isSendAction = utils.isThisExpression(node.object) &&
         utils.isIdentifier(node.property) &&
         node.property.name === 'sendAction';
 
       if (isSendAction) {
         report(node);
       }
-    }
+    },
   };
-
 };

lib/rules/jquery-ember-run.js

@@ -1,54 +1,52 @@
 'use strict';
 
-var utils = require('../utils/utils');
-var ember = require('../utils/ember');
+const utils = require('../utils/utils');
+const ember = require('../utils/ember');
 
 //------------------------------------------------------------------------------
 // General rule - Don’t use jQuery without Ember Run Loop
 //------------------------------------------------------------------------------
 
-module.exports = function(context) {
+module.exports = function (context) {
+  const message = 'Don\'t use jQuery without Ember Run Loop';
 
-  var message = 'Don\'t use jQuery without Ember Run Loop';
-
-  var report = function(node) {
+  const report = function (node) {
     context.report(node, message);
   };
 
-  var isJqueryUsed = function(node) {
+  const isJqueryUsed = function (node) {
     return utils.isMemberExpression(node) &&
       utils.isCallExpression(node.object) &&
       ember.isModule(node.object, '$');
   };
 
-  var isRunUsed = function(node) {
+  const isRunUsed = function (node) {
     return ember.isModule(node, 'run');
   };
 
   return {
-    CallExpression: function(node) {
-      var callee = node.callee;
-      var fnNodes = utils.findNodes(node.arguments, 'ArrowFunctionExpression');
+    CallExpression(node) {
+      const callee = node.callee;
+      const fnNodes = utils.findNodes(node.arguments, 'ArrowFunctionExpression');
 
       if (isJqueryUsed(callee) && fnNodes.length) {
-        fnNodes.forEach(function(fnNode) {
-          var fnBody = fnNode.body.body;
-          var fnExpressions = utils.findNodes(fnBody, 'ExpressionStatement');
+        fnNodes.forEach((fnNode) => {
+          const fnBody = fnNode.body.body;
+          const fnExpressions = utils.findNodes(fnBody, 'ExpressionStatement');
 
-          fnExpressions.forEach(function(fnExpression) {
-            fnExpression = fnExpression.expression;
+          fnExpressions.forEach((fnExpression) => {
+            const expression = fnExpression.expression;
 
             if (
-              utils.isCallExpression(fnExpression) &&
-              utils.isMemberExpression(fnExpression.callee) &&
-              !isRunUsed(fnExpression)
+              utils.isCallExpression(expression) &&
+              utils.isMemberExpression(expression.callee) &&
+              !isRunUsed(expression)
             ) {
-              report(fnExpression.callee);
+              report(expression.callee);
             }
           });
         });
       }
-    }
+    },
   };
-
 };

lib/rules/local-modules.js

@@ -1,33 +1,32 @@
 'use strict';
 
-var utils = require('../utils/utils');
+const utils = require('../utils/utils');
 
 //------------------------------------------------------------------------------
 // General rule - Create local version of Ember.* and DS.*
 //------------------------------------------------------------------------------
 
-module.exports = function(context) {
+module.exports = function (context) {
+  const message = 'Create local version of ';
 
-  var message = 'Create local version of ';
-
-  var report = function(node, name) {
-    var msg = message + name + '.' + node.property.name;
+  const report = function (node, name) {
+    const msg = `${message + name}.${node.property.name}`;
     context.report(node, msg);
   };
 
-  var allowedEmberProperties = ['$', 'Object', 'Router', 'String'];
-  var allowedDSProperties = [];
+  const allowedEmberProperties = ['$', 'Object', 'Router', 'String'];
+  const allowedDSProperties = [];
 
-  var isExpressionForbidden = function (objectName, node, allowedProperties) {
+  const isExpressionForbidden = function (objectName, node, allowedProperties) {
     return node.object.name === objectName &&
       node.property.name.length &&
       allowedProperties.indexOf(node.property.name) === -1;
   };
 
   return {
-    CallExpression: function(node) {
-      var callee = node.callee;
-      var obj = utils.isMemberExpression(callee.object) ? callee.object : callee;
+    CallExpression(node) {
+      const callee = node.callee;
+      const obj = utils.isMemberExpression(callee.object) ? callee.object : callee;
 
       if (
         utils.isIdentifier(obj.object) &&
@@ -41,7 +40,6 @@ module.exports = function(context) {
           report(obj, 'DS');
         }
       }
-    }
+    },
   };
-
 };

lib/rules/named-functions-in-promises.js

@@ -1,22 +1,21 @@
 'use strict';
 
-var utils = require('../utils/utils');
+const utils = require('../utils/utils');
 
 //------------------------------------------------------------------------------
 // General rule - Use named functions defined on objects to handle promises
 //------------------------------------------------------------------------------
 
-module.exports = function(context) {
+module.exports = function (context) {
+  const message = 'Use named functions defined on objects to handle promises';
 
-  var message = 'Use named functions defined on objects to handle promises';
-
-  var report = function(node) {
+  const report = function (node) {
     context.report(node, message);
   };
 
   return {
-    CallExpression: function(node) {
-      var firstArg = node.arguments[0];
+    CallExpression(node) {
+      const firstArg = node.arguments[0];
 
       if (
         hasPromiseExpression(node) &&
@@ -27,12 +26,12 @@ module.exports = function(context) {
       ) {
         report(node);
       }
-    }
+    },
   };
 
   function hasPromiseExpression(node) {
-    var callee = node.callee;
-    var promisesMethods = ['then', 'catch', 'finally'];
+    const callee = node.callee;
+    const promisesMethods = ['then', 'catch', 'finally'];
 
     return utils.isCallExpression(callee.object) &&
       utils.isIdentifier(callee.property) &&