Merge pull request #61 from rwjblue/linting

Add linting!

Author: rwjblue

.eslintignore

@@ -0,0 +1 @@
+/fixtures/

.eslintrc.js

@@ -0,0 +1,23 @@
+module.exports = {
+  root: true,
+  extends: ['eslint:recommended', 'prettier', 'plugin:node/recommended'],
+  plugins: ['prettier', 'node'],
+  parserOptions: {
+    ecmaVersion: 2017,
+  },
+  env: {
+    node: true,
+  },
+  rules: {
+    'prettier/prettier': 'error',
+  },
+
+  overrides: [
+    {
+      files: ['tests/**/*.js'],
+      env: {
+        jest: true
+      }
+    }
+  ]
+};

.prettierrc

@@ -0,0 +1,5 @@
+{
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "printWidth": 100
+}

.travis.yml

@@ -3,9 +3,11 @@ language: node_js
 node_js:
   - '4'
   - '6'
-  - '7'
+  - '8'
+  - '10'
 
 cache: yarn
 
 script:
+  - yarn eslint .
   - yarn test --coverage

package.json

@@ -4,7 +4,12 @@
     "@babel/preset-env": "^7.0.0-beta.42",
     "babel-core": "^6.26.0",
     "babel-preset-env": "^1.6.1",
-    "jest": "^21.0.0"
+    "eslint": "^4.19.1",
+    "eslint-config-prettier": "^2.9.0",
+    "eslint-plugin-node": "^6.0.1",
+    "eslint-plugin-prettier": "^2.6.0",
+    "jest": "^21.0.0",
+    "prettier": "^1.12.1"
   },
   "name": "babel-plugin-debug-macros",
   "version": "0.2.0-beta.2",
@@ -41,5 +46,8 @@
     "testMatch": [
       "<rootDir>/tests/**/*-test.js"
     ]
+  },
+  "engines": {
+    "node": ">=4"
   }
 }

src/index.js

@@ -7,54 +7,49 @@ const normalizeOptions = require('./utils/normalize-options').normalizeOptions;
 function macros(babel) {
   const t = babel.types;
 
-  let macroBuilder;
   let options;
 
   return {
-    name: "babel-feature-flags-and-debug-macros",
+    name: 'babel-feature-flags-and-debug-macros',
     visitor: {
-
       Program: {
         enter(path, state) {
           options = normalizeOptions(state.opts);
           this.macroBuilder = new Macros(t, options);
 
           let body = path.get('body');
 
-          body.forEach((item) => {
+          body.forEach(item => {
             if (item.isImportDeclaration()) {
               let importPath = item.node.source.value;
 
-              let featureSources = options.featureSources;
               let debugToolsImport = options.debugTools.debugToolsImport;
               let envFlagsImport = options.envFlags.envFlagsImport;
 
-              let isFeaturesImport = featureSources.indexOf(importPath) > -1;
-
               if (debugToolsImport && debugToolsImport === importPath) {
                 this.macroBuilder.collectDebugToolsSpecifiers(item.get('specifiers'));
-              } if (envFlagsImport && envFlagsImport === importPath) {
+              }
+              if (envFlagsImport && envFlagsImport === importPath) {
                 this.macroBuilder.collectEnvFlagSpecifiers(item.get('specifiers'));
               }
             }
           });
-
         },
 
         exit(path) {
           this.macroBuilder.expand(path);
-        }
+        },
       },
 
       ExpressionStatement(path) {
         this.macroBuilder.build(path);
-      }
-    }
+      },
+    },
   };
 }
 
 macros.baseDir = function() {
   return path.dirname(__dirname);
-}
+};
 
 module.exports = macros;

src/utils/builder.js

@@ -35,7 +35,7 @@ module.exports = class Builder {
     }
 
     this._createMacroExpression(path, {
-      predicate
+      predicate,
     });
   }
 
@@ -104,7 +104,6 @@ module.exports = class Builder {
       callExpression = this._createConsoleAPI(options.consoleAPI || callee, args);
     }
 
-    let identifiers = this._getIdentifiers(args);
     let prefixedIdentifiers = [];
 
     if (options.predicate) {
@@ -113,7 +112,10 @@ module.exports = class Builder {
       prefixedIdentifiers.push(negatedPredicate);
     }
 
-    this.expressions.push([path, this._buildLogicalExpressions(prefixedIdentifiers, callExpression)]);
+    this.expressions.push([
+      path,
+      this._buildLogicalExpressions(prefixedIdentifiers, callExpression),
+    ]);
   }
 
   /**
@@ -154,14 +156,14 @@ module.exports = class Builder {
       validate: (expression, args) => {
         let meta = args[2];
 
-        if (meta && meta.properties && !meta.properties.some( prop =>  prop.key.name === 'id')) {
+        if (meta && meta.properties && !meta.properties.some(prop => prop.key.name === 'id')) {
           throw new ReferenceError(`deprecate's meta information requires an "id" field.`);
         }
 
-        if (meta && meta.properties && !meta.properties.some(prop =>  prop.key.name === 'until')) {
+        if (meta && meta.properties && !meta.properties.some(prop => prop.key.name === 'until')) {
           throw new ReferenceError(`deprecate's meta information requires an "until" field.`);
         }
-      }
+      },
     });
   }
 
@@ -180,7 +182,7 @@ module.exports = class Builder {
   }
 
   _getIdentifiers(args) {
-    return args.filter((arg) => this.t.isIdentifier(arg));
+    return args.filter(arg => this.t.isIdentifier(arg));
   }
 
   _createGlobalExternalHelper(identifier, args, ns) {
@@ -196,22 +198,22 @@ module.exports = class Builder {
   _buildLogicalExpressions(identifiers, callExpression) {
     let t = this.t;
 
-    return (debugIdentifier) => {
+    return debugIdentifier => {
       identifiers.unshift(debugIdentifier);
       identifiers.push(callExpression);
       let logicalExpressions;
 
-        for (let i = 0; i < identifiers.length; i++) {
-          let left = identifiers[i];
-          let right = identifiers[i + 1];
-          if (!logicalExpressions) {
-            logicalExpressions = t.logicalExpression('&&', left, right);
-          } else if (right) {
-            logicalExpressions = t.logicalExpression('&&', logicalExpressions, right)
-          }
+      for (let i = 0; i < identifiers.length; i++) {
+        let left = identifiers[i];
+        let right = identifiers[i + 1];
+        if (!logicalExpressions) {
+          logicalExpressions = t.logicalExpression('&&', left, right);
+        } else if (right) {
+          logicalExpressions = t.logicalExpression('&&', logicalExpressions, right);
         }
+      }
 
       return logicalExpressions;
-    }
+    };
   }
-}
+};

src/utils/macros.js

@@ -22,7 +22,7 @@ module.exports = class Macros {
     this.builder = new Builder(t, {
       module: this.debugHelpers.module,
       global: this.debugHelpers.global,
-      assertPredicateIndex: options.debugTools.assertPredicateIndex
+      assertPredicateIndex: options.debugTools.assertPredicateIndex,
     });
   }
 
@@ -35,7 +35,7 @@ module.exports = class Macros {
 
     this._inlineFeatureFlags(path);
     this._inlineSvelteFlags(path);
-    this._inlineEnvFlags(path)
+    this._inlineEnvFlags(path);
     this.builder.expandMacros(this.envFlags.DEBUG);
 
     if (this._hasDebugModule(debugBinding)) {
@@ -48,9 +48,11 @@ module.exports = class Macros {
   _inlineFeatureFlags(path) {
     let featuresMap = this.featuresMap;
 
-    if (this.envFlags.DEBUG) { return; }
-    Object.keys(featuresMap).forEach((source) => {
-      Object.keys(featuresMap[source]).forEach((flag) => {
+    if (this.envFlags.DEBUG) {
+      return;
+    }
+    Object.keys(featuresMap).forEach(source => {
+      Object.keys(featuresMap[source]).forEach(flag => {
         let flagValue = featuresMap[source][flag];
         let binding = path.scope.getBinding(flag);
 
@@ -71,13 +73,16 @@ module.exports = class Macros {
     let envFlags = this.envFlags;
 
     Object.keys(envFlags).forEach(flag => {
-       let binding = path.scope.getBinding(flag);
-       if (binding &&
-          binding.path.isImportSpecifier() &&
-          binding.path.parent.source.value === this.envFlagsSource) {
-
-         binding.referencePaths.forEach(p => p.replaceWith(this.builder.t.booleanLiteral(envFlags[flag])));
-       }
+      let binding = path.scope.getBinding(flag);
+      if (
+        binding &&
+        binding.path.isImportSpecifier() &&
+        binding.path.parent.source.value === this.envFlagsSource
+      ) {
+        binding.referencePaths.forEach(p =>
+          p.replaceWith(this.builder.t.booleanLiteral(envFlags[flag]))
+        );
+      }
     });
   }
 
@@ -87,19 +92,28 @@ module.exports = class Macros {
     let builder = this.builder;
 
     let sources = Object.keys(svelteMap);
-    sources.forEach((source) => {
-      Object.keys(svelteMap[source]).forEach((flag) => {
+    sources.forEach(source => {
+      Object.keys(svelteMap[source]).forEach(flag => {
         let binding = path.scope.getBinding(flag);
         if (binding !== undefined) {
-          binding.referencePaths.forEach((p) => {
+          binding.referencePaths.forEach(p => {
             let t = builder.t;
             if (envFlags.DEBUG) {
               if (svelteMap[source][flag] === false) {
-                if (!p.parentPath.isIfStatement()) { return; }
+                if (!p.parentPath.isIfStatement()) {
+                  return;
+                }
                 let consequent = p.parentPath.get('consequent');
-                consequent.unshiftContainer('body', t.throwStatement(
-                  t.newExpression(t.identifier('Error'), [t.stringLiteral(`You indicated you don't have any deprecations, however you are relying on ${flag}.`)])
-                ));
+                consequent.unshiftContainer(
+                  'body',
+                  t.throwStatement(
+                    t.newExpression(t.identifier('Error'), [
+                      t.stringLiteral(
+                        `You indicated you don't have any deprecations, however you are relying on ${flag}.`
+                      ),
+                    ])
+                  )
+                );
               }
             } else {
               if (p.parentPath.isIfStatement()) {
@@ -135,14 +149,17 @@ module.exports = class Macros {
   build(path) {
     let expression = path.node.expression;
 
-    if (this.builder.t.isCallExpression(expression) && this.localDebugBindings.some((b) => b.node.name === expression.callee.name)) {
+    if (
+      this.builder.t.isCallExpression(expression) &&
+      this.localDebugBindings.some(b => b.node.name === expression.callee.name)
+    ) {
       let imported = path.scope.getBinding(expression.callee.name).path.node.imported.name;
       this.builder[`${imported}`](path);
     }
   }
 
   _collectImportBindings(specifiers, buffer) {
-    specifiers.forEach((specifier) => {
+    specifiers.forEach(specifier => {
       if (specifier.node.imported && SUPPORTED_MACROS.indexOf(specifier.node.imported.name) > -1) {
         buffer.push(specifier.get('local'));
       }
@@ -156,9 +173,11 @@ module.exports = class Macros {
   }
 
   _detectForeignFeatureFlag(specifiers, source) {
-    specifiers.forEach((specifier) => {
+    specifiers.forEach(specifier => {
       if (specifier.imported && this.featuresMap[source][specifier.imported.name] !== null) {
-        throw new Error(`Imported ${specifier.imported.name} from ${source} which is not a supported flag.`);
+        throw new Error(
+          `Imported ${specifier.imported.name} from ${source} which is not a supported flag.`
+        );
       }
     });
   }
@@ -186,16 +205,16 @@ module.exports = class Macros {
 
     if (!this.debugHelpers.module) {
       if (this.localDebugBindings.length > 0) {
-        this.localDebugBindings[0].parentPath.parentPath
+        this.localDebugBindings[0].parentPath.parentPath;
         let importPath = this.localDebugBindings[0].findParent(p => p.isImportDeclaration());
         let specifiers = importPath.get('specifiers');
 
         if (specifiers.length === this.localDebugBindings.length) {
           this.localDebugBindings[0].parentPath.parentPath.remove();
         } else {
-          this.localDebugBindings.forEach((binding) => binding.parentPath.remove());
+          this.localDebugBindings.forEach(binding => binding.parentPath.remove());
         }
       }
     }
   }
-}
+};