isml-linter 5.39.1 → 5.40.0

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

@@ -1,134 +1,134 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const ConfigUtils       = require('../../util/ConfigUtils');
-const ParseUtils        = require('../../isml_tree/ParseUtils');
-
-const ruleId                        = require('path').basename(__filename).slice(0, -3);
-const disallowedOccurrenceContainer = [
-
-    // dw.web.Resource;
-    {
-        key     : 'dw.web.Resource',
-        wrong   : 'dw.web.',
-        correct : 'Resource'
-    },
-    {
-        key     : 'require(\'dw/web/Resource\')',
-        wrong   : 'require(\'dw/web/Resource\')',
-        correct : 'Resource'
-    },
-    {
-        key     : 'require("dw/web/Resource")',
-        wrong   : 'require("dw/web/Resource")',
-        correct : 'Resource'
-    },
-
-
-    // dw.web.URLUtils;
-    {
-        key     : 'dw.web.URLUtils',
-        wrong   : 'dw.web.',
-        correct : 'URLUtils'
-    },
-    {
-        key     : 'require(\'dw/web/URLUtils\')',
-        wrong   : 'require(\'dw/web/URLUtils\')',
-        correct : 'URLUtils'
-    },
-    {
-        key     : 'require("dw/web/URLUtils")',
-        wrong   : 'require("dw/web/URLUtils")',
-        correct : 'URLUtils'
-    },
-
-
-    // dw.util.StringUtils;
-    {
-        key     : 'dw.util.StringUtils',
-        wrong   : 'dw.util.',
-        correct : 'StringUtils'
-    },
-    {
-        key     : 'require(\'dw/util/StringUtils\')',
-        wrong   : 'require(\'dw/util/StringUtils\')',
-        correct : 'StringUtils'
-    },
-    {
-        key     : 'require("dw/util/StringUtils")',
-        wrong   : 'require("dw/util/StringUtils")',
-        correct : 'StringUtils'
-    }
-];
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId);
-
-Rule.isBroken = function (node) {
-    for (let i = 0; i < disallowedOccurrenceContainer.length; i++) {
-        const disallowedOccurrence = disallowedOccurrenceContainer[i];
-
-        if (node.head.indexOf(disallowedOccurrence.key) >= 0) {
-            return disallowedOccurrence;
-        }
-    }
-
-    return null;
-};
-
-Rule.check = function(node, data) {
-
-    const config               = ConfigUtils.load();
-    const occurrenceList       = this.checkChildren(node, data);
-    const disallowedOccurrence = this.isBroken(node);
-
-    if (disallowedOccurrence) {
-        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);
-
-        if (data.isCrlfLineBreak) {
-            globalPos += lineOffset;
-        }
-
-        const error = this.getError(
-            node.head.trim(),
-            node.lineNumber,
-            node.columnNumber + node.head.trim().indexOf(disallowedOccurrence.key) - 1,
-            globalPos,
-            disallowedOccurrence.wrong.length,
-            message
-        );
-
-        occurrenceList.push(error);
-    }
-
-    return this.return(node, occurrenceList, config);
-};
-
-Rule.getFixedContent = function(node) {
-
-    for (let i = 0; i < disallowedOccurrenceContainer.length; i++) {
-        const disallowedOccurrence = disallowedOccurrenceContainer[i];
-
-        if (node.head.indexOf(disallowedOccurrence.key) >= 0) {
-            node.head = node.head
-                .split(disallowedOccurrence.key)
-                .join(disallowedOccurrence.correct);
-        }
-    }
-
-    for (let i = 0; i < node.children.length; i++) {
-        this.getFixedContent(node.children[i]);
-    }
-
-    return node.toString();
-};
-
-const getMessage = disallowedOccurrence => {
-    return `"${disallowedOccurrence.wrong}" is not necessary since "${disallowedOccurrence.correct}" is available globally`;
-};
-
-module.exports = Rule;
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+const ConfigUtils       = require('../../util/ConfigUtils');
+const ParseUtils        = require('../../isml_tree/ParseUtils');
+
+const ruleId                        = require('path').basename(__filename).slice(0, -3);
+const disallowedOccurrenceContainer = [
+
+    // dw.web.Resource;
+    {
+        key     : 'dw.web.Resource',
+        wrong   : 'dw.web.',
+        correct : 'Resource'
+    },
+    {
+        key     : 'require(\'dw/web/Resource\')',
+        wrong   : 'require(\'dw/web/Resource\')',
+        correct : 'Resource'
+    },
+    {
+        key     : 'require("dw/web/Resource")',
+        wrong   : 'require("dw/web/Resource")',
+        correct : 'Resource'
+    },
+
+
+    // dw.web.URLUtils;
+    {
+        key     : 'dw.web.URLUtils',
+        wrong   : 'dw.web.',
+        correct : 'URLUtils'
+    },
+    {
+        key     : 'require(\'dw/web/URLUtils\')',
+        wrong   : 'require(\'dw/web/URLUtils\')',
+        correct : 'URLUtils'
+    },
+    {
+        key     : 'require("dw/web/URLUtils")',
+        wrong   : 'require("dw/web/URLUtils")',
+        correct : 'URLUtils'
+    },
+
+
+    // dw.util.StringUtils;
+    {
+        key     : 'dw.util.StringUtils',
+        wrong   : 'dw.util.',
+        correct : 'StringUtils'
+    },
+    {
+        key     : 'require(\'dw/util/StringUtils\')',
+        wrong   : 'require(\'dw/util/StringUtils\')',
+        correct : 'StringUtils'
+    },
+    {
+        key     : 'require("dw/util/StringUtils")',
+        wrong   : 'require("dw/util/StringUtils")',
+        correct : 'StringUtils'
+    }
+];
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId);
+
+Rule.isBroken = function (node) {
+    for (let i = 0; i < disallowedOccurrenceContainer.length; i++) {
+        const disallowedOccurrence = disallowedOccurrenceContainer[i];
+
+        if (node.head.indexOf(disallowedOccurrence.key) >= 0) {
+            return disallowedOccurrence;
+        }
+    }
+
+    return null;
+};
+
+Rule.check = function(node, data) {
+
+    const config               = ConfigUtils.load();
+    const occurrenceList       = this.checkChildren(node, data);
+    const disallowedOccurrence = this.isBroken(node);
+
+    if (disallowedOccurrence) {
+        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);
+
+        if (data.isCrlfLineBreak) {
+            globalPos += lineOffset;
+        }
+
+        const error = this.getError(
+            node.head.trim(),
+            node.lineNumber,
+            node.columnNumber + node.head.trim().indexOf(disallowedOccurrence.key) - 1,
+            globalPos,
+            disallowedOccurrence.wrong.length,
+            message
+        );
+
+        occurrenceList.push(error);
+    }
+
+    return this.return(node, occurrenceList, config);
+};
+
+Rule.getFixedContent = function(node) {
+
+    for (let i = 0; i < disallowedOccurrenceContainer.length; i++) {
+        const disallowedOccurrence = disallowedOccurrenceContainer[i];
+
+        if (node.head.indexOf(disallowedOccurrence.key) >= 0) {
+            node.head = node.head
+                .split(disallowedOccurrence.key)
+                .join(disallowedOccurrence.correct);
+        }
+    }
+
+    for (let i = 0; i < node.children.length; i++) {
+        this.getFixedContent(node.children[i]);
+    }
+
+    return node.toString();
+};
+
+const getMessage = disallowedOccurrence => {
+    return `"${disallowedOccurrence.wrong}" is not necessary since "${disallowedOccurrence.correct}" is available globally`;
+};
+
+module.exports = Rule;

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

@@ -1,63 +1,63 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const ConfigUtils       = require('../../util/ConfigUtils');
-const ParseUtils        = require('../../isml_tree/ParseUtils');
-
-const ruleId      = require('path').basename(__filename).slice(0, -3);
-const description = '"require()" call is not allowed within a loop';
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId, description);
-
-Rule.isBroken = function(node) {
-
-    if (node.head.indexOf('require(') === -1) {
-        return false;
-    }
-
-    let iterator = node;
-
-    while (iterator.parent) {
-        iterator = iterator.parent;
-
-        if (iterator.isOfType('isloop')) {
-            return true;
-        }
-    }
-
-    return false;
-};
-
-Rule.check = function(node, data) {
-
-    const config         = ConfigUtils.load();
-    const occurrenceList = this.checkChildren(node, data);
-
-    if (this.isBroken(node)) {
-        const trimmedHead    = node.head.trim();
-        const startPos       = trimmedHead.indexOf('require(');
-        const beforeStartPos = trimmedHead.substring(0, startPos);
-        const lineOffset     = ParseUtils.getLineBreakQty(beforeStartPos);
-        const afterStartPos  = trimmedHead.substring(startPos);
-        const length         = afterStartPos.indexOf(')') + 1;
-        let globalPos        = node.globalPos + startPos;
-
-        if (data.isCrlfLineBreak) {
-            globalPos += lineOffset;
-        }
-
-        const error = this.getError(
-            node.head.trim(),
-            node.lineNumber + lineOffset,
-            node.columnNumber + node.head.trim().indexOf('require('),
-            globalPos,
-            length
-        );
-
-        occurrenceList.push(error);
-    }
-
-    return this.return(node, occurrenceList, config);
-};
-
-module.exports = Rule;
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+const ConfigUtils       = require('../../util/ConfigUtils');
+const ParseUtils        = require('../../isml_tree/ParseUtils');
+
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = '"require()" call is not allowed within a loop';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.isBroken = function(node) {
+
+    if (node.head.indexOf('require(') === -1) {
+        return false;
+    }
+
+    let iterator = node;
+
+    while (iterator.parent) {
+        iterator = iterator.parent;
+
+        if (iterator.isOfType('isloop')) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
+Rule.check = function(node, data) {
+
+    const config         = ConfigUtils.load();
+    const occurrenceList = this.checkChildren(node, data);
+
+    if (this.isBroken(node)) {
+        const trimmedHead    = node.head.trim();
+        const startPos       = trimmedHead.indexOf('require(');
+        const beforeStartPos = trimmedHead.substring(0, startPos);
+        const lineOffset     = ParseUtils.getLineBreakQty(beforeStartPos);
+        const afterStartPos  = trimmedHead.substring(startPos);
+        const length         = afterStartPos.indexOf(')') + 1;
+        let globalPos        = node.globalPos + startPos;
+
+        if (data.isCrlfLineBreak) {
+            globalPos += lineOffset;
+        }
+
+        const error = this.getError(
+            node.head.trim(),
+            node.lineNumber + lineOffset,
+            node.columnNumber + node.head.trim().indexOf('require('),
+            globalPos,
+            length
+        );
+
+        occurrenceList.push(error);
+    }
+
+    return this.return(node, occurrenceList, config);
+};
+
+module.exports = Rule;

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

@@ -1,76 +1,82 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const ConfigUtils       = require('../../util/ConfigUtils');
-// const Constants         = require('../../Constants');
-// const GeneralUtils = require('../../util/GeneralUtils');
-
-const ruleId      = require('path').basename(__filename).slice(0, -3);
-const description = 'Only one element per line is allowed';
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId, description);
-
-Rule.isBroken = function(node) {
-
-    const config     = ConfigUtils.load();
-    const ruleConfig = config.rules[ruleId];
-
-    if (ruleConfig && ruleConfig.except) {
-
-        if (node.parent && node.parent.isOfType('iscomment') && ruleConfig.except.indexOf('iscomment') >= 0) {
-            return false;
-        }
-
-        if (!node.isIsmlTag() && !node.isHtmlTag() && ruleConfig.except.indexOf('non-tag') >= 0) {
-            return false;
-        }
-    }
-
-    return !node.isRoot() &&
-        !node.parent.isContainer() &&
-        node.lineNumber === node.parent.lineNumber;
-};
-
-// Rule.getFixedContent = rootNode => {
-//     fixContent(rootNode);
-
-//     return GeneralUtils.applyActiveLineBreaks(rootNode.toString());
-// };
-
-// const fixContent = node => {
-//     for (let i = 0; i < node.children.length; i++) {
-//         const child = node.children[i];
-
-//         if (child.isInSameLineAsParent() && !node.isIsmlComment()) {
-//             const indentation       = getCorrectIndentation(child);
-//             const parentIndentation = getCorrectIndentation(node);
-
-//             child.head = `${Constants.EOL}${indentation}${child.head}${Constants.EOL}${parentIndentation}`;
-
-//             if (child.tail) {
-//                 child.setTail(`${Constants.EOL}${indentation}${child.tail}${Constants.EOL}`);
-//             }
-//         }
-
-//         fixContent(child);
-//     }
-// };
-
-// const getCorrectIndentation = node => {
-//     const indentSize = node.depth - 1;
-//     const config     = ConfigUtils.load();
-//     let indentation  = '';
-//     let indentUnit   = '';
-
-//     for (let i = 0; i < (config.indent || 4); ++i) {
-//         indentUnit += ' ';
-//     }
-
-//     for (let i = 0; i < indentSize; ++i) {
-//         indentation += indentUnit;
-//     }
-
-//     return indentation;
-// };
-
-module.exports = Rule;
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+const IndentRule        = require('../tree/indent');
+const ConfigUtils       = require('../../util/ConfigUtils');
+const Constants         = require('../../Constants');
+const GeneralUtils      = require('../../util/GeneralUtils');
+const TreeBuilder       = require('../../isml_tree/TreeBuilder');
+
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = 'Only one element per line is allowed';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.isBroken = function(node) {
+
+    const config     = ConfigUtils.load();
+    const ruleConfig = config.rules[ruleId];
+
+    if (ruleConfig && ruleConfig.except) {
+
+        if (node.parent && node.parent.isOfType('iscomment') && ruleConfig.except.indexOf('iscomment') >= 0) {
+            return false;
+        }
+
+        if (!node.isIsmlTag() && !node.isHtmlTag() && ruleConfig.except.indexOf('non-tag') >= 0) {
+            return false;
+        }
+    }
+
+    return !node.isRoot() &&
+        !node.parent.isContainer() &&
+        node.lineNumber === node.parent.endLineNumber;
+};
+
+Rule.getFixedContent = rootNode => {
+    addLineBreaks(rootNode);
+
+    // Rebuilding the tree automatically updates all node data, such as column number,
+    // line number, global position, etc;
+    const stringifiedTree   = rootNode.toString();
+    const newRootNode       = TreeBuilder.build(null, stringifiedTree).rootNode;
+    const partialFixContent = IndentRule.getFixedContent(newRootNode);
+
+    return GeneralUtils.applyActiveLineBreaks(partialFixContent);
+};
+
+const addLineBreaks = node => {
+    const config              = ConfigUtils.load();
+    const ruleConfig          = config.rules[ruleId];
+    const shouldIgnoreNonTags = ruleConfig && ruleConfig.except && ruleConfig.except.indexOf('non-tag') >= 0;
+
+    for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+
+        if (shouldAddLeadingLineBreakToChildHead(node, child, shouldIgnoreNonTags)) {
+            child.head = Constants.EOL + child.head;
+        }
+
+        if (shouldAddLeadingLineBreakToParentTail(node, child, shouldIgnoreNonTags)) {
+            node.tail = Constants.EOL + node.tail;
+        }
+
+        addLineBreaks(child);
+    }
+};
+
+const shouldAddLeadingLineBreakToChildHead = (node, child, shouldIgnoreNonTags) => {
+    return (child.isFirstChild() && child.isInSameLineAsParentEnd() || child.isTag() && child.isInSameLineAsPreviousSibling())
+        && !node.isIsmlComment()
+        && (child.isTag() || !child.isTag() && !shouldIgnoreNonTags);
+};
+
+const shouldAddLeadingLineBreakToParentTail = (node, child, shouldIgnoreNonTags) => {
+    return child.isLastChild()
+        && child.endLineNumber === node.tailLineNumber
+        && !node.isIsmlComment()
+        && !node.tail.startsWith(Constants.EOL)
+        && (child.isTag() || !child.isTag() && !shouldIgnoreNonTags);
+};
+
+module.exports = Rule;

package/src/util/CommandLineUtils.js

@@ -1,19 +1,19 @@
-const parseCommand = () => {
-    const commandObject = {
-        options : [],
-        files   : []
-    };
-
-    for (let i = 2; i < process.argv.length; i++) {
-        const arg = process.argv[i];
-        if (arg.startsWith('--')) {
-            commandObject.options.push(arg);
-        } else {
-            commandObject.files.push(arg);
-        }
-    }
-
-    return commandObject;
-};
-
-module.exports.parseCommand = parseCommand;
+const parseCommand = () => {
+    const commandObject = {
+        options : [],
+        files   : []
+    };
+
+    for (let i = 2; i < process.argv.length; i++) {
+        const arg = process.argv[i];
+        if (arg.startsWith('--')) {
+            commandObject.options.push(arg);
+        } else {
+            commandObject.files.push(arg);
+        }
+    }
+
+    return commandObject;
+};
+
+module.exports.parseCommand = parseCommand;