isml-linter 5.38.2 → 5.39.0

package/src/rules/tree/no-deprecated-attrs.js

@@ -1,5 +1,5 @@
 const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const SfccTags          = require('../../enums/SfccTags');
+const SfccTagContainer  = require('../../enums/SfccTagContainer');
 
 const ruleId      = require('path').basename(__filename).slice(0, -3);
 const description = 'Attribute label or value is deprecated';
@@ -15,7 +15,7 @@ Rule.isBroken = function(node) {
 
     const attrList = node.getAttributeList();
     const nodeType = node.getType();
-    const obj      = SfccTags[nodeType];
+    const obj      = SfccTagContainer[nodeType];
     let result     = null;
 
     if (node.isStandardIsmlTag()) {
@@ -48,9 +48,9 @@ Rule.check = function(node, data) {
     const occurrence = this.isBroken(node);
     if (occurrence) {
         const error = this.getError(
-            node.value.trim(),
+            node.head.trim(),
             node.lineNumber,
-            node.columnNumber + node.value.trim().indexOf(occurrence.fullContent),
+            node.columnNumber + node.head.trim().indexOf(occurrence.fullContent),
             occurrence.attrGlobalPos,
             occurrence.length,
             occurrence.message

package/src/rules/tree/no-embedded-isml.js

@@ -10,8 +10,8 @@ Rule.init(ruleId, description);
 Rule.isBroken = function(node) {
     return node.isHtmlTag() &&
         !node.isOfType('is') &&
-        node.value.indexOf('<isprint') === -1 &&
-        node.value.indexOf('<is') >= 0;
+        node.head.indexOf('<isprint') === -1 &&
+        node.head.indexOf('<is') >= 0;
 };
 
 module.exports = Rule;

package/src/rules/tree/no-hardcode.js

@@ -18,25 +18,25 @@ Rule.isBroken = function(node) {
     const ruleExceptionList  = this.getConfigs().except;
     const allowHtmlEntities  = this.getConfigs().allowHtmlEntities;
     const isTagContent       = isTagChild(node);
-    const shouldCheckValue   = node.isOfType('text') && !node.isExpression() && !isTagContent;
-    const isTextAnHtmlEntity = node.value.trim().startsWith('&') && node.value.trim().endsWith(';');
-    let nodeValue            = node.value;
+    const shouldCheckHead    = node.isOfType('text') && !node.isExpression() && !isTagContent;
+    const isTextAnHtmlEntity = node.head.trim().startsWith('&') && node.head.trim().endsWith(';');
+    let nodeHead             = node.head;
 
-    if (!shouldCheckValue) {
+    if (!shouldCheckHead) {
         return false;
     }
 
     for (let i = 0; i < ruleExceptionList.length; i++) {
         const char = ruleExceptionList[i];
 
-        nodeValue = nodeValue.split(char).join('');
+        nodeHead = nodeHead.split(char).join('');
     }
 
     if (allowHtmlEntities && isTextAnHtmlEntity) {
         return false;
     }
 
-    return nodeValue.trim().length > 0;
+    return nodeHead.trim().length > 0;
 };
 
 const isTagChild = node => {

package/src/rules/tree/no-iselse-slash.js

@@ -11,7 +11,7 @@ Rule.init(ruleId, description);
 
 Rule.isBroken = function(node) {
     return (node.isOfType('iselse') || node.isOfType('iselseif')) &&
-        node.value.trim().endsWith('/>');
+        node.head.trim().endsWith('/>');
 };
 
 Rule.getFixedContent = function(node) {
@@ -19,10 +19,10 @@ Rule.getFixedContent = function(node) {
         const child = node.children[i];
 
         if (child.isOfType('iselse') || child.isOfType('iselseif')) {
-            const slashPos = MaskUtils.maskInBetween(child.value, '${', '}').lastIndexOf('/');
+            const slashPos = MaskUtils.maskInBetween(child.head, '${', '}').lastIndexOf('/');
 
             if (slashPos >= 0) {
-                child.value = child.value.slice(0, slashPos) + child.value.slice(slashPos + 1);
+                child.head = child.head.slice(0, slashPos) + child.head.slice(slashPos + 1);
             }
         }
 

package/src/rules/tree/no-redundant-context.js

@@ -67,7 +67,7 @@ Rule.isBroken = function (node) {
     for (let i = 0; i < disallowedOccurrenceContainer.length; i++) {
         const disallowedOccurrence = disallowedOccurrenceContainer[i];
 
-        if (node.value.indexOf(disallowedOccurrence.key) >= 0) {
+        if (node.head.indexOf(disallowedOccurrence.key) >= 0) {
             return disallowedOccurrence;
         }
     }
@@ -82,9 +82,9 @@ Rule.check = function(node, data) {
     const disallowedOccurrence = this.isBroken(node);
 
     if (disallowedOccurrence) {
-        const trimmedValue   = node.value.trim();
-        const startPos       = trimmedValue.indexOf(disallowedOccurrence.key);
-        const beforeStartPos = trimmedValue.substring(0, startPos);
+        const trimmedHead    = node.head.trim();
+        const startPos       = trimmedHead.indexOf(disallowedOccurrence.key);
+        const beforeStartPos = trimmedHead.substring(0, startPos);
         const lineOffset     = ParseUtils.getLineBreakQty(beforeStartPos);
         let globalPos        = node.globalPos + startPos;
         const message        = getMessage(disallowedOccurrence);
@@ -94,9 +94,9 @@ Rule.check = function(node, data) {
         }
 
         const error = this.getError(
-            node.value.trim(),
+            node.head.trim(),
             node.lineNumber,
-            node.columnNumber + node.value.trim().indexOf(disallowedOccurrence.key) - 1,
+            node.columnNumber + node.head.trim().indexOf(disallowedOccurrence.key) - 1,
             globalPos,
             disallowedOccurrence.wrong.length,
             message
@@ -113,8 +113,8 @@ Rule.getFixedContent = function(node) {
     for (let i = 0; i < disallowedOccurrenceContainer.length; i++) {
         const disallowedOccurrence = disallowedOccurrenceContainer[i];
 
-        if (node.value.indexOf(disallowedOccurrence.key) >= 0) {
-            node.value = node.value
+        if (node.head.indexOf(disallowedOccurrence.key) >= 0) {
+            node.head = node.head
                 .split(disallowedOccurrence.key)
                 .join(disallowedOccurrence.correct);
         }

package/src/rules/tree/no-require-in-loop.js

@@ -11,7 +11,7 @@ Rule.init(ruleId, description);
 
 Rule.isBroken = function(node) {
 
-    if (node.value.indexOf('require(') === -1) {
+    if (node.head.indexOf('require(') === -1) {
         return false;
     }
 
@@ -34,11 +34,11 @@ Rule.check = function(node, data) {
     const occurrenceList = this.checkChildren(node, data);
 
     if (this.isBroken(node)) {
-        const trimmedValue   = node.value.trim();
-        const startPos       = trimmedValue.indexOf('require(');
-        const beforeStartPos = trimmedValue.substring(0, startPos);
+        const trimmedHead    = node.head.trim();
+        const startPos       = trimmedHead.indexOf('require(');
+        const beforeStartPos = trimmedHead.substring(0, startPos);
         const lineOffset     = ParseUtils.getLineBreakQty(beforeStartPos);
-        const afterStartPos  = trimmedValue.substring(startPos);
+        const afterStartPos  = trimmedHead.substring(startPos);
         const length         = afterStartPos.indexOf(')') + 1;
         let globalPos        = node.globalPos + startPos;
 
@@ -47,9 +47,9 @@ Rule.check = function(node, data) {
         }
 
         const error = this.getError(
-            node.value.trim(),
-            node.lineNumber,
-            node.columnNumber + node.value.trim().indexOf('require('),
+            node.head.trim(),
+            node.lineNumber + lineOffset,
+            node.columnNumber + node.head.trim().indexOf('require('),
             globalPos,
             length
         );

package/src/rules/tree/one-element-per-line.js

@@ -45,10 +45,10 @@ Rule.isBroken = function(node) {
 //             const indentation       = getCorrectIndentation(child);
 //             const parentIndentation = getCorrectIndentation(node);
 
-//             child.value = `${Constants.EOL}${indentation}${child.value}${Constants.EOL}${parentIndentation}`;
+//             child.head = `${Constants.EOL}${indentation}${child.head}${Constants.EOL}${parentIndentation}`;
 
-//             if (child.suffixValue) {
-//                 child.setSuffix(`${Constants.EOL}${indentation}${child.suffixValue}${Constants.EOL}`);
+//             if (child.tail) {
+//                 child.setTail(`${Constants.EOL}${indentation}${child.tail}${Constants.EOL}`);
 //             }
 //         }
 

package/src/util/ConsoleUtils.js

@@ -68,6 +68,10 @@ const displayUnparseableErrors = lintResult => {
             console.log(chalk`{red.bold ${Constants.EOL}An Isml abstract syntax tree could not be built for the following templates:}`);
 
             for (let i = 0; i < lintResult[INVALID_TEMPLATE].length; i++) {
+                if (config.printPartialResults && i > MAX_LISTED_ERRORS) {
+                    break;
+                }
+
                 const error = lintResult[INVALID_TEMPLATE][i];
                 console.log(chalk.gray(i) + ' ' + error.templatePath + ':' + error.lineNumber);
                 console.log('\t' + chalk`{red.bold >> }` + `${error.message}${Constants.EOL}`);
@@ -79,6 +83,29 @@ const displayUnparseableErrors = lintResult => {
     return partialSum;
 };
 
+const displayRuleErrors = lintResult => {
+
+    const RULE_ERROR = ExceptionUtils.types.RULE_ERROR;
+    const config     = ConfigUtils.load();
+    let partialSum   = 0;
+
+    if (lintResult[RULE_ERROR] && lintResult[RULE_ERROR].length > 0) {
+        console.log(chalk`{red.bold ${Constants.EOL}An unexpected error occurred while applying rules to the following templates:}`);
+
+        for (let i = 0; i < lintResult[RULE_ERROR].length; i++) {
+            if (config.printPartialResults && i > MAX_LISTED_ERRORS) {
+                break;
+            }
+
+            const error = lintResult[RULE_ERROR][i];
+            console.log(chalk.gray(i) + '\t' + error.ruleID + ' :\t' + error.templatePath);
+            partialSum++;
+        }
+    }
+
+    return partialSum;
+};
+
 const displayUnknownErrors = lintResult => {
     const UNKNOWN_ERROR = ExceptionUtils.types.UNKNOWN_ERROR;
     let partialSum      = 0;
@@ -103,6 +130,7 @@ const displayOccurrenceList = lintResult => {
 
     displayUnparseableErrors(lintResult);
     displayUnknownErrors(lintResult);
+    displayRuleErrors(lintResult);
 
     // TODO Add this 'config' as a global const;
     const config         = ConfigUtils.load();
@@ -144,7 +172,7 @@ const displayOccurrenceList = lintResult => {
         }
 
         if (config.printPartialResults) {
-            console.log(chalk`{bold Displaying the first ${MAX_LISTED_ERRORS} occurrenceList of each group.}` + Constants.EOL);
+            console.log(chalk`{bold Displaying the first ${MAX_LISTED_ERRORS} occurrences of each group.}` + Constants.EOL);
         }
     }
 };
@@ -275,11 +303,25 @@ const getInfoData = lintResult => {
     };
 };
 
+const displayVerboseMessage = (message, depth = 0) => {
+    const config    = ConfigUtils.load();
+    let indentation = '';
+
+    for (let i = 0; i < depth; i++) {
+        indentation += '    ';
+    }
+
+    if (config.verbose) {
+        console.log(indentation + message);
+    }
+};
+
 module.exports = {
     displayOccurrenceList,
     displayConfigError,
     displayEslintConfigError,
     displayInvalidTemplatesPaths,
     displayInvalidCommandError,
-    printExceptionMsg
+    printExceptionMsg,
+    displayVerboseMessage
 };

package/src/util/ExceptionUtils.js

@@ -5,6 +5,7 @@ const types = {
     UNCLOSED_DEPRECATED_ISML_COMMENT : 'UNCLOSED_DEPRECATED_ISML_COMMENT',
     INVALID_TEMPLATE                 : 'INVALID_TEMPLATE',
     INVALID_CHARACTER                : 'INVALID_CHARACTER',
+    RULE_ERROR                       : 'RULE_ERROR',
     NO_CONFIG                        : 'NO_CONFIG',
 };
 
@@ -20,6 +21,18 @@ const unbalancedElementError = (elementType, lineNumber, globalPos, length, temp
     };
 };
 
+const ruleApplianceError = (rule, originalError, templatePath) => {
+    return {
+        message      : `An error happened while applying rule "${rule.id}" to ${templatePath}`,
+        ruleID       : rule.id,
+        originalError,
+        lineNumber   : 0,
+        templatePath : templatePath,
+        isCustom     : true,
+        type         : types.RULE_ERROR
+    };
+};
+
 const unexpectedClosingElementError = (elementType, lineNumber, globalPos, length, templatePath) => {
     return {
         message      : `Unexpected </${elementType}> element`,
@@ -32,6 +45,18 @@ const unexpectedClosingElementError = (elementType, lineNumber, globalPos, lengt
     };
 };
 
+const unbalancedQuotesError = (elementType, lineNumber, globalPos, length, templatePath) => {
+    return {
+        message      : `Unbalanced quotes in <${elementType}> element`,
+        templatePath : templatePath,
+        globalPos,
+        length,
+        lineNumber   : lineNumber,
+        isCustom     : true,
+        type         : types.INVALID_TEMPLATE
+    };
+};
+
 const unclosedDeprecatedIsmlComment = (lineNumber, globalPos, length, templatePath) => {
     return {
         message      : '"<!---" element not correctly closed: use "--->" instead of "-->"',
@@ -92,6 +117,8 @@ const isLinterException = e => e && e.isCustom;
 
 module.exports = {
     parseError,
+    unbalancedQuotesError,
+    ruleApplianceError,
     unclosedDeprecatedIsmlComment,
     unbalancedElementError,
     unexpectedClosingElementError,

package/src/util/RuleUtils.js

@@ -4,9 +4,11 @@ const Constants             = require('../Constants');
 const TreeBuilder           = require('../isml_tree/TreeBuilder');
 const ConfigUtils           = require('./ConfigUtils');
 const lowercaseFilenameRule = require('../rules/line_by_line/lowercase-filename');
-const customTagContainer    = require('./CustomTagUtils');
+const CustomTagContainer    = require('./CustomTagContainer');
 const CustomModulesRule     = require('../rules/tree/custom-tags');
 const GeneralUtils          = require('./GeneralUtils');
+const ConsoleUtils          = require('./ConsoleUtils');
+const ExceptionUtils        = require('./ExceptionUtils');
 
 const lineByLineRules = [];
 const treeRules       = [];
@@ -41,8 +43,8 @@ const getLevelGroup = level => {
 };
 
 const checkCustomTag = tag => {
-    if (Object.prototype.hasOwnProperty.call(customTagContainer, tag)) {
-        const attrList = customTagContainer[tag].attrList;
+    if (Object.prototype.hasOwnProperty.call(CustomTagContainer, tag)) {
+        const attrList = CustomTagContainer[tag].attrList;
 
         for (let i = 0; i < attrList.length; i++) {
             const attr = attrList[i];
@@ -88,8 +90,14 @@ const applyRuleOnTemplate = (ruleArray, templatePath, root, config, data) => {
     for (let i = 0; i < ruleArray.length; i++) {
         const rule = ruleArray[i];
         if (!rule.shouldIgnore(templatePath)) {
-            const ruleResults = rule.check(root, templateResults.data);
-            applyRuleResult(config, ruleResults, templatePath, templateResults, rule);
+            try {
+                ConsoleUtils.displayVerboseMessage(`Applying "${rule.id}" rule`, 1);
+                const ruleResults = rule.check(root, templateResults.data);
+                applyRuleResult(config, ruleResults, templatePath, templateResults, rule);
+
+            } catch (error) {
+                throw ExceptionUtils.ruleApplianceError(rule, error, templatePath);
+            }
         }
     }
 
@@ -163,6 +171,7 @@ const checkFileName = (filename, templateContent) => {
 
 const checkTreeRules = (templatePath, templateContent, config, data) => {
     if (!config.disableTreeParse) {
+        ConsoleUtils.displayVerboseMessage(`Building tree for "${templatePath}"`, 1);
         const tree = TreeBuilder.build(templatePath, templateContent);
 
         if (!tree.rootNode) {
@@ -200,7 +209,7 @@ const checkCustomModules = () => {
     };
 
     if (CustomModulesRule.isEnabled()) {
-        for (const tag in customTagContainer) {
+        for (const tag in CustomTagContainer) {
             const occurrenceObj = checkCustomTag(tag);
 
             if (occurrenceObj) {
@@ -213,6 +222,7 @@ const checkCustomModules = () => {
 };
 
 const checkTemplate = (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);

package/src/util/TempRuleUtils.js

@@ -12,15 +12,15 @@ const Constants             = require('../Constants');
 const TreeBuilder           = require('../isml_tree/TreeBuilder');
 const ConfigUtils           = require('./ConfigUtils');
 const lowercaseFilenameRule = require('../rules/line_by_line/lowercase-filename');
-const customTagContainer    = require('./CustomTagUtils');
+const CustomTagContainer    = require('./CustomTagContainer');
 const CustomModulesRule     = require('../rules/tree/custom-tags');
 
 const lineByLineRules = [];
 const treeRules       = [];
 
 const checkCustomTag = tag => {
-    if (Object.prototype.hasOwnProperty.call(customTagContainer, tag)) {
-        const attrList = customTagContainer[tag].attrList;
+    if (Object.prototype.hasOwnProperty.call(CustomTagContainer, tag)) {
+        const attrList = CustomTagContainer[tag].attrList;
 
         for (let i = 0; i < attrList.length; i++) {
             const attr = attrList[i];
@@ -164,7 +164,7 @@ const checkCustomModules = () => {
     };
 
     if (CustomModulesRule.isEnabled()) {
-        for (const tag in customTagContainer) {
+        for (const tag in CustomTagContainer) {
             const errorObj = checkCustomTag(tag);
 
             if (errorObj) {