isml-linter 5.39.1 → 5.40.0

package/src/rules/tree/leading-iscache.js

@@ -1,43 +1,39 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const RuleUtils         = require('../../util/TempRuleUtils');
-const Constants         = require('../../Constants');
-const GeneralUtils      = require('../../util/GeneralUtils');
-
-const TAG_TYPE    = 'iscache';
-const ruleId      = require('path').basename(__filename).slice(0, -3);
-const description = `<${TAG_TYPE}> tag should be on top of the template`;
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId, description);
-
-Rule.isBroken = function(node) {
-    let rootNode = node;
-
-    while (rootNode.parent) {
-        rootNode = rootNode.parent;
-    }
-
-    const isFirstNode          = rootNode.children[0] && rootNode.children[0].isOfType(TAG_TYPE);
-    const isAfterIscontentNode = rootNode.children[0] && rootNode.children[0].isOfType('iscontent') &&
-                                 rootNode.children[1] && rootNode.children[1].isOfType(TAG_TYPE);
-
-    return node.isOfType(TAG_TYPE) &&
-        (!isFirstNode && !isAfterIscontentNode);
-};
-
-Rule.getFixedContent = function(rootNode) {
-    if (!RuleUtils.isTypeAmongTheFirstElements(rootNode, TAG_TYPE)) {
-        const isContentNode = RuleUtils.findNodeOfType(rootNode, TAG_TYPE);
-
-        if (isContentNode) {
-            isContentNode.parent.removeChild(isContentNode);
-            isContentNode.head = isContentNode.head.trim() + Constants.EOL;
-            rootNode.addChildNodeToPos(isContentNode, 0);
-        }
-    }
-
-    return GeneralUtils.applyActiveLineBreaks(rootNode.toString());
-};
-
-module.exports = Rule;
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+const RuleUtils         = require('../../util/TempRuleUtils');
+const Constants         = require('../../Constants');
+const GeneralUtils      = require('../../util/GeneralUtils');
+
+const TAG_TYPE    = 'iscache';
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = `<${TAG_TYPE}> tag should be on top of the template`;
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.isBroken = function(node) {
+    const rootNode = node.getRoot();
+
+    const isFirstNode          = rootNode.children[0] && rootNode.children[0].isOfType(TAG_TYPE);
+    const isAfterIscontentNode = rootNode.children[0] && rootNode.children[0].isOfType('iscontent') &&
+                                 rootNode.children[1] && rootNode.children[1].isOfType(TAG_TYPE);
+
+    return node.isOfType(TAG_TYPE) &&
+        (!isFirstNode && !isAfterIscontentNode);
+};
+
+Rule.getFixedContent = function(rootNode) {
+    if (!RuleUtils.isTypeAmongTheFirstElements(rootNode, TAG_TYPE)) {
+        const isContentNode = RuleUtils.findNodeOfType(rootNode, TAG_TYPE);
+
+        if (isContentNode) {
+            isContentNode.parent.removeChild(isContentNode);
+            isContentNode.head = isContentNode.head.trim() + Constants.EOL;
+            rootNode.addChildNodeToPos(isContentNode, 0);
+        }
+    }
+
+    return GeneralUtils.applyActiveLineBreaks(rootNode.toString());
+};
+
+module.exports = Rule;

package/src/rules/tree/leading-iscontent.js

@@ -1,39 +1,35 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const Constants         = require('../../Constants');
-const RuleUtils         = require('../../util/TempRuleUtils');
-const GeneralUtils      = require('../../util/GeneralUtils');
-
-const TAG_TYPE    = 'iscontent';
-const ruleId      = require('path').basename(__filename).slice(0, -3);
-const description = `<${TAG_TYPE}> tag should be the first in the template`;
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId, description);
-
-Rule.isBroken = function(node) {
-    let rootNode = node;
-
-    while (rootNode.parent) {
-        rootNode = rootNode.parent;
-    }
-
-    return node.isOfType(TAG_TYPE) &&
-        rootNode.children[0].id !== node.id;
-};
-
-Rule.getFixedContent = function(rootNode) {
-    if (!RuleUtils.isTypeAmongTheFirstElements(rootNode, TAG_TYPE)) {
-        const isContentNode = RuleUtils.findNodeOfType(rootNode, TAG_TYPE);
-
-        if (isContentNode) {
-            isContentNode.parent.removeChild(isContentNode);
-            isContentNode.head = isContentNode.head.trim() + Constants.EOL;
-            rootNode.addChildNodeToPos(isContentNode, 0);
-        }
-    }
-
-    return GeneralUtils.applyActiveLineBreaks(rootNode.toString());
-};
-
-module.exports = Rule;
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+const Constants         = require('../../Constants');
+const RuleUtils         = require('../../util/TempRuleUtils');
+const GeneralUtils      = require('../../util/GeneralUtils');
+
+const TAG_TYPE    = 'iscontent';
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = `<${TAG_TYPE}> tag should be the first in the template`;
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.isBroken = function(node) {
+    const rootNode = node.getRoot();
+
+    return node.isOfType(TAG_TYPE) &&
+        rootNode.children[0].id !== node.id;
+};
+
+Rule.getFixedContent = function(rootNode) {
+    if (!RuleUtils.isTypeAmongTheFirstElements(rootNode, TAG_TYPE)) {
+        const isContentNode = RuleUtils.findNodeOfType(rootNode, TAG_TYPE);
+
+        if (isContentNode) {
+            isContentNode.parent.removeChild(isContentNode);
+            isContentNode.head = isContentNode.head.trim() + Constants.EOL;
+            rootNode.addChildNodeToPos(isContentNode, 0);
+        }
+    }
+
+    return GeneralUtils.applyActiveLineBreaks(rootNode.toString());
+};
+
+module.exports = Rule;

package/src/rules/tree/max-depth.js

@@ -1,54 +1,54 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const ParseUtils        = require('../../isml_tree/ParseUtils');
-
-const ruleId      = require('path').basename(__filename).slice(0, -3);
-const description = 'max depth beyond allowed';
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId, description);
-
-Rule.getDefaultAttrs = () => {
-    return {
-        value : 10
-    };
-};
-
-Rule.isBroken = function(node) {
-    const configMaxDepth = this.getConfigs().value;
-    return !node.isContainer() && !node.isEmpty() && node.depth > configMaxDepth;
-};
-
-Rule.check = function(node, data) {
-
-    const config         = this.getConfigs();
-    const occurrenceList = [];
-
-    if (this.isBroken(node)) {
-        const stringifiedNode = node.toString().trim();
-        let length            = stringifiedNode.length;
-
-        if (data.isCrlfLineBreak) {
-            length += ParseUtils.getLineBreakQty(stringifiedNode);
-        }
-
-        const error = this.getError(
-            stringifiedNode,
-            node.lineNumber,
-            node.columnNumber,
-            node.globalPos,
-            length
-        );
-
-        occurrenceList.push(error);
-    } else {
-        for (let i = 0; i < node.children.length; i++) {
-            const childrenResult = this.check(node.children[i], data);
-            occurrenceList.push(...childrenResult);
-        }
-    }
-
-    return this.return(node, occurrenceList, config);
-};
-
-module.exports = Rule;
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+const ParseUtils        = require('../../isml_tree/ParseUtils');
+
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = 'max depth beyond allowed';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.getDefaultAttrs = () => {
+    return {
+        value : 10
+    };
+};
+
+Rule.isBroken = function(node) {
+    const configMaxDepth = this.getConfigs().value;
+    return !node.isContainer() && !node.isEmpty() && node.depth > configMaxDepth;
+};
+
+Rule.check = function(node, data) {
+
+    const config         = this.getConfigs();
+    const occurrenceList = [];
+
+    if (this.isBroken(node)) {
+        const stringifiedNode = node.toString().trim();
+        let length            = stringifiedNode.length;
+
+        if (data.isCrlfLineBreak) {
+            length += ParseUtils.getLineBreakQty(stringifiedNode);
+        }
+
+        const error = this.getError(
+            stringifiedNode,
+            node.lineNumber,
+            node.columnNumber,
+            node.globalPos,
+            length
+        );
+
+        occurrenceList.push(error);
+    } else {
+        for (let i = 0; i < node.children.length; i++) {
+            const childrenResult = this.check(node.children[i], data);
+            occurrenceList.push(...childrenResult);
+        }
+    }
+
+    return this.return(node, occurrenceList, config);
+};
+
+module.exports = Rule;

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

@@ -1,67 +1,67 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const SfccTagContainer  = require('../../enums/SfccTagContainer');
-
-const ruleId      = require('path').basename(__filename).slice(0, -3);
-const description = 'Attribute label or value is deprecated';
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId, description);
-
-Rule.isBroken = function(node) {
-    if (!node.isIsmlTag()) {
-        return false;
-    }
-
-    const attrList = node.getAttributeList();
-    const nodeType = node.getType();
-    const obj      = SfccTagContainer[nodeType];
-    let result     = null;
-
-    if (node.isStandardIsmlTag()) {
-        attrList.some( nodeAttribute => {
-            for (const sfccAttr in obj.attributes) {
-                if (Object.prototype.hasOwnProperty.call(obj.attributes, sfccAttr) && nodeAttribute.name === sfccAttr) {
-                    const attr              = obj.attributes[sfccAttr];
-                    const isValueDeprecated = attr.deprecatedValues &&
-                    attr.deprecatedValues.indexOf(nodeAttribute.value) >= 0;
-
-                    if (isValueDeprecated) {
-                        result         = nodeAttribute;
-                        result.message = `"${nodeAttribute.value}" value is deprecated for "${nodeAttribute.name}" attribute`;
-                        return true;
-                    }
-                }
-            }
-
-            return false;
-        });
-    }
-
-    return result;
-};
-
-Rule.check = function(node, data) {
-
-    const occurrenceList = this.checkChildren(node, data);
-
-    const occurrence = this.isBroken(node);
-    if (occurrence) {
-        const error = this.getError(
-            node.head.trim(),
-            node.lineNumber,
-            node.columnNumber + node.head.trim().indexOf(occurrence.fullContent),
-            occurrence.attrGlobalPos,
-            occurrence.length,
-            occurrence.message
-        );
-
-        occurrenceList.push(error);
-    }
-
-    return node.isRoot() ?
-        { occurrenceList } :
-        occurrenceList;
-};
-
-module.exports = Rule;
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+const SfccTagContainer  = require('../../enums/SfccTagContainer');
+
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = 'Attribute label or value is deprecated';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.isBroken = function(node) {
+    if (!node.isIsmlTag()) {
+        return false;
+    }
+
+    const attrList = node.getAttributeList();
+    const nodeType = node.getType();
+    const obj      = SfccTagContainer[nodeType];
+    let result     = null;
+
+    if (node.isStandardIsmlTag()) {
+        attrList.some( nodeAttribute => {
+            for (const sfccAttr in obj.attributes) {
+                if (Object.prototype.hasOwnProperty.call(obj.attributes, sfccAttr) && nodeAttribute.name === sfccAttr) {
+                    const attr              = obj.attributes[sfccAttr];
+                    const isValueDeprecated = attr.deprecatedValues &&
+                    attr.deprecatedValues.indexOf(nodeAttribute.value) >= 0;
+
+                    if (isValueDeprecated) {
+                        result         = nodeAttribute;
+                        result.message = `"${nodeAttribute.value}" value is deprecated for "${nodeAttribute.name}" attribute`;
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        });
+    }
+
+    return result;
+};
+
+Rule.check = function(node, data) {
+
+    const occurrenceList = this.checkChildren(node, data);
+
+    const occurrence = this.isBroken(node);
+    if (occurrence) {
+        const error = this.getError(
+            node.head.trim(),
+            node.lineNumber,
+            node.columnNumber + node.head.trim().indexOf(occurrence.fullContent),
+            occurrence.attrGlobalPos,
+            occurrence.length,
+            occurrence.message
+        );
+
+        occurrenceList.push(error);
+    }
+
+    return node.isRoot() ?
+        { occurrenceList } :
+        occurrenceList;
+};
+
+module.exports = Rule;

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

@@ -1,17 +1,17 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-
-const ruleId      = require('path').basename(__filename).slice(0, -3);
-const description = 'Embedded ISML is not allowed';
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId, description);
-
-Rule.isBroken = function(node) {
-    return node.isHtmlTag() &&
-        !node.isOfType('is') &&
-        node.head.indexOf('<isprint') === -1 &&
-        node.head.indexOf('<is') >= 0;
-};
-
-module.exports = Rule;
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = 'Embedded ISML is not allowed';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.isBroken = function(node) {
+    return node.isHtmlTag() &&
+        !node.isOfType('is') &&
+        node.head.indexOf('<isprint') === -1 &&
+        node.head.indexOf('<is') >= 0;
+};
+
+module.exports = Rule;

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

@@ -1,51 +1,51 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-
-const ruleId      = require('path').basename(__filename).slice(0, -3);
-const description = 'Hardcoded string is not allowed';
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId, description);
-
-Rule.getDefaultAttrs = () => {
-    return {
-        except            : [],
-        allowHtmlEntities : true
-    };
-};
-
-Rule.isBroken = function(node) {
-    const ruleExceptionList  = this.getConfigs().except;
-    const allowHtmlEntities  = this.getConfigs().allowHtmlEntities;
-    const isTagContent       = isTagChild(node);
-    const shouldCheckHead    = node.isOfType('text') && !node.isExpression() && !isTagContent;
-    const isTextAnHtmlEntity = node.head.trim().startsWith('&') && node.head.trim().endsWith(';');
-    let nodeHead             = node.head;
-
-    if (!shouldCheckHead) {
-        return false;
-    }
-
-    for (let i = 0; i < ruleExceptionList.length; i++) {
-        const char = ruleExceptionList[i];
-
-        nodeHead = nodeHead.split(char).join('');
-    }
-
-    if (allowHtmlEntities && isTextAnHtmlEntity) {
-        return false;
-    }
-
-    return nodeHead.trim().length > 0;
-};
-
-const isTagChild = node => {
-    const isCommentContent  = node.parent && node.parent.isOfType('iscomment');
-    const isIsscriptContent = node.parent && node.parent.isOfType('isscript');
-    const isScriptContent   = node.parent && node.parent.isOfType('script');
-    const isStyleContent    = node.parent && node.parent.isOfType('style');
-
-    return isCommentContent || isIsscriptContent || isScriptContent || isStyleContent;
-};
-
-module.exports = Rule;
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = 'Hardcoded string is not allowed';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.getDefaultAttrs = () => {
+    return {
+        except            : [],
+        allowHtmlEntities : true
+    };
+};
+
+Rule.isBroken = function(node) {
+    const ruleExceptionList  = this.getConfigs().except;
+    const allowHtmlEntities  = this.getConfigs().allowHtmlEntities;
+    const isTagContent       = isTagChild(node);
+    const shouldCheckHead    = node.isOfType('text') && !node.isExpression() && !isTagContent;
+    const isTextAnHtmlEntity = node.head.trim().startsWith('&') && node.head.trim().endsWith(';');
+    let nodeHead             = node.head;
+
+    if (!shouldCheckHead) {
+        return false;
+    }
+
+    for (let i = 0; i < ruleExceptionList.length; i++) {
+        const char = ruleExceptionList[i];
+
+        nodeHead = nodeHead.split(char).join('');
+    }
+
+    if (allowHtmlEntities && isTextAnHtmlEntity) {
+        return false;
+    }
+
+    return nodeHead.trim().length > 0;
+};
+
+const isTagChild = node => {
+    const isCommentContent  = node.isDescendantOf('iscomment');
+    const isIsscriptContent = node.isDescendantOf('isscript');
+    const isScriptContent   = node.isDescendantOf('script');
+    const isStyleContent    = node.isDescendantOf('style');
+
+    return isCommentContent || isIsscriptContent || isScriptContent || isStyleContent;
+};
+
+module.exports = Rule;

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

@@ -1,35 +1,35 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const MaskUtils         = require('../../isml_tree/MaskUtils');
-const GeneralUtils      = require('../../util/GeneralUtils');
-
-const ruleId      = require('path').basename(__filename).slice(0, -3);
-const description = 'Slash is not allowed for "iselse" nor "iselseif" tags';
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId, description);
-
-Rule.isBroken = function(node) {
-    return (node.isOfType('iselse') || node.isOfType('iselseif')) &&
-        node.head.trim().endsWith('/>');
-};
-
-Rule.getFixedContent = function(node) {
-    for (let i = 0; i < node.children.length; i++) {
-        const child = node.children[i];
-
-        if (child.isOfType('iselse') || child.isOfType('iselseif')) {
-            const slashPos = MaskUtils.maskInBetween(child.head, '${', '}').lastIndexOf('/');
-
-            if (slashPos >= 0) {
-                child.head = child.head.slice(0, slashPos) + child.head.slice(slashPos + 1);
-            }
-        }
-
-        this.getFixedContent(child);
-    }
-
-    return GeneralUtils.applyActiveLineBreaks(node.toString());
-};
-
-module.exports = Rule;
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+const MaskUtils         = require('../../isml_tree/MaskUtils');
+const GeneralUtils      = require('../../util/GeneralUtils');
+
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = 'Slash is not allowed for "iselse" nor "iselseif" tags';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.isBroken = function(node) {
+    return (node.isOfType('iselse') || node.isOfType('iselseif')) &&
+        node.head.trim().endsWith('/>');
+};
+
+Rule.getFixedContent = function(node) {
+    for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+
+        if (child.isOfType('iselse') || child.isOfType('iselseif')) {
+            const slashPos = MaskUtils.maskInBetween(child.head, '${', '}').lastIndexOf('/');
+
+            if (slashPos >= 0) {
+                child.head = child.head.slice(0, slashPos) + child.head.slice(slashPos + 1);
+            }
+        }
+
+        this.getFixedContent(child);
+    }
+
+    return GeneralUtils.applyActiveLineBreaks(node.toString());
+};
+
+module.exports = Rule;