Check for mozIndexedDB; close #15

package.json

@@ -40,6 +40,7 @@
   "dependencies": {
     "chalk": "1.1.1",
     "es6-promisify": "3.0.0",
+    "eslint": "1.6.0",
     "yargs": "3.26.0",
     "yauzl": "2.3.1"
   }

src/const.js

@@ -1,10 +1,20 @@
 export const DEFLATE_COMPRESSION = 8;
 export const NO_COMPRESSION = 0;
 
+export const ESLINT_ERROR = 2;
+export const ESLINT_NOTICE = 0;
+export const ESLINT_WARNING = 1;
+
 export const VALIDATION_ERROR = 'error';
 export const VALIDATION_NOTICE = 'notice';
 export const VALIDATION_WARNING = 'warning';
 
+export const ESLINT_TYPES = {
+  0: VALIDATION_NOTICE,
+  1: VALIDATION_WARNING,
+  2: VALIDATION_ERROR,
+};
+
 export const MESSAGE_TYPES = [
   VALIDATION_ERROR,
   VALIDATION_NOTICE,

src/javascript.js

@@ -0,0 +1,49 @@
+import path from 'path';
+
+import ESLint from 'eslint';
+
+import { ESLINT_TYPES } from 'const';
+import * as messages from 'messages';
+import ESLintRules from 'rules';
+
+
+export default class JavaScriptScanner {
+
+  constructor(code, filename) {
+    this.code = code;
+    this.filename = filename;
+  }
+
+  scan() {
+    return new Promise((resolve) => {
+      // ESLint is synchronous and doesn't accept streams, so we need to
+      // pass it the entire source file as a string.
+      let eslint = new ESLint.CLIEngine({
+        ignore: false,
+        rulePaths: [path.join('src', 'rules')],
+        rules: ESLintRules,
+        useEslintrc: false,
+      });
+
+      var validatorMessages = [];
+      var report = eslint.executeOnText(this.code, this.filename);
+
+      for (let message of report.results[0].messages) {
+        validatorMessages.push({
+          id: message.ruleId.toUpperCase(),
+          message: messages[message.ruleId.toUpperCase()].message,
+          description: messages[message.ruleId.toUpperCase()].description,
+          code: message.source,
+          file: this.filename,
+          line: message.line,
+          column: message.column,
+          severity: ESLINT_TYPES[message.severity],
+        });
+      }
+
+      resolve(validatorMessages);
+    });
+  }
+
+
+}

src/messages/index.js

@@ -1,4 +1,5 @@
 // Here we can re-export all our message so one can just do
 // import * as messages from 'messages';
 
+export * from './javascript';
 export * from './layout';

src/messages/javascript.js

@@ -0,0 +1,14 @@
+import { gettext as _ } from 'utils';
+
+
+export const MOZINDEXEDDB = {
+  code: 'MOZINDEXEDDB',
+  message: _('mozIndexedDB has been removed; use indexedDB instead.'),
+  description: _('mozIndexedDB has been removed; use indexedDB instead.'),
+};
+
+export const MOZINDEXEDDB_PROPERTY = {
+  code: 'MOZINDEXEDDB_PROPERTY',
+  message: _('mozIndexedDB used as an object key/property.'),
+  description: _('mozIndexedDB has been removed; use indexedDB instead.'),
+};

src/rules/index.js

@@ -0,0 +1,6 @@
+import { ESLINT_ERROR, ESLINT_WARNING } from 'const';
+
+export default {
+  mozIndexedDB: ESLINT_ERROR,
+  mozIndexedDB_property: ESLINT_WARNING,
+};

src/rules/mozIndexedDB.js

@@ -0,0 +1,11 @@
+module.exports = function(context) {
+  return {
+    Identifier: function(node) {
+      // Catches `var foo = mozIndexedDB;`.
+      if (node.name === 'mozIndexedDB' &&
+          node.parent.type !== 'MemberExpression') {
+        return context.report(node, 'MOZINDEXEDDB');
+      }
+    },
+  };
+};

src/rules/mozIndexedDB_property.js

@@ -0,0 +1,18 @@
+module.exports = function(context) {
+  return {
+    Identifier: function(node) {
+      // Catches `var foo = 'mozIndexedDB'; var myDatabase = window[foo];`.
+      if (node.parent.init && node.parent.init.value === 'mozIndexedDB') {
+        return context.report(node, 'MOZINDEXEDDB_PROPERTY');
+      }
+    },
+    MemberExpression: function(node) {
+      // Catches `var foo = window.mozIndexedDB;` and
+      // `var foo = window['mozIndexedDB'];`.
+      if (node.property.name === 'mozIndexedDB' ||
+          node.property.value === 'mozIndexedDB') {
+        context.report(node, 'MOZINDEXEDDB_PROPERTY');
+      }
+    },
+  };
+};

src/utils.js

@@ -1,3 +1,13 @@
+/*
+ * Implementation of String.endsWith, which errors in node.
+ *
+ */
+export function endsWith(string, suffix) {
+  string = String(string);
+  suffix = String(suffix);
+  return string.indexOf(suffix, string.length - suffix.length) !== -1;
+}
+
 /*
  * Template tag for removing whitespace and new lines
  * in order to be able to use multiline template strings

src/validator.js

@@ -7,8 +7,9 @@ import * as messages from 'messages';
 import * as exceptions from 'exceptions';
 import * as constants from 'const';
 
-import Xpi from 'xpi';
+import JavaScriptScanner from 'javascript';
 import Collector from 'collector';
+import Xpi from 'xpi';
 
 export var lstat = promisify(fs.lstat);
 
@@ -24,6 +25,12 @@ export default class Validator {
     this.collector = new Collector();
   }
 
+  addToCollector(message) {
+    var messageType = message.severity.charAt(0).toUpperCase() +
+                      message.severity.slice(1);
+    this.collector[`add${messageType}`](message);
+  }
+
   handleError(err) {
     if (this.config.stack === true) {
       console.error(err.stack);
@@ -75,6 +82,67 @@ export default class Validator {
     return output;
   }
 
+  scan(_Xpi=Xpi) {
+    return new Promise((resolve, reject) => {
+      this.checkFileExists(this.packagePath)
+        .then(() => {
+          this.xpi = new _Xpi(this.packagePath);
+          return this.xpi.getJSFiles();
+        })
+        .then((jsFiles) => {
+          return this.scanJSFiles(jsFiles);
+        })
+        .then(() => {
+          this.print();
+          resolve();
+        })
+        .catch((err) => {
+          if (err instanceof exceptions.DuplicateZipEntryError) {
+            this.collector.addError(messages.DUPLICATE_XPI_ENTRY);
+            this.print();
+          } else {
+            this.handleError(err);
+          }
+
+          reject(err);
+        });
+    });
+  }
+
+  scanJSFiles(jsFiles) {
+    return new Promise((resolve, reject) => {
+      // Resolve once every file in the XPI has been checked.
+      var jsFilesPromises = [];
+
+      for (let filename of jsFiles) {
+        jsFilesPromises.push(this.scanJSFile(filename));
+      }
+
+      return Promise.all(jsFilesPromises)
+        .then(() => {
+          resolve(this.collector);
+        }).catch(reject);
+    });
+  }
+
+  scanJSFile(filename) {
+    return new Promise((resolve, reject) => {
+      this.xpi.getFileAsString(filename)
+        .then((code) => {
+          let jsScanner = new JavaScriptScanner(code, filename);
+          return jsScanner.scan();
+        })
+        .then((validatorMessages) => {
+          for (let message of validatorMessages) {
+            this.addToCollector(message);
+          }
+
+          resolve();
+        })
+        .catch(reject);
+    });
+  }
+
   toJSON(pretty=false) {
     var args = [this.output];
     if (pretty === true) {
@@ -83,24 +151,4 @@ export default class Validator {
     }
     return JSON.stringify.apply(null, args);
   }
-
-  scan(_Xpi=Xpi) {
-    return this.checkFileExists(this.packagePath)
-      .then(() => {
-        this.xpi = new _Xpi(this.packagePath);
-        return this.xpi.getMetaData();
-      })
-      .then((metadata) => {
-        // Do something useful with package here.
-        console.log(metadata);
-      })
-      .catch((err) => {
-        if (err instanceof exceptions.DuplicateZipEntryError) {
-          this.collector.addError(messages.DUPLICATE_XPI_ENTRY);
-          this.print();
-        } else {
-          return this.handleError(err);
-        }
-      });
-  }
 }

src/xpi.js

@@ -1,7 +1,7 @@
 import yauzl from 'yauzl';
 
 import { DuplicateZipEntryError } from 'exceptions';
-
+import { endsWith } from 'utils';
 
 /*
  * Simple Promise wrapper for the Yauzl unzipping lib to unpack add-on .xpis.
@@ -96,7 +96,45 @@ export default class Xpi {
             resolve(readStream);
           });
         })
-        .catch((err) => reject(err));
+        .catch(reject);
+    });
+  }
+
+  getFileAsString(path) {
+    return new Promise((resolve, reject) => {
+      return this.getFileAsStream(path)
+        .then((fileStream) => {
+          var fileString = '';
+          fileStream.on('data', (chunk) => {
+            fileString += chunk;
+          });
+
+          // Once the file is assembled, resolve the promise.
+          fileStream.on('end', () => {
+            resolve(fileString);
+          });
+        })
+        .catch(reject);
+    });
+  }
+
+  getJSFiles() {
+    return new Promise((resolve, reject) => {
+      return this.getMetaData()
+        .then((metadata) => {
+          let jsFiles = [];
+
+          for (let filename in metadata) {
+            // TODO: Check for JS files better than this (follow require path)
+            // of add-on?
+            if (endsWith(filename, '.js')) {
+              jsFiles.push(filename);
+            }
+          }
+
+          resolve(jsFiles);
+        })
+        .catch(reject);
     });
   }
 }