add ESLint as a default Brackets extension

.brackets.json

@@ -10,7 +10,7 @@
     "defaultExtension": "js",
     "language": {
         "javascript": {
-            "linting.prefer": ["ESLint", "JSLint"],
+            "linting.prefer": ["ESLint"],
             "linting.usePreferredOnly": true
         }
     },

.eslintrc

@@ -43,13 +43,13 @@
         "new-parens": 2,
         "no-new-object": 2,
         "no-invalid-this": 0,
-        indent: [0, 4],
+        indent: [2, 4],
 
         "valid-jsdoc": 0,
         "valid-typeof": 2,
 
-        "no-trailing-spaces": 0,
-        "eol-last": 0
+        "no-trailing-spaces": [2, { "skipBlankLines": true }],
+        "eol-last": 2
     },
     "globals": {
         "brackets": false,

src/extensions/default/ESLint/domain.js

@@ -0,0 +1,155 @@
+/*eslint no-process-env:0*/
+/*global require, exports*/
+
+(function () {
+    'use strict';
+
+    var fs = require('fs');
+    var CLIEngine = require('eslint').CLIEngine;
+    var cli = new CLIEngine();
+    var currentProjectRoot = null;
+    var domainName = 'brackets-eslint';
+    var domainManager = null;
+    var globalPackagesAvailable = false;
+
+    function _setProjectRoot(projectRoot) {
+        var opts = { useEslintrc: true };
+        var configPath;
+        var rulesDirPath;
+        var ignorePath;
+
+        if (projectRoot) {
+            try {
+                var dirContent = fs.readdirSync(projectRoot);
+                dirContent = dirContent.filter(function (entry) {
+                    return /^\.eslintrc(\.(js|yaml|yml|json))?$/.test(entry);
+                });
+                if (dirContent.length === 0) {
+                    throw new Error('no config file found!');
+                }
+            } catch (e) {
+                // config file not found, use default
+                opts.rules = require('eslint/conf/eslint.json').rules;
+            }
+
+            rulesDirPath = projectRoot + '.eslintrules';
+            try {
+                if (fs.statSync(rulesDirPath).isDirectory()) {
+                    opts.rulePaths = [rulesDirPath];
+                }
+            } catch (err) {
+                // ignore err
+            }
+
+            ignorePath = projectRoot + '.eslintignore';
+            try {
+                if (fs.statSync(ignorePath).isFile()) {
+                    opts.ignore = true;
+                    opts.ignorePath = ignorePath;
+                }
+            } catch (err) {
+                // ignore err
+            }
+        }
+
+        cli = new CLIEngine(opts);
+    }
+
+    require('enable-global-packages').on('ready', function () {
+        // global packages are available now
+        _setProjectRoot(currentProjectRoot);
+        globalPackagesAvailable = true;
+    });
+
+    function lintFile(fullPath, projectRoot, callback) {
+        if (!globalPackagesAvailable) {
+            setTimeout(function () {
+                lintFile(fullPath, projectRoot, callback);
+            }, 250);
+            return;
+        }
+        if (projectRoot !== currentProjectRoot) {
+            _setProjectRoot(projectRoot);
+            currentProjectRoot = projectRoot;
+        }
+        fs.readFile(fullPath, {encoding: 'utf8'}, function (err, text) {
+            if (err) {
+                return callback(err);
+            }
+            var relativePath = fullPath.indexOf(projectRoot) === 0 ? fullPath.substring(projectRoot.length) : fullPath;
+
+            // this is important for ESLint so .eslintrc is properly loaded
+            // we could go around this by parsing .eslintrc manually but that'd
+            // bring complexity we don't need here right now
+            // related: https://github.com/eslint/eslint/issues/4472
+            process.chdir(projectRoot);
+
+            var res;
+            try {
+                res = cli.executeOnText(text, relativePath);
+            } catch (e) {
+                err = e.toString();
+            }
+            callback(err, res);
+        });
+    }
+
+    function configFileModified(projectRoot) {
+        _setProjectRoot(projectRoot);
+        currentProjectRoot = projectRoot;
+    }
+
+    exports.init = function (_domainManager) {
+        domainManager = _domainManager;
+
+        if (!domainManager.hasDomain(domainName)) {
+            domainManager.registerDomain(domainName, {
+                major: 0,
+                minor: 1
+            });
+        }
+
+        domainManager.registerCommand(
+            domainName,
+            'lintFile', // command name
+            lintFile, // handler function
+            true, // is async
+            'lint given file with eslint', // description
+            [
+                {
+                    name: 'fullPath',
+                    type: 'string'
+                },
+                {
+                    name: 'projectRoot',
+                    type: 'string'
+                }
+            ], [
+                {
+                    name: 'report',
+                    type: 'object'
+                }
+            ]
+        );
+
+        domainManager.registerCommand(
+            domainName,
+            'configFileModified',
+            configFileModified,
+            false,
+            'notify that config file was modified',
+            [
+                {
+                    name: 'projectRoot',
+                    type: 'string'
+                }
+            ], [
+                {
+                    name: 'result',
+                    type: 'boolean'
+                }
+            ]
+        );
+    };
+
+}());

src/extensions/default/ESLint/main.js

@@ -0,0 +1,76 @@
+/*global $, brackets, define*/
+
+define(function (require, exports, module) {
+    'use strict';
+
+    // imports
+    var CodeInspection = brackets.getModule('language/CodeInspection');
+    var LanguageManager = brackets.getModule('language/LanguageManager');
+    var ProjectManager = brackets.getModule('project/ProjectManager');
+    var ExtensionUtils = brackets.getModule('utils/ExtensionUtils');
+    var NodeDomain = brackets.getModule('utils/NodeDomain');
+    var FileSystem = brackets.getModule("filesystem/FileSystem");
+
+    // constants
+    var JS_LANGUAGE = LanguageManager.getLanguageForExtension('js');
+    var LINTER_NAME = 'ESLint';
+    var nodeDomain = new NodeDomain('brackets-eslint', ExtensionUtils.getModulePath(module, 'domain'));
+
+    // this will map ESLint output to match format expected by Brackets
+    function remapResults(results) {
+        return {
+            errors: results.map(function (result) {
+                var message = result.message;
+                if (result.ruleId) {
+                    message += ' [' + result.ruleId + ']';
+                }
+                return {
+                    message: message,
+                    pos: {
+                        line: result.line - 1,
+                        ch: result.column
+                    },
+                    type: result.ruleId
+                };
+            })
+        };
+    }
+
+    function handleLintSync(text, fullPath) {
+        throw new Error('ESLint sync is not available, use async for ' + fullPath);
+    }
+
+    function handleLintAsync(text, fullPath) {
+        var deferred = new $.Deferred();
+        var projectRoot = ProjectManager.getProjectRoot().fullPath;
+
+        nodeDomain.exec('lintFile', fullPath, projectRoot)
+            .then(function (report) {
+                if (report.results.length > 1) {
+                    console.warn('ESLint returned multiple results, where only one set was expected');
+                }
+                var results = report.results[0];
+                var remapped = remapResults(results.messages);
+                deferred.resolve(remapped);
+            }, function (err) {
+                deferred.reject(err);
+            });
+
+        return deferred.promise();
+    }
+
+    FileSystem.on("change", function (evt, file) {
+        if (/^\.eslintrc(\.(js|yaml|yml|json))?$/.test(file.name)) {
+            var projectRoot = ProjectManager.getProjectRoot().fullPath;
+            nodeDomain.exec('configFileModified', projectRoot);
+        }
+    });
+
+    // register a linter with CodeInspection
+    CodeInspection.register(JS_LANGUAGE.getId(), {
+        name: LINTER_NAME,
+        scanFile: handleLintSync,
+        scanFileAsync: handleLintAsync
+    });
+
+});