isml-linter 5.40.5 → 5.42.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [5.42.0] - 2023-01-25
+
+### Added
+ - Introducing ["strict-void-elements" rule][strict-void-elements-readme];
+
+### Changed
+ - Allow Closing Tags for Void Elements in AST. "strict-void-elements" rule will optionally handle that invalid scenario;
+
+### Fixed
+ - "indent" Rule - Add "line" Attribute to Quote Issue Report;
+ 
+## [5.41.0] - 2023-01-21
+
+### Added
+ - Exposed "fix" method in [ISML Linter API][api-docs];
+
+### Fixed
+ - Line-by-line and tree rules issues now are fixed in a single ISML Linter execution, not in two steps anymore;
+ 
 ## [5.40.5] - 2023-01-15
 
 ### Fixed
@@ -1040,6 +1059,8 @@
 ### Added
 - Linter is published;
 
+[5.42.0]: https://github.com/FabiowQuixada/isml-linter/compare/v5.41.0...v5.42.0
+[5.41.0]: https://github.com/FabiowQuixada/isml-linter/compare/v5.40.5...v5.41.0
 [5.40.5]: https://github.com/FabiowQuixada/isml-linter/compare/v5.40.4...v5.40.5
 [5.40.4]: https://github.com/FabiowQuixada/isml-linter/compare/v5.40.3...v5.40.4
 [5.40.3]: https://github.com/FabiowQuixada/isml-linter/compare/v5.40.2...v5.40.3
@@ -1202,11 +1223,12 @@
 [api-docs]: <docs/api.md>
 [license]:  <LICENSE>
 
-[disallow-tags-readme]:      <docs/rules/disallow-tags.md>
-[no-br-readme]:              <docs/rules/no-br.md>
-[no-inline-style-readme]:    <docs/rules/no-br.md>
-[no-isscript-readme]:        <docs/rules/no-isscript.md>
-[enforce-security-readme]:   <docs/rules/enforce-security.md>
-[no-hardcode-readme]:        <docs/rules/no-hardcode.md>
-[indent-readme]:             <docs/rules/indent.md>
-[eslint-to-isscript-readme]: <docs/rules/eslint-to-isscript.md>
+[strict-void-elements-readme]: <docs/rules/strict-void-elements.md>
+[disallow-tags-readme]:        <docs/rules/disallow-tags.md>
+[no-br-readme]:                <docs/rules/no-br.md>
+[no-inline-style-readme]:      <docs/rules/no-br.md>
+[no-isscript-readme]:          <docs/rules/no-isscript.md>
+[enforce-security-readme]:     <docs/rules/enforce-security.md>
+[no-hardcode-readme]:          <docs/rules/no-hardcode.md>
+[indent-readme]:               <docs/rules/indent.md>
+[eslint-to-isscript-readme]:   <docs/rules/eslint-to-isscript.md>

package/README.md

@@ -3,7 +3,7 @@ ISML Linter is a tool for examining if your project's templates follow a specifi
 
  - Styles that are defined by your team;
  - Syntactic errors related to `<is* >` tags;
- - Coding conventions recommended by SalesForce;
+ - Coding conventions recommended by Salesforce;
  - Git conflicts that may accidentally be left unresolved;
 
 Please feel free to make suggestions and help make this linter better. :) The set of currently available rules can be found below.
@@ -161,7 +161,7 @@ Please check the [Generic Configurations for Rules][generic-rule-config] page.
 | ------------------------------------------------------------------------------------ |:-----------------------------------------|
 | :exclamation: [no-br][no-br-readme]                                                  | <span style="color:orange">[Deprecated]</span> Disallows `<br/>` tags. Enable this rule if you prefer to use CSS to handle vertical spacing |
 | [no-git-conflict][no-git-conflict-readme]                                            | Disallows unresolved Git conflicts |
-| [no-import-package][no-import-package-readme]                                        | Disallows `importPackage()` function. It is recommended by SalesForce to use `require()` instead |
+| [no-import-package][no-import-package-readme]                                        | Disallows `importPackage()` function. It is recommended by Salesforce to use `require()` instead |
 | :exclamation: [no-isscript][no-isscript-readme]                                      | <span style="color:orange">[Deprecated]</span> Disallows `<isscript/>` tag in template. Enable this rule if you prefer logic to be kept in a separate .ds/.js file |
 | :wrench: [no-trailing-spaces][no-trailing-spaces-readme]                             | Disallows trailing blank spaces |
 | :wrench: [no-space-only-lines][no-space-only-lines-readme]                           | Disallows lines that contain only blank spaces, i.e., unnecessarily indented |
@@ -189,6 +189,7 @@ Please check the [Generic Configurations for Rules][generic-rule-config] page.
 | :small_orange_diamond: [align-isset][align-isset-readme]                             | Aligns contiguous `<isset>` tags attributes' columns |
 | :small_orange_diamond: [enforce-security][enforce-security-readme]                   | Enforces security measures |
 | :wrench: :small_orange_diamond: [no-redundant-context][no-redundant-context-readme]  | Prevents use of unnecessary contexts, such as `dw.web.Resource` |
+| :small_orange_diamond: [strict-void-elements][strict-void-elements-readme]  | Disallows closing tags for void elements, such as `<input>` and `<img>` |
 
 You are more than welcome to contribute with us! Please check the [contribute section][contribute-docs].
 
@@ -235,6 +236,7 @@ This project was conceived by its author without any financial support, with the
 [disallow-tags-readme]:          <docs/rules/disallow-tags.md>
 [enforce-security-readme]:       <docs/rules/enforce-security.md>
 [no-redundant-context-readme]:   <docs/rules/no-redundant-context.md>
+[strict-void-elements-readme]:   <docs/rules/strict-void-elements.md>
 
 [api-docs]:        <docs/api.md>
 [cli-docs]:        <docs/cli.md>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isml-linter",
-  "version": "5.40.5",
+  "version": "5.42.0",
   "author": "Fabiow Quixadá <ftquixada@gmail.com>",
   "license": "MIT",
   "main": "src/publicApi.js",

package/scaffold_files/ismllinter.config.js

@@ -38,6 +38,7 @@ const config = {
             values : ['isscript', 'br', 'style', 'iframe']
         },
         'enforce-security'     : {},
+        'strict-void-elements' : {},
 
         // Other
         'lowercase-filename' : {}

package/src/IsmlLinter.js

@@ -101,12 +101,12 @@ const getEmptyResult = () => {
     };
 };
 
-const checkTemplate = (templatePath, data, content, templateName) => {
+const parseAndPossiblyFixTemplate = (templatePath, data, content, templateName) => {
     const formattedTemplatePath = GeneralUtils.formatTemplatePath(templatePath);
     const templateResults       = getEmptyResult();
 
     try {
-        const parseResult = RuleUtils.checkTemplate(templatePath, data, content, templateName);
+        const parseResult = RuleUtils.parseAndPossiblyFixTemplate(templatePath, data, content, templateName);
 
         if (parseResult.fixed) {
             templateResults.templatesFixed++;
@@ -232,7 +232,7 @@ Linter.run = (pathData, content, data = {}) => {
             const isIgnored    = FileUtils.isIgnored(templatePath);
 
             if (!isIgnored) {
-                const templateResults = checkTemplate(templatePath, data, content, templateName);
+                const templateResults = parseAndPossiblyFixTemplate(templatePath, data, content, templateName);
 
                 finalResult = merge(finalResult, templateResults);
             }

package/src/isml_tree/IsmlNode.js

@@ -149,6 +149,7 @@ class IsmlNode {
         newNode.isEmbeddedNode = this.isEmbeddedNode;
     }
 
+    getChild(number) { return this.children[number];                   }
     getLastChild()   { return this.children[this.children.length - 1]; }
     getChildrenQty() { return this.children.length;                    }
     hasChildren()    { return this.children.length > 0;                }

package/src/isml_tree/ParseUtils.js

@@ -136,7 +136,7 @@ const parseNextElement = state => {
     }
 
     state.elementList.push(newElement);
-    
+
     if (newElement.type === 'htmlTag' && newElement.value.indexOf('<isif') >= 0 && newElement.value.indexOf('</isif') < 0) {
         throw ExceptionUtils.invalidNestedIsifError(
             newElement.tagType,

package/src/isml_tree/TreeBuilder.js

@@ -110,14 +110,8 @@ const parseContainerElements = (element, currentParent, newNode, templatePath) =
 
 const parseNonContainerElements = (element, currentParent, newNode, templatePath) => {
     if (element.isSelfClosing) {
-        if (element.isClosingTag && element.isVoidElement) {
-            throw ExceptionUtils.voidElementClosingTag(
-                element.tagType,
-                element.lineNumber,
-                element.globalPos,
-                element.value.trim().length,
-                templatePath
-            );
+        if (element.isClosingTag  && element.isVoidElement) {
+            currentParent.getLastChild().setTail(element.value, element.lineNumber, element.columnNumber, element.globalPos);
         } else {
             currentParent.addChild(newNode);
         }

package/src/publicApi.js

@@ -14,8 +14,23 @@ module.exports = {
         }
 
         linterResult = IsmlLinter.run(path, content);
+
         return linterResult;
     },
+    fix          : (path, content, config) => {
+        let autofixConfig = config;
+
+        if (config) {
+            autofixConfig.autoFix = true;
+            IsmlLinter.setConfig(autofixConfig);
+        } else {
+            autofixConfig         = IsmlLinter.getConfig();
+            autofixConfig.autoFix = true;
+            IsmlLinter.setConfig(autofixConfig);
+        }
+
+        return IsmlLinter.run(path, content, autofixConfig);
+    },
     printResults : ()    => ConsoleUtils.displayOccurrenceList(linterResult),
     build        : path  => Builder.run(path),
 

package/src/rules/prototypes/SingleLineRulePrototype.js

@@ -41,7 +41,10 @@ SingleLineRulePrototype.check = function(templateContent, data = { isCrlfLineBre
         };
     }
 
-    return { occurrenceList };
+    return {
+        occurrenceList,
+        fixedContent : templateContent
+    };
 };
 
 module.exports = SingleLineRulePrototype;

package/src/rules/tree/indent.js

@@ -161,8 +161,14 @@ Rule.isQuoteClosingCharBroken = function(node) {
                     '';
 
             if (message) {
+                const line = node
+                    .getRoot()
+                    .toString()
+                    .split(Constants.EOL)[lineNumber - 1];
+
                 result.push({
                     quoteChar    : attribute.quoteChar,
+                    line         : line,
                     lineNumber   : lineNumber,
                     columnNumber : columnNumber,
                     globalPos    : globalPos,

package/src/rules/tree/strict-void-elements.js

@@ -0,0 +1,46 @@
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = 'This is a void element, and as such, should not have a corresponding closing tag';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.isBroken = function(node) {
+    return node.isVoidElement() && node.tail.length > 0;
+};
+
+Rule.check = function(node, data) {
+
+    const ruleConfig   = this.getConfigs();
+    let occurrenceList = [];
+
+    occurrenceList = this.checkChildren(node, data);
+
+    if (this.isBroken(node)) {
+        const error = this.getError(
+            node.tail.trim(),
+            node.tailLineNumber,
+            node.tailColumnNumber,
+            node.tailGlobalPos,
+            node.tail.trim().length,
+            `"<${node.getType()}>" is a void element, and as such, should not have a corresponding closing tag`
+        );
+
+        occurrenceList.push(error);
+    }
+
+    return this.return(node, occurrenceList, ruleConfig);
+};
+
+Rule.getFixedContent = node => {
+
+    if (node.isVoidElement()) {
+        node.setTail('', null, null, null);
+    }
+
+    return node.toString();
+};
+
+module.exports = Rule;

package/src/util/ConfigUtils.js

@@ -158,7 +158,7 @@ const existEslintConfigFile = () => {
         FileUtils.fileExists(Constants.eslintConfigFilePathList[2]);
 };
 
-const isTestEnv = () => process.env.NODE_ENV === Constants.ENV_TEST;
+const isTestEnv = () => process.env.NODE_ENV === Constants.ENV_TEST && !global.isSimulatingProductionEnvironment;
 
 const setLocalConfig = configParam => {
     if (isTestEnv()) {

package/src/util/RuleUtils.js

@@ -64,7 +64,7 @@ const checkCustomTag = tag => {
     }
 };
 
-const applyRuleResult = (config, ruleResult, templatePath, templateResults, rule) => {
+const fixTemplateOrReportIssues = (config, ruleResult, templatePath, templateResults, rule) => {
     if (config.autoFix && ruleResult.fixedContent) {
         fs.writeFileSync(templatePath, ruleResult.fixedContent);
         templateResults.fixed = true;
@@ -78,7 +78,7 @@ const applyRuleResult = (config, ruleResult, templatePath, templateResults, rule
     }
 };
 
-const applyRuleOnTemplate = (ruleArray, templatePath, root, config, data) => {
+const fixTemplateOrReportIssuesForRuleList = (ruleArray, templatePath, root, config, data) => {
     const templateResults = {
         fixed    : false,
         errors   : {},
@@ -92,8 +92,9 @@ const applyRuleOnTemplate = (ruleArray, templatePath, root, config, data) => {
         if (!rule.shouldIgnore(templatePath)) {
             try {
                 ConsoleUtils.displayVerboseMessage(`Applying "${rule.id}" rule`, 1);
-                const ruleResults = rule.check(root, templateResults.data);
-                applyRuleResult(config, ruleResults, templatePath, templateResults, rule);
+                const ruleResults            = rule.check(root, templateResults.data);
+                templateResults.finalContent = ruleResults.fixedContent;
+                fixTemplateOrReportIssues(config, ruleResults, templatePath, templateResults, rule);
 
             } catch (error) {
                 throw ExceptionUtils.ruleApplianceError(rule, error, templatePath);
@@ -111,10 +112,10 @@ const findNodeOfType = (node, type) => {
         if (child.isOfType(type)) {
             result = child;
             return true;
-        } else {
-            result = findNodeOfType(child, type) || result;
         }
 
+        result = findNodeOfType(child, type) || result;
+
         return false;
     });
 
@@ -169,7 +170,7 @@ const checkFileName = (filename, templateContent) => {
     return templateResults;
 };
 
-const checkTreeRules = (templatePath, templateContent, config, data) => {
+const checkAndPossiblyFixTreeRules = (templatePath, templateContent, config, data) => {
     if (!config.disableTreeParse) {
         ConsoleUtils.displayVerboseMessage(`Building tree for "${templatePath}"`, 1);
         const tree = TreeBuilder.build(templatePath, templateContent);
@@ -180,7 +181,7 @@ const checkTreeRules = (templatePath, templateContent, config, data) => {
 
         const ruleArray = getEnabledTreeRules();
 
-        return applyRuleOnTemplate(
+        return fixTemplateOrReportIssuesForRuleList(
             ruleArray,
             templatePath,
             tree.rootNode,
@@ -189,10 +190,10 @@ const checkTreeRules = (templatePath, templateContent, config, data) => {
     }
 };
 
-const checkLineByLineRules = (templatePath, templateContent, config, data) => {
+const checkAndPossiblyFixLineByLineRules = (templatePath, templateContent, config, data) => {
     const ruleArray = getEnabledLineRules();
 
-    return applyRuleOnTemplate(
+    return fixTemplateOrReportIssuesForRuleList(
         ruleArray,
         templatePath,
         templateContent,
@@ -221,12 +222,12 @@ const checkCustomModules = () => {
     return moduleResults;
 };
 
-const checkTemplate = (templatePath, data, content = '', templateName = '') => {
+const parseAndPossiblyFixTemplate = (templatePath, data, content = '', templateName = '') => {
     ConsoleUtils.displayVerboseMessage(`\nChecking "${templatePath}" template`);
     const config          = ConfigUtils.load();
     const templateContent = GeneralUtils.toLF(content || fs.readFileSync(templatePath, 'utf-8'));
-    const lineResults     = checkLineByLineRules(templatePath, templateContent, config, data);
-    const treeResults     = checkTreeRules(templatePath, templateContent, config, data) || { errors : [] };
+    const lineResults     = checkAndPossiblyFixLineByLineRules(templatePath, templateContent, config, data);
+    const treeResults     = checkAndPossiblyFixTreeRules(templatePath, lineResults.finalContent, config, data) || { errors : [] };
     const filenameResults = checkFileName(templateName, templateContent);
 
     return {
@@ -289,7 +290,7 @@ const getEnabledTreeRules = () => {
 module.exports.getAllLineRules             = () => lineByLineRules;
 module.exports.findNodeOfType              = findNodeOfType;
 module.exports.isTypeAmongTheFirstElements = isTypeAmongTheFirstElements;
-module.exports.checkTemplate               = checkTemplate;
+module.exports.parseAndPossiblyFixTemplate = parseAndPossiblyFixTemplate;
 module.exports.checkCustomModules          = checkCustomModules;
 module.exports.getAvailableRulesQty        = getAvailableRulesQty;
 module.exports.getLevelGroup               = getLevelGroup;

package/src/util/TempRuleUtils.js

@@ -6,7 +6,6 @@
     ===========================================================================
 **/
 
-const path                  = require('path');
 const fs                    = require('fs');
 const Constants             = require('../Constants');
 const TreeBuilder           = require('../isml_tree/TreeBuilder');
@@ -38,7 +37,7 @@ const checkCustomTag = tag => {
     }
 };
 
-const applyRuleResult = (config, ruleResult, templatePath, templateResults, rule) => {
+const fixTemplateOrReportIssues = (config, ruleResult, templatePath, templateResults, rule) => {
     if (config.autoFix && ruleResult.fixedContent) {
         fs.writeFileSync(templatePath, ruleResult.fixedContent);
         templateResults.fixed = true;
@@ -49,7 +48,7 @@ const applyRuleResult = (config, ruleResult, templatePath, templateResults, rule
     }
 };
 
-const applyRuleOnTemplate = (ruleArray, templatePath, root, config) => {
+const fixTemplateOrReportIssuesForRuleList = (ruleArray, templatePath, root, config) => {
     const templateResults = {
         fixed  : false,
         errors : {}
@@ -59,7 +58,7 @@ const applyRuleOnTemplate = (ruleArray, templatePath, root, config) => {
         const rule = ruleArray[i];
         if (!rule.shouldIgnore(templatePath)) {
             const ruleResults = rule.check(root, templateResults.data);
-            applyRuleResult(config, ruleResults, templatePath, templateResults, rule);
+            fixTemplateOrReportIssues(config, ruleResults, templatePath, templateResults, rule);
         }
     }
 
@@ -130,7 +129,7 @@ const checkFileName = (filename, templateContent) => {
     return templateResults;
 };
 
-const checkTreeRules = (templatePath, templateContent, config) => {
+const checkAndPossiblyFixTreeRules = (templatePath, templateContent, config) => {
     if (!config.disableTreeParse) {
         const tree = TreeBuilder.build(templatePath, templateContent);
 
@@ -140,7 +139,7 @@ const checkTreeRules = (templatePath, templateContent, config) => {
 
         const ruleArray = getEnabledTreeRules();
 
-        return applyRuleOnTemplate(
+        return fixTemplateOrReportIssuesForRuleList(
             ruleArray,
             templatePath,
             tree.rootNode,
@@ -148,10 +147,10 @@ const checkTreeRules = (templatePath, templateContent, config) => {
     }
 };
 
-const checkLineByLineRules = (templatePath, templateContent, config) => {
+const checkAndPossiblyFixLineByLineRules = (templatePath, templateContent, config) => {
     const ruleArray = getEnabledLineRules();
 
-    return applyRuleOnTemplate(
+    return fixTemplateOrReportIssuesForRuleList(
         ruleArray,
         templatePath,
         templateContent,
@@ -176,11 +175,11 @@ const checkCustomModules = () => {
     return moduleResults;
 };
 
-const checkTemplate = (templatePath, content, templateName) => {
+const parseAndPossiblyFixTemplate = (templatePath, content, templateName) => {
     const config          = ConfigUtils.load();
     const templateContent = content || fs.readFileSync(templatePath, 'utf-8');
-    const lineResults     = checkLineByLineRules(templatePath, templateContent, config);
-    const treeResults     = checkTreeRules(templatePath, templateContent, config) || { errors : [] };
+    const lineResults     = checkAndPossiblyFixLineByLineRules(templatePath, templateContent, config);
+    const treeResults     = checkAndPossiblyFixTreeRules(templatePath, templateContent, config) || { errors : [] };
     const filenameResults = checkFileName(templateName, templateContent);
 
     return {
@@ -227,6 +226,6 @@ const getEnabledTreeRules = () => {
 module.exports.getAllLineRules             = () => lineByLineRules;
 module.exports.findNodeOfType              = findNodeOfType;
 module.exports.isTypeAmongTheFirstElements = isTypeAmongTheFirstElements;
-module.exports.checkTemplate               = checkTemplate;
+module.exports.parseAndPossiblyFixTemplate = parseAndPossiblyFixTemplate;
 module.exports.checkCustomModules          = checkCustomModules;
 module.exports.getAvailableRulesQty        = getAvailableRulesQty;