feat: html validator custom config support-htmlvalidate.json

abose · abose · commit e2b075d8f9e0 · 2024-06-18T19:02:49.000+05:30
diff --git a/src/extensions/default/HTMLCodeHints/html-lint.js b/src/extensions/default/HTMLCodeHints/html-lint.js
@@ -19,7 +19,7 @@
  *
  */
 
-// Parts of this file is adapted from https://github.com/cfjedimaster/brackets-jshint
+/* global path*/
 
 /**
  * Provides JSLint results via the core linting extension point
@@ -28,16 +28,26 @@ define(function (require, exports, module) {
 
     // Load dependent modules
     const CodeInspection   = brackets.getModule("language/CodeInspection"),
+        AppInit            = brackets.getModule("utils/AppInit"),
         Strings            = brackets.getModule("strings"),
+        StringUtils        = brackets.getModule("utils/StringUtils"),
+        FileSystemError    = brackets.getModule("filesystem/FileSystemError"),
+        DocumentManager    = brackets.getModule("document/DocumentManager"),
         EditorManager      = brackets.getModule("editor/EditorManager"),
         ProjectManager     = brackets.getModule("project/ProjectManager"),
         PreferencesManager = brackets.getModule("preferences/PreferencesManager"),
+        Metrics            = brackets.getModule("utils/Metrics"),
+        FileSystem         = brackets.getModule("filesystem/FileSystem"),
         IndexingWorker     = brackets.getModule("worker/IndexingWorker");
 
     IndexingWorker.loadScriptInWorker(`${module.uri}/../worker/html-worker.js`);
 
     const prefs = PreferencesManager.getExtensionPrefs("HTMLLint");
     const PREFS_HTML_LINT_DISABLED = "disabled";
+    const CONFIG_FILE_NAME = ".htmlvalidate.json";
+    const UNSUPPORTED_CONFIG_FILES = [".htmlvalidate.js", ".htmlvalidate.cjs"];
+
+    let projectSpecificOptions, configErrorMessage, configID = 0;
 
     prefs.definePreference(PREFS_HTML_LINT_DISABLED, "boolean", false, {
         description: Strings.DESCRIPTION_HTML_LINT_DISABLE
@@ -54,15 +64,30 @@ define(function (require, exports, module) {
         }
     }
 
+    function _getLinterConfigFileErrorMsg() {
+        return [{
+            // JSLint returns 1-based line/col numbers
+            pos: { line: -1, ch: 0 },
+            message: configErrorMessage,
+            type: CodeInspection.Type.ERROR
+        }];
+    }
+
     /**
      * Run JSLint on the current document. Reports results to the main UI. Displays
      * a gold star when no errors are found.
      */
     async function lintOneFile(text, fullPath) {
         return new Promise((resolve, reject)=>{
+            if(configErrorMessage){
+                resolve({ errors: _getLinterConfigFileErrorMsg() });
+                return;
+            }
             IndexingWorker.execPeer("htmlLint", {
                 text,
-                filePath: fullPath
+                filePath: fullPath,
+                configID,
+                config: projectSpecificOptions
             }).then(lintResult =>{
                 const editor = EditorManager.getCurrentFullEditor();
                 if(!editor || editor.document.file.fullPath !== fullPath) {
@@ -88,6 +113,110 @@ define(function (require, exports, module) {
         });
     }
 
+    function _readConfig(dir) {
+        return new Promise((resolve, reject)=>{
+            const configFilePath = path.join(dir, CONFIG_FILE_NAME);
+            let displayPath = ProjectManager.getProjectRelativeOrDisplayPath(configFilePath);
+            DocumentManager.getDocumentForPath(configFilePath).done(function (configDoc) {
+                let config;
+                const content = configDoc.getText();
+                try {
+                    config = JSON.parse(content);
+                    console.log("html-lint: loaded config file for project " + configFilePath);
+                } catch (e) {
+                    console.log("html-lint: error parsing " + configFilePath, content, e);
+                    // just log and return as this is an expected failure for us while the user edits code
+                    reject(StringUtils.format(Strings.HTML_LINT_CONFIG_JSON_ERROR, displayPath));
+                    return;
+                }
+                resolve(config);
+            }).fail((err)=>{
+                if(err === FileSystemError.NOT_FOUND){
+                    resolve(null); // no config file is a valid case. we just resolve with null
+                    return;
+                }
+                console.error("Error reading JSHint Config File", configFilePath, err);
+                reject("Error reading JSHint Config File", displayPath);
+            });
+        });
+    }
+
+    async function _validateUnsupportedConfig(scanningProjectPath) {
+        let errorMessage;
+        for(let unsupportedFileName of UNSUPPORTED_CONFIG_FILES) {
+            let exists = await FileSystem.existsAsync(path.join(scanningProjectPath, unsupportedFileName));
+            if(exists) {
+                errorMessage = StringUtils.format(Strings.HTML_LINT_CONFIG_UNSUPPORTED, unsupportedFileName);
+                break;
+            }
+        }
+        if(scanningProjectPath !== ProjectManager.getProjectRoot().fullPath) {
+            // this is a rare race condition where the user switches project between the config reload
+            // Eg. in integ tests. do nothing as another scan for the new project will be in progress.
+            return;
+        }
+        configErrorMessage = errorMessage;
+        CodeInspection.requestRun(Strings.HTML_LINT_NAME);
+    }
+
+    function _reloadOptions() {
+        projectSpecificOptions = null;
+        configErrorMessage = null;
+        const scanningProjectPath = ProjectManager.getProjectRoot().fullPath;
+        configID++;
+        _readConfig(scanningProjectPath, CONFIG_FILE_NAME).then((config)=>{
+            configID++;
+            if(scanningProjectPath !== ProjectManager.getProjectRoot().fullPath){
+                // this is a rare race condition where the user switches project between the get document call.
+                // Eg. in integ tests. do nothing as another scan for the new project will be in progress.
+                return;
+            }
+            if(config) {
+                Metrics.countEvent(Metrics.EVENT_TYPE.LINT, "html", "configPresent");
+                projectSpecificOptions = config;
+                configErrorMessage = null;
+                CodeInspection.requestRun(Strings.HTML_LINT_NAME);
+            } else {
+                _validateUnsupportedConfig(scanningProjectPath)
+                    .catch(console.error);
+            }
+        }).catch((err)=>{
+            configID++;
+            if(scanningProjectPath !== ProjectManager.getProjectRoot().fullPath){
+                return;
+            }
+            Metrics.countEvent(Metrics.EVENT_TYPE.LINT, "HTMLConfig", "error");
+            configErrorMessage = err;
+            CodeInspection.requestRun(Strings.HTML_LINT_NAME);
+        });
+    }
+
+    function _isFileInArray(pathToMatch, filePathArray){
+        if(!filePathArray){
+            return false;
+        }
+        for(let filePath of filePathArray){
+            if(filePath === pathToMatch){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    function _projectFileChanged(_evt, changedPath, added, removed) {
+        let configFilePath = path.join(ProjectManager.getProjectRoot().fullPath, CONFIG_FILE_NAME);
+        if(changedPath=== configFilePath
+            || _isFileInArray(configFilePath, added) || _isFileInArray(configFilePath, removed)){
+            _reloadOptions();
+        }
+    }
+
+    AppInit.appReady(function () {
+        ProjectManager.on(ProjectManager.EVENT_PROJECT_PATH_CHANGED_OR_RENAMED, _projectFileChanged);
+        ProjectManager.on(ProjectManager.EVENT_PROJECT_OPEN, _reloadOptions);
+        _reloadOptions();
+    });
+
     CodeInspection.register("html", {
         name: Strings.HTML_LINT_NAME,
         scanFileAsync: lintOneFile,
diff --git a/src/extensions/default/HTMLCodeHints/worker/html-worker.js b/src/extensions/default/HTMLCodeHints/worker/html-worker.js
@@ -22,9 +22,42 @@
 
 (function () {
     let htmlValidator = HTMLLanguageService.createHTMLValidator({
-          extends: ["html-validate:standard"]
-        });
+        extends: ["html-validate:standard"]
+    });
+
+    let isUsingCustomConfig = false, currentConfigID;
+
+    function setupValidator(config, configID) {
+        try{
+            if(!config && isUsingCustomConfig) {
+                // reset the config
+                htmlValidator = HTMLLanguageService.createHTMLValidator({
+                    extends: ["html-validate:standard"]
+                });
+                isUsingCustomConfig = false;
+                currentConfigID = null;
+            } else if(config && currentConfigID !== configID) {
+                htmlValidator = HTMLLanguageService.createHTMLValidator(config);
+                isUsingCustomConfig = true;
+                currentConfigID = configID;
+            }
+            return null;
+        } catch (e) {
+            return e.message;
+        }
+    }
+
     async function htmlLint(params) {
+        let errorMessage = setupValidator(params.config, params.configID);
+        if(errorMessage) {
+            return [{
+                start: 0,
+                end: 0,
+                severity: 2, // 1 warning and 2 is error
+                message: "Invalid config file `.htmlvalidate.json`"+ errorMessage,
+                ruleId: "INVALID_CONFIG"
+            }];
+        }
         const validatorResult = await htmlValidator.validateString(params.text, params.filePath);
         if(!validatorResult || !validatorResult.results || !validatorResult.results.length){
             return [];
@@ -48,5 +81,14 @@
         return errors;
     }
 
+    async function updateHTMLLintConfig(params) {
+        if(params.config){
+            console.error("HTML Lint worker updateHTMLLintConfig received null config", params);
+            return;
+        }
+        htmlValidator = HTMLLanguageService.createHTMLValidator(params.config);
+    }
+
     WorkerComm.setExecHandler("htmlLint", htmlLint);
+    WorkerComm.setExecHandler("updateHTMLLintConfig", updateHTMLLintConfig);
 }());
diff --git a/src/extensions/default/JSLint/ESLint.js b/src/extensions/default/JSLint/ESLint.js
@@ -236,7 +236,7 @@ define(function (require, exports, module) {
             if(scanningProjectPath !== ProjectManager.getProjectRoot().fullPath){
                 return;
             }
-            Metrics.countEvent(Metrics.EVENT_TYPE.LINT, "eslintErr", "project");
+            Metrics.countEvent(Metrics.EVENT_TYPE.LINT, "eslintConfig", "error");
             useESLintFromProject = false;
             CodeInspection.requestRun(Strings.ESLINT_NAME);
         });
diff --git a/src/extensions/default/JSLint/JSHint.js b/src/extensions/default/JSLint/JSHint.js
@@ -29,13 +29,13 @@
 define(function (require, exports, module) {
 
     // Load dependent modules
-    const _                = brackets.getModule("thirdparty/lodash"),
-        CodeInspection     = brackets.getModule("language/CodeInspection"),
+    const CodeInspection     = brackets.getModule("language/CodeInspection"),
         FileSystemError    = brackets.getModule("filesystem/FileSystemError"),
         AppInit            = brackets.getModule("utils/AppInit"),
         PreferencesManager = brackets.getModule("preferences/PreferencesManager"),
         DocumentManager    = brackets.getModule("document/DocumentManager"),
         Strings            = brackets.getModule("strings"),
+        StringUtils        = brackets.getModule("utils/StringUtils"),
         ProjectManager     = brackets.getModule("project/ProjectManager"),
         FileSystem         = brackets.getModule("filesystem/FileSystem"),
         IndexingWorker     = brackets.getModule("worker/IndexingWorker"),
@@ -163,8 +163,7 @@ define(function (require, exports, module) {
         return new Promise((resolve, reject)=>{
             configFileName = configFileName || CONFIG_FILE_NAME;
             const configFilePath = path.join(dir, configFileName);
-            let displayPath = ProjectManager.makeProjectRelativeIfPossible(configFilePath);
-            displayPath = ProjectManager.getProjectRelativeOrDisplayPath(displayPath);
+            let displayPath = ProjectManager.getProjectRelativeOrDisplayPath(configFilePath);
             DocumentManager.getDocumentForPath(configFilePath).done(function (configDoc) {
                 if (!ProjectManager.isWithinProject(configFilePath)) {
                     // this is a rare race condition where the user switches project between the get document call.
@@ -180,7 +179,7 @@ define(function (require, exports, module) {
                 } catch (e) {
                     console.log("JSHint: error parsing " + configFilePath, content, e);
                     // just log and return as this is an expected failure for us while the user edits code
-                    reject("Error parsing JSHint config file:    " + displayPath);
+                    reject(StringUtils.format(Strings.JSHINT_CONFIG_JSON_ERROR, displayPath));
                     return;
                 }
                 // Load any base config defined by "extends".
@@ -199,10 +198,9 @@ define(function (require, exports, module) {
                     }).catch(()=>{
                         let extendDisplayPath = ProjectManager.makeProjectRelativeIfPossible(extendFile.fullPath);
                         extendDisplayPath = ProjectManager.getProjectRelativeOrDisplayPath(extendDisplayPath);
-                        reject("Error parsing JSHint config file: " + extendDisplayPath);
+                        reject(StringUtils.format(Strings.JSHINT_CONFIG_JSON_ERROR, extendDisplayPath));
                     });
-                }
-                else {
+                } else {
                     resolve(config);
                 }
             }).fail((err)=>{
@@ -211,13 +209,14 @@ define(function (require, exports, module) {
                     return;
                 }
                 console.error("Error reading JSHint Config File", configFilePath, err);
-                reject("Error reading JSHint Config File", displayPath);
+                reject(StringUtils.format(Strings.JSHINT_CONFIG_ERROR, displayPath));
             });
         });
     }
 
     function _reloadOptions() {
         projectSpecificOptions = null;
+        jsHintConfigFileErrorMessage = null;
         const scanningProjectPath = ProjectManager.getProjectRoot().fullPath;
         _readConfig(scanningProjectPath, CONFIG_FILE_NAME).then((config)=>{
             if(scanningProjectPath !== ProjectManager.getProjectRoot().fullPath){
@@ -235,7 +234,7 @@ define(function (require, exports, module) {
             if(scanningProjectPath !== ProjectManager.getProjectRoot().fullPath){
                 return;
             }
-            Metrics.countEvent(Metrics.EVENT_TYPE.LINT, "jsHintErr", "project");
+            Metrics.countEvent(Metrics.EVENT_TYPE.LINT, "jsHintConfig", "error");
             jsHintConfigFileErrorMessage = err;
             CodeInspection.requestRun(Strings.JSHINT_NAME);
         });
diff --git a/src/nls/root/strings.js b/src/nls/root/strings.js
@@ -898,13 +898,17 @@ define({
 
     // extensions/default/JSLint
     "JSHINT_NAME": "JSHint",
+    "JSHINT_CONFIG_ERROR": "Error reading JSHint config file: {0}",
+    "JSHINT_CONFIG_JSON_ERROR": "Error: JSHint config file `{0}` is not valid JSON",
     "ESLINT_NAME": "ESLint",
 
     // extension css code hints
     "CSS_LINT_NAME": "{0}",
 
     // html lint
     "HTML_LINT_NAME": "HTML",
+    "HTML_LINT_CONFIG_JSON_ERROR": "Error: HTML Validator config file `{0}` is not valid JSON",
+    "HTML_LINT_CONFIG_UNSUPPORTED": "Error: Unsupported config format `{0}`. Use JSON config `.htmlvalidate.json`",
 
     // Features/QuickView and quick view extensions
     "CMD_ENABLE_QUICK_VIEW": "Quick View on Hover",
diff --git a/src/project/ProjectManager.js b/src/project/ProjectManager.js
@@ -92,8 +92,12 @@ define(function (require, exports, module) {
         EVENT_AFTER_STARTUP_FILES_LOADED = "startupFilesLoaded",
         EVENT_PROJECT_REFRESH = "projectRefresh",
         EVENT_CONTENT_CHANGED = "contentChanged",
+        // This will capture all file/folder changes in projects except renames. If you want to track renames,
+        // use EVENT_PROJECT_PATH_CHANGED_OR_RENAMED to track all changes or EVENT_PROJECT_FILE_RENAMED too.
         EVENT_PROJECT_FILE_CHANGED = "projectFileChanged",
-        EVENT_PROJECT_FILE_RENAMED = "projectFileRenamed";
+        EVENT_PROJECT_FILE_RENAMED = "projectFileRenamed",
+        // the path changed event differs in the sense that all events returned by this will be a path.
+        EVENT_PROJECT_PATH_CHANGED_OR_RENAMED = "projectPathChanged";
 
     EventDispatcher.setLeakThresholdForEvent(EVENT_PROJECT_OPEN, 25);
 
@@ -2021,6 +2025,32 @@ define(function (require, exports, module) {
         return !unsafeExit;
     }
 
+    function _entryToPathArray(entryArray) {
+        if(!entryArray || !entryArray.length) {
+            return [];
+        }
+        return entryArray.map(entry => path.normalize(entry.fullPath));
+    }
+
+    exports.on(EVENT_PROJECT_FILE_CHANGED, (_evt, entry, addedInProject, removedInProject)=>{
+        exports.trigger(EVENT_PROJECT_PATH_CHANGED_OR_RENAMED, entry && path.normalize(entry.fullPath),
+            _entryToPathArray(addedInProject), _entryToPathArray(removedInProject));
+    });
+    exports.on(EVENT_PROJECT_FILE_RENAMED, (_evt, oldPath, newPath)=>{
+        oldPath = path.normalize(oldPath);
+        newPath = path.normalize(newPath);
+        if(oldPath === newPath){
+            return; // no change
+        }
+        const oldParent = path.dirname(oldPath), newParent = path.dirname(newPath);
+        if(oldParent === newParent) {
+            exports.trigger(EVENT_PROJECT_PATH_CHANGED_OR_RENAMED, newParent, [newPath], [oldPath]);
+        } else {
+            exports.trigger(EVENT_PROJECT_PATH_CHANGED_OR_RENAMED, oldParent, [], [oldPath]);
+            exports.trigger(EVENT_PROJECT_PATH_CHANGED_OR_RENAMED, newParent, [newPath], []);
+        }
+    });
+
     exports.on(EVENT_PROJECT_OPEN, (_evt, projectRoot)=>{
         _reloadProjectPreferencesScope();
         _saveProjectPath();
@@ -2285,5 +2315,6 @@ define(function (require, exports, module) {
     exports.EVENT_CONTENT_CHANGED = EVENT_CONTENT_CHANGED;
     exports.EVENT_PROJECT_FILE_CHANGED = EVENT_PROJECT_FILE_CHANGED;
     exports.EVENT_PROJECT_FILE_RENAMED = EVENT_PROJECT_FILE_RENAMED;
+    exports.EVENT_PROJECT_PATH_CHANGED_OR_RENAMED = EVENT_PROJECT_PATH_CHANGED_OR_RENAMED;
     exports.EVENT_PROJECT_OPEN_FAILED = EVENT_PROJECT_OPEN_FAILED;
 });
diff --git a/test/spec/QuickOpen-integ-test.js b/test/spec/QuickOpen-integ-test.js

Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ define(function (require, exports, module) {`
`236`	`236`	`if(scanningProjectPath !== ProjectManager.getProjectRoot().fullPath){`
`237`	`237`	`return;`
`238`	`238`	`}`
`239`		`- Metrics.countEvent(Metrics.EVENT_TYPE.LINT, "eslintErr", "project");`
	`239`	`+ Metrics.countEvent(Metrics.EVENT_TYPE.LINT, "eslintConfig", "error");`
`240`	`240`	`useESLintFromProject = false;`
`241`	`241`	`CodeInspection.requestRun(Strings.ESLINT_NAME);`
`242`	`242`	`});`