npm-groovy-lint 9.3.0 → 9.4.1

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## UNRELEASED
 
+- Add your updates here :)
+
+## [9.4.1] 2022-01-22
+
+- Upgrade node-sarif-builder to 2.0.1 and send npm-groovy-lint version in SARIF logs
+- New range detection for rules:
+  - MethodReturnTypeRequired
+  - UnusedImport
+
+## [9.4.0] 2022-01-11
+
+- Add [SARIF](https://sarifweb.azurewebsites.net/) output format using [node-sarif-builder](https://github.com/nvuillam/node-sarif-builder)
+
+## [9.3.2] 2022-01-09
+
+- Upgrade cli-progress to avoid [colors lib boring but harmless hack](https://github.com/Marak/colors.js/issues/285)
+
+## [9.3.1] 2022-01-06
+
+- Fix issue when used as module and with file containing spaces ([VsCodeGroovyLint #137](https://github.com/nvuillam/vscode-groovy-lint/issues/137))
+
 ## [9.3.0] 2021-12-29
 
 - Upgrade log4j dependencies because of [security issue](https://nvd.nist.gov/vuln/detail/CVE-2021-44832).

package/README.md

@@ -47,7 +47,7 @@ Any **question**, **problem** or **enhancement request** ? Ask [**here**](https:
 |-------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | -p<br/> --path          | String  | Directory containing the files to lint<br/> Example: `./path/to/my/groovy/files`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | -f<br/> --files         | String  | Comma-separated list of Ant-style file patterns specifying files that must be included.<br/> Default: `"**/*.groovy,**/Jenkinsfile,**/*.gradle"`<br/>Examples:<br/> - `"**/Jenkinsfile"`<br/> - `"**/*.groovy"`<br/> - `"**/*.gradle"`<br/> - `"**/mySingleFile.groovy"`                                                                                                                                                                                                                                                                                                          |
-| -o<br/> --output        | String  | Output format (txt,json,html,xml), or path to a file with one of these extensions<br/> Default: `txt`<br/> Examples:<br/> - `"txt"`<br/> - `"json"`<br/> - `"./logs/myLintResults.txt"`<br/> - `"./logs/myLintResults.json"`<br/> - `"./logs/myLintResults.html"`<br/> - `"./logs/myLintResults.xml"`                                                                                                                                                                                                                                                                             |
+| -o<br/> --output        | String  | Output format (txt,json,sarif,html,xml), or path to a file with one of these extensions<br/> Default: `txt`<br/> Examples:<br/> - `"txt"`<br/> - `"json"`<br/> - `"./logs/myLintResults.txt"`<br/> - `"./logs/myLintResults.sarif"`<br/> - `"./logs/myLintResults.html"`<br/> - `"./logs/myLintResults.xml"`                                                                                                                                                                                                                                                                      |
 | -l<br/> --loglevel      | String  | Log level (error,warning or info)<br/>Default: info                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | --failon                | String  | Defines the error level where CLI will fail (return code = 1). error,warning,info or none. Each failure level includes the more critical ones.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | -c<br/> --config        | String  | Custom path to [GroovyLint config file](#Configuration), or preset config `recommended|recommended-jenkinsfile|all`<br/> Default: Browse current directory to find `.groovylintrc.json|js|yml|package.json` config file, or default npm-groovy-lint config if not defined.<br/>Note: command-line arguments have priority on config file properties                                                                                                                                                                                                                               |

package/lib/codenarc-caller.js

@@ -304,7 +304,7 @@ class CodeNarcCaller {
         });
 
         if (this.serverStatus === "running") {
-            console.log(c.green(`GroovyLint: Started CodeNarc Server`));
+            debug(c.green(`GroovyLint: Started CodeNarc Server`));
             return true;
         } else {
             return false;

package/lib/codenarc-factory.js

@@ -2,7 +2,7 @@
 "use strict";
 
 const debug = require("debug")("npm-groovy-lint");
-const fse = require("fs-extra");
+const fs = require("fs-extra");
 const os = require("os");
 const path = require("path");
 const { getConfigFileName } = require("./config.js");
@@ -29,14 +29,15 @@ async function prepareCodeNarcCall(options) {
     // If source option, create a temporary Groovy file
     if (options.source) {
         cnPath = path.resolve(os.tmpdir() + "/npm-groovy-lint");
-        await fse.ensureDir(cnPath, { mode: "0777" });
+        await fs.ensureDir(cnPath, { mode: "0777" });
         // File path is sent (recommended): use it to create temp file name
         if (options.sourcefilepath) {
             const pathParse = path.parse(options.sourcefilepath);
             cnPath = cnPath + "/codeNarcTmpDir_" + Math.random();
-            await fse.ensureDir(cnPath, { mode: "0777" });
-            result.tmpGroovyFileName = path.resolve(cnPath + "/" + pathParse.base);
-            cnFiles = "**/" + pathParse.base;
+            await fs.ensureDir(cnPath, { mode: "0777" });
+            const pathBase = pathParse.base.replace(/ /g, "_");
+            result.tmpGroovyFileName = path.resolve(cnPath + "/" + pathBase);
+            cnFiles = "**/" + pathBase;
         }
         // Use default random file name
         else {
@@ -45,7 +46,7 @@ async function prepareCodeNarcCall(options) {
             cnFiles = "**/" + tmpFileNm;
         }
 
-        await fse.writeFile(result.tmpGroovyFileName, normalizeNewLines(options.source));
+        await fs.writeFile(result.tmpGroovyFileName, normalizeNewLines(options.source));
         debug(`CREATE GROOVY temp file ${result.tmpGroovyFileName} with input source, as CodeNarc requires physical files`);
     }
 
@@ -90,8 +91,14 @@ async function prepareCodeNarcCall(options) {
 
     // Output
     result.output = options.output.replace(/^"(.*)"$/, "$1");
-    if (["txt", "json", "none"].includes(result.output) || result.output.endsWith(".txt") || result.output.endsWith(".json")) {
-        result.outputType = result.output.endsWith(".txt") ? "txt" : result.output.endsWith(".json") ? "json" : result.output;
+    if (["txt", "json", "sarif", "none"].includes(result.output) ||
+        result.output.endsWith(".txt") ||
+        result.output.endsWith(".sarif") ||
+        result.output.endsWith(".json")) {
+        result.outputType = result.output.endsWith(".txt") ? "txt"
+            : result.output.endsWith(".json") ? "json"
+                : result.output.endsWith(".sarif") ? "sarif"
+                    : result.output;
         result.codenarcArgs.push(`-report=json:stdout`);
     } else if (["html", "xml"].includes(result.output.split(".").pop())) {
         result.outputType = result.output
@@ -100,11 +107,11 @@ async function prepareCodeNarcCall(options) {
             .endsWith("html")
             ? "html"
             : result.output
-                  .split(".")
-                  .pop()
-                  .endsWith("xml")
-            ? "xml"
-            : "";
+                .split(".")
+                .pop()
+                .endsWith("xml")
+                ? "xml"
+                : "";
         const ext = result.output.split(".").pop();
         result.codenarcArgs.push(`-report=${ext}:${result.output}`);
 
@@ -265,9 +272,9 @@ async function parseCodeNarcResult(options, codeNarcBaseDir, codeNarcJsonResult,
     }
 
     // Parse error definitions & build url if not already done and not noreturnrules option
-    if (result.rules == null && options.returnrules === true) {
+    if (result.rules == null && (options.returnrules === true || options.output.includes("sarif"))) {
         const configAllFileName = await getConfigFileName(__dirname, null, [".groovylintrc-all.json"]);
-        const grooylintrcAllRules = Object.keys(JSON.parse(fse.readFileSync(configAllFileName, "utf8").toString()).rules);
+        const grooylintrcAllRules = Object.keys(JSON.parse(fs.readFileSync(configAllFileName, "utf8").toString()).rules);
         const rules = {};
         for (const ruleDef of codeNarcJsonResult.rules) {
             const ruleName = ruleDef.name;
@@ -295,7 +302,7 @@ async function buildRuleSets(options) {
         const normalizedRulesets = rulesetSplits.map(rulesetFile => {
             const fullFile = path.resolve(rulesetFile);
             // Encode file name so CodeNarc understands it
-            if (fse.exists(fullFile)) {
+            if (fs.existsSync(fullFile)) {
                 return "file:" + encodeURIComponent(fullFile);
             }
             // File name has already been encoded: let it as it is (will make CodeNarc fail if file not existing)
@@ -337,8 +344,8 @@ async function buildRuleSets(options) {
                 typeof ruleFromConfig === "object"
                     ? Object.assign(ruleFromConfig, ruleOptions)
                     : Object.keys(ruleOptions).length > 0
-                    ? ruleOptions
-                    : ruleFromConfig;
+                        ? ruleOptions
+                        : ruleFromConfig;
             const ruleDef = buildCodeNarcRule(ruleName, mergedRuleConfig);
             return ruleDef;
         });
@@ -355,8 +362,8 @@ async function buildRuleSets(options) {
                     typeof ruleDef === "object"
                         ? Object.assign(ruleDef, ruleFromRuleSetsArg)
                         : Object.keys(ruleFromRuleSetsArg).length > 0
-                        ? ruleFromRuleSetsArg
-                        : ruleDef;
+                            ? ruleFromRuleSetsArg
+                            : ruleDef;
             }
             // Add in the list of rules to test , except if it is disabled
             if (!(ruleDef === "off" || ruleDef.disabled === true || ruleDef.enabled === false)) {
@@ -415,7 +422,7 @@ function getCodeNarcPriorityCode(ruleFromConfig) {
 async function manageDeleteTmpFiles(tmpGroovyFileName) {
     // Remove temporary groovy file created for source argument if provided
     if (tmpGroovyFileName) {
-        await fse.remove(tmpGroovyFileName);
+        await fs.remove(tmpGroovyFileName);
         debug(`Removed temp file ${tmpGroovyFileName} as it is not longer used`);
         tmpGroovyFileName = null;
     }

package/lib/example/file with spaces.groovy

@@ -0,0 +1,56 @@
+import groovy.io.FileType
+import groovy.json.*
+import groovy.time.TimeCategory
+import static groovyx.gpars.GParsPool.withPool
+
+        def script = new GroovyScriptEngine( "." ).with{
+                loadScriptByName( 'Utils.groovy' ) ;
+   }
+this.metaClass.mixin script
+
+def returnCode = 0
+         Exception eThrow = null ;
+   try {
+    initialize(args) ;
+} catch (Exception e){
+                 eThrow = e ;
+    returnCode = 1
+             }
+          if (eThrow == null){
+                      return 0 ;
+}
+else {
+         throw eThrow ;
+    return 1 ;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////// SCRIPT /////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+def initialize(args3) {   //
+    def executor = new TestExecutor(args3)
+    return executor
+}
+
+class TestExecutor {
+
+    public TestExecutor( args2) {
+        this.testExternalGlobalProps()
+    }
+
+    public testExternalGlobalProps() {
+        Utils.printlnLog( '########## testExternalGlobalProps')
+        def globalKeyName = new Random().with { (1..9).collect { (('a'..'z')).join()[ nextInt((('a'..'z')).join().length())]}.join()}
+        Utils.printlnLog( "Generated random key: ${globalKeyName}")
+        Utils.setExternalValue(globalKeyName , 'lelama' , 'nul')
+        def storedValue = Utils.getExternalValue(globalKeyName , 'lelama')
+        assert storedValue == 'nul' , 'Error in global prop key storage/ retrieval (1)'
+        Utils.setExternalValue(globalKeyName , 'lelama2' , 'nul2')
+        def storedValue2 = Utils.getExternalValue(globalKeyName , 'lelama2')
+        assert storedValue2 == 'nul2' , 'Error in global prop key storage/ retrieval (2)'
+        def storedValueBack = Utils.getExternalValue(globalKeyName , 'lelama')
+        assert storedValueBack == 'nul' , 'Error in global prop key storage/ retrieval (3)'
+        Utils.printlnLog( Utils.getExternalValue(globalKeyName))
+    }
+
+}

package/lib/groovy-lint.js

@@ -10,7 +10,7 @@ const { NPM_GROOVY_LINT_CONSTANTS, loadConfig, getConfigFileName } = require("./
 const optionsDefinition = require("./options");
 const { computeStats, processOutput } = require("./output.js");
 const { recordAnonymousEvent } = require("./analytics.js");
-const { getSourceLines, isErrorInLogLevelScope } = require("./utils");
+const { getNpmGroovyLintVersion, getSourceLines, isErrorInLogLevelScope } = require("./utils");
 
 class NpmGroovyLint {
     "use strict";
@@ -179,16 +179,7 @@ class NpmGroovyLint {
 
         // Show version
         if (this.options.version) {
-            let v = process.env.npm_package_version;
-            if (!v) {
-                try {
-                    const FindPackageJson = require("find-package-json");
-                    const finder = FindPackageJson(__dirname);
-                    v = finder.next().value.version;
-                } catch {
-                    v = "error";
-                }
-            }
+            const v = getNpmGroovyLintVersion();
 
             const codeNarcVersionLinter = await new NpmGroovyLint([process.execPath, "", "--codenarcargs", "-version"], {}).run();
             const codeNarcVersionLines = [(await getSourceLines(codeNarcVersionLinter.codeNarcStdOut))[0]];

package/lib/options.js

@@ -119,8 +119,8 @@ module.exports = optionator({
             alias: "o",
             type: "String",
             default: "txt",
-            description: "Output format (txt,json,html,xml), or path to a file with one of these extensions",
-            example: ["txt", "json", "./logs/myLintResults.txt", "./logs/myLintResults.json", "./logs/myLintResults.html", "./logs/myLintResults.xml"]
+            description: "Output format (txt,json,sarif,html,xml), or path to a file with one of these extensions",
+            example: ["txt", "json", "sarif", "./logs/myLintResults.txt", "./logs/myLintResults.json","./logs/myLintResults.sarif", "./logs/myLintResults.html", "./logs/myLintResults.xml"]
         },
         {
             option: "loglevel",

package/lib/output.js

@@ -1,8 +1,9 @@
 // Output management
 const c = require("ansi-colors");
 const fse = require("fs-extra");
+const { SarifBuilder, SarifRunBuilder, SarifResultBuilder, SarifRuleBuilder } = require("node-sarif-builder");
 const path = require("path");
-const { isErrorInLogLevelScope } = require("./utils");
+const { isErrorInLogLevelScope, getNpmGroovyLintVersion } = require("./utils");
 
 // Compute statistics for output
 function computeStats(lintResult) {
@@ -204,8 +205,81 @@ async function processOutput(outputType, output, lintResult, options, fixer = nu
             outputString = JSON.stringify(lintResult);
             console.log(outputString);
         }
+    } else if (outputType === "sarif") {
+        const sarifJsonString = buildSarifResult(lintResult);
+        // SARIF file
+        if (output.endsWith(".sarif")) {
+            fse.writeFileSync(output, sarifJsonString);
+            const absolutePath = path.resolve(".", output);
+            outputString = "GroovyLint: Logged SARIF results in file " + absolutePath;
+            console.info(outputString);
+        } else {
+            // SARIF in stdout
+            outputString = sarifJsonString;
+            console.log(sarifJsonString);
+        }
     }
     return outputString;
 }
 
+function buildSarifResult(lintResult) {
+    // SARIF builder
+    const sarifBuilder = new SarifBuilder();
+    // SARIF Run builder
+    const sarifRunBuilder = new SarifRunBuilder().initSimple({
+        toolDriverName: "npm-groovy-lint",
+        toolDriverVersion: getNpmGroovyLintVersion(),
+        url: "https://nvuillam.github.io/npm-groovy-lint/"
+    });
+    // SARIF rules
+    for (const ruleId of Object.keys(lintResult.rules || {})) {
+        const rule = lintResult.rules[ruleId];
+        const sarifRuleBuilder = new SarifRuleBuilder().initSimple({
+            ruleId: ruleId,
+            shortDescriptionText: rule.description,
+            helpUri: rule.docUrl
+        });
+        sarifRunBuilder.addRule(sarifRuleBuilder);
+    }
+    // Add SARIF results (individual errors)
+    for (const fileNm of Object.keys(lintResult.files)) {
+        const fileErrors = lintResult.files[fileNm].errors;
+        for (const err of fileErrors) {
+            const sarifResultBuilder = new SarifResultBuilder();
+            const sarifResultInit = {
+                level: err.severity === "info" ? "note" : err.severity, // Other values can be "warning" or "error"
+                messageText: err.msg,
+                ruleId: err.rule,
+                fileUri: process.env.SARIF_URI_ABSOLUTE
+                    ? "file:///" + fileNm.replace(/\\/g, "/")
+                    : path.relative(process.cwd(), fileNm)
+            };
+            if (err && err.range && err.range.start && (err.range.start.line === 0 || err.range.start.line > 0)) {
+                sarifResultInit.startLine = fixLine(err.range.start.line);
+                sarifResultInit.startColumn = fixCol(err.range.start.character);
+                sarifResultInit.endLine = fixLine(err.range.end.line);
+                sarifResultInit.endColumn = fixCol(err.range.end.character);
+            }
+            sarifResultBuilder.initSimple(sarifResultInit);
+            sarifRunBuilder.addResult(sarifResultBuilder);
+        }
+    }
+    sarifBuilder.addRun(sarifRunBuilder);
+    return sarifBuilder.buildSarifJsonString({ indent: false });
+}
+
+function fixLine(val) {
+    if (val === null) {
+        return undefined;
+    }
+    return val === 0 ? 1 : val;
+}
+
+function fixCol(val) {
+    if (val === null) {
+        return undefined;
+    }
+    return val === 0 ? 1 : val + 1;
+}
+
 module.exports = { computeStats, processOutput };

package/lib/rules/MethodReturnTypeRequired.js

@@ -0,0 +1,21 @@
+// Too many methods in a class
+
+const { getVariableRange } = require("../utils");
+
+const rule = {
+    variables: [
+        {
+            name: "METHODNAME",
+            regex: /Method "(.*)" has a dynamic return type/,
+            regexPos: 1
+        }
+    ],
+    range: {
+        type: "function",
+        func: (errLine, errItem, evaluatedVars) => {
+            return getVariableRange(errLine, evaluatedVars, "METHODNAME", errItem);
+        }
+    }
+};
+
+module.exports = { rule };

package/lib/rules/UnusedImport.js

@@ -1,6 +1,6 @@
 // Unused import
 
-const { getVariable } = require("../utils");
+const { getVariable, getVariableRange } = require("../utils");
 
 const rule = {
     scope: "file",
@@ -12,6 +12,12 @@ const rule = {
             regexPos: 1
         }
     ],
+    range: {
+        type: "function",
+        func: (errLine, errItem, evaluatedVars) => {
+            return getVariableRange(errLine, evaluatedVars, "CLASSNAME", errItem);
+        }
+    },
     fix: {
         label: "Remove unused import",
         type: "function",

package/lib/utils.js

@@ -394,6 +394,20 @@ function splitMulti(str, tokens) {
     return str;
 }
 
+function getNpmGroovyLintVersion(){
+    let v = process.env.npm_package_version;
+    if (!v) {
+        try {
+            const FindPackageJson = require("find-package-json");
+            const finder = FindPackageJson(__dirname);
+            v = finder.next().value.version;
+        } catch {
+            v = "error";
+        }
+    }
+    return v ;
+}
+
 module.exports = {
     addImport,
     addSpaceAfterChar,
@@ -405,6 +419,7 @@ module.exports = {
     findRangeBetweenStrings,
     getIndentLength,
     getLastStringRange,
+    getNpmGroovyLintVersion,
     getOutOfBracesStrings,
     getSourceLines,
     getStringRange,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-groovy-lint",
-  "version": "9.3.0",
+  "version": "9.4.1",
   "description": "Lint, format and auto-fix your Groovy / Jenkinsfile / Gradle files",
   "main": "index.js",
   "scripts": {
@@ -48,7 +48,7 @@
     "ansi-colors": "^4.1.1",
     "axios": "^0.21.1",
     "chalk": "^4.1.2",
-    "cli-progress": "^3.6.0",
+    "cli-progress": "^3.10.0",
     "debug": "^4.1.1",
     "decode-html": "^2.0.0",
     "find-java-home": "^1.1.0",
@@ -58,6 +58,7 @@
     "import-fresh": "^3.2.1",
     "ip": "^1.1.5",
     "java-caller": "^2.2.4",
+    "node-sarif-builder": "^2.0.1",
     "optionator": "^0.8.3",
     "semver": "^7.1.3",
     "strip-json-comments": "^3.0.1",
@@ -75,7 +76,7 @@
     "eslint-plugin-standard": "^5.0.0",
     "mocha": "^7.0.1",
     "nyc": "^15.1.0",
-    "prettier": "1.19.1",
+    "prettier": "^1.19.1",
     "rimraf": "^3.0.2",
     "which": "^2.0.2"
   },