isml-linter 5.39.1 → 5.40.0

package/src/rules/prototypes/TreeRulePrototype.js

@@ -1,84 +1,84 @@
-const RulePrototype = require('./RulePrototype');
-const ConfigUtils   = require('../../util/ConfigUtils');
-const ParseUtils    = require('../../isml_tree/ParseUtils');
-
-const TreeRulePrototype = Object.create(RulePrototype);
-
-TreeRulePrototype.check = function(node, data) {
-
-    const config         = ConfigUtils.load();
-    const occurrenceList = this.checkChildren(node, data);
-
-    if (this.isBroken(node)) {
-        let length = node.head.trim().length;
-
-        if (data.isCrlfLineBreak) {
-            length += ParseUtils.getLineBreakQty(node.head.trim());
-        }
-
-        const error = this.getError(
-            node.head.trim(),
-            node.lineNumber,
-            node.columnNumber,
-            node.globalPos,
-            length
-        );
-
-        occurrenceList.push(error);
-    }
-
-    return this.return(node, occurrenceList, config);
-};
-
-TreeRulePrototype.shouldGetFixedContent = function(node, occurrenceList, config) {
-    return occurrenceList.length &&
-    config.autoFix &&
-    this.getFixedContent &&
-    node.isRoot();
-};
-
-TreeRulePrototype.return = function(node, occurrenceList, config) {
-    if (this.shouldGetFixedContent(node, occurrenceList, config)) {
-        return {
-            occurrenceList,
-            fixedContent : this.getFixedContent(node)
-        };
-    } else if (node.isRoot()) {
-        occurrenceList.sort((occurrence1, occurrence2) => {
-            if ( occurrence1.lineNumber < occurrence2.lineNumber ) {
-                return -1;
-            }
-
-            if ( occurrence1.lineNumber > occurrence2.lineNumber ) {
-                return 1;
-            }
-
-            return 0;
-        });
-
-        return  {
-            occurrenceList
-        } ;
-
-    } else {
-        return occurrenceList;
-    }
-};
-
-TreeRulePrototype.fix = function(stream = '') {
-
-    if (!this.isRoot() && !this.isContainer()) {
-        stream += this.head;
-    }
-
-    for (let i = 0; i < this.children.length; i++) {
-        const node = this.children[i];
-        stream     = node.isBroken() ?
-            node.toString(stream) :
-            this.getFixedContent(node, stream);
-    }
-
-    return stream;
-};
-
-module.exports = TreeRulePrototype;
+const RulePrototype = require('./RulePrototype');
+const ConfigUtils   = require('../../util/ConfigUtils');
+const ParseUtils    = require('../../isml_tree/ParseUtils');
+
+const TreeRulePrototype = Object.create(RulePrototype);
+
+TreeRulePrototype.check = function(node, data) {
+
+    const config         = ConfigUtils.load();
+    const occurrenceList = this.checkChildren(node, data);
+
+    if (this.isBroken(node)) {
+        let length = node.head.trim().length;
+
+        if (data.isCrlfLineBreak) {
+            length += ParseUtils.getLineBreakQty(node.head.trim());
+        }
+
+        const error = this.getError(
+            node.head.trim(),
+            node.lineNumber,
+            node.columnNumber,
+            node.globalPos,
+            length
+        );
+
+        occurrenceList.push(error);
+    }
+
+    return this.return(node, occurrenceList, config);
+};
+
+TreeRulePrototype.shouldGetFixedContent = function(node, occurrenceList, config) {
+    return occurrenceList.length &&
+    config.autoFix &&
+    this.getFixedContent &&
+    node.isRoot();
+};
+
+TreeRulePrototype.return = function(node, occurrenceList, config) {
+    if (this.shouldGetFixedContent(node, occurrenceList, config)) {
+        return {
+            occurrenceList,
+            fixedContent : this.getFixedContent(node)
+        };
+    } else if (node.isRoot()) {
+        occurrenceList.sort((occurrence1, occurrence2) => {
+            if ( occurrence1.lineNumber < occurrence2.lineNumber ) {
+                return -1;
+            }
+
+            if ( occurrence1.lineNumber > occurrence2.lineNumber ) {
+                return 1;
+            }
+
+            return 0;
+        });
+
+        return  {
+            occurrenceList
+        };
+
+    } else {
+        return occurrenceList;
+    }
+};
+
+TreeRulePrototype.fix = function(stream = '') {
+
+    if (!this.isRoot() && !this.isContainer()) {
+        stream += this.head;
+    }
+
+    for (let i = 0; i < this.children.length; i++) {
+        const node = this.children[i];
+        stream     = node.isBroken() ?
+            node.toString(stream) :
+            this.getFixedContent(node, stream);
+    }
+
+    return stream;
+};
+
+module.exports = TreeRulePrototype;

package/src/rules/tree/align-isset.js

@@ -1,87 +1,87 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-
-const ruleId      = require('path').basename(__filename).slice(0, -3);
-const description = 'Tag attributes are not column-aligned';
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId, description);
-
-Rule.check = function(node, data) {
-
-    const occurrenceList          = this.checkChildren(node, data);
-    const issetChildren           = getConsecutiveIssetTagChildren(node);
-    const attrPosContainer        = getCorrectAttributePositions(issetChildren);
-    const alignmentoccurrenceList = this.checkAttributesAlignments(issetChildren, attrPosContainer);
-
-    occurrenceList.push(...alignmentoccurrenceList);
-
-    return node.isRoot() ?
-        { occurrenceList } :
-        occurrenceList;
-};
-
-const getConsecutiveIssetTagChildren = node => {
-    const issetChildren = new Set();
-
-    for (let i = 1; i < node.children.length; i++) {
-        const prevChild = node.children[i - 1];
-        const child     = node.children[i];
-
-        if (prevChild.isOfType('isset') && child.isOfType('isset')) {
-            issetChildren.add(prevChild);
-            issetChildren.add(child);
-        } else if (!child.isOfType('isset') && issetChildren.length > 0) {
-            break;
-        }
-    }
-
-    return issetChildren;
-};
-
-const getCorrectAttributePositions = issetChildren => {
-
-    const attrPosContainer = {};
-    for (const issetNode of issetChildren) {
-
-        const attrArray = issetNode.getAttributeList();
-        for (let i = 0; i < attrArray.length; i++) {
-
-            const attr = attrArray[i];
-            if (!attrPosContainer[attr.name] || attr.localPos > attrPosContainer[attr.name]) {
-                attrPosContainer[attr.name] = attr.localPos;
-            }
-        }
-    }
-
-    return attrPosContainer;
-};
-
-Rule.checkAttributesAlignments = function(issetChildren, attrPosContainer) {
-    const occurrenceList = [];
-
-    for (const issetNode of issetChildren) {
-        const attrArray = issetNode.getAttributeList();
-
-        for (let i = 0; i < attrArray.length; i++) {
-            const attr = attrArray[i];
-            if (attr.localPos !== attrPosContainer[attr.name]) {
-                const error = this.getError(
-                    issetNode.head.trim(),
-                    issetNode.lineNumber,
-                    issetNode.columnNumber,
-                    issetNode.globalPos,
-                    issetNode.head.trim().length,
-                    description
-                );
-
-                occurrenceList.push(error);
-                break;
-            }
-        }
-    }
-
-    return occurrenceList;
-};
-
-module.exports = Rule;
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = 'Tag attributes are not column-aligned';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.check = function(node, data) {
+
+    const occurrenceList          = this.checkChildren(node, data);
+    const issetChildren           = getConsecutiveIssetTagChildren(node);
+    const attrPosContainer        = getCorrectAttributePositions(issetChildren);
+    const alignmentoccurrenceList = this.checkAttributesAlignments(issetChildren, attrPosContainer);
+
+    occurrenceList.push(...alignmentoccurrenceList);
+
+    return node.isRoot() ?
+        { occurrenceList } :
+        occurrenceList;
+};
+
+const getConsecutiveIssetTagChildren = node => {
+    const issetChildren = new Set();
+
+    for (let i = 1; i < node.children.length; i++) {
+        const prevChild = node.children[i - 1];
+        const child     = node.children[i];
+
+        if (prevChild.isOfType('isset') && child.isOfType('isset')) {
+            issetChildren.add(prevChild);
+            issetChildren.add(child);
+        } else if (!child.isOfType('isset') && issetChildren.length > 0) {
+            break;
+        }
+    }
+
+    return issetChildren;
+};
+
+const getCorrectAttributePositions = issetChildren => {
+
+    const attrPosContainer = {};
+    for (const issetNode of issetChildren) {
+
+        const attrArray = issetNode.getAttributeList();
+        for (let i = 0; i < attrArray.length; i++) {
+
+            const attr = attrArray[i];
+            if (!attrPosContainer[attr.name] || attr.localPos > attrPosContainer[attr.name]) {
+                attrPosContainer[attr.name] = attr.localPos;
+            }
+        }
+    }
+
+    return attrPosContainer;
+};
+
+Rule.checkAttributesAlignments = function(issetChildren, attrPosContainer) {
+    const occurrenceList = [];
+
+    for (const issetNode of issetChildren) {
+        const attrArray = issetNode.getAttributeList();
+
+        for (let i = 0; i < attrArray.length; i++) {
+            const attr = attrArray[i];
+            if (attr.localPos !== attrPosContainer[attr.name]) {
+                const error = this.getError(
+                    issetNode.head.trim(),
+                    issetNode.lineNumber,
+                    issetNode.columnNumber,
+                    issetNode.globalPos,
+                    issetNode.head.trim().length,
+                    description
+                );
+
+                occurrenceList.push(error);
+                break;
+            }
+        }
+    }
+
+    return occurrenceList;
+};
+
+module.exports = Rule;

package/src/rules/tree/contextual-attrs.js

@@ -1,105 +1,105 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const SfccTagContainer  = require('../../enums/SfccTagContainer');
-
-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) {
-    if (!node.isIsmlTag() || node.isCustomIsmlTag()) {
-        return false;
-    }
-
-    const attrList   = node.getAttributeList();
-    const nodeType   = node.getType();
-    const sfccTagObj = SfccTagContainer[nodeType];
-    let result       = null;
-
-    attrList.some( nodeAttribute => {
-        const sfccAttr = sfccTagObj.attributes[nodeAttribute.name];
-        result         = checkForExclusiveAttributes(sfccTagObj, nodeAttribute, attrList) ||
-                         checkForConditionalAttributes(sfccAttr, nodeAttribute, attrList);
-
-        return !result;
-    });
-
-    if (sfccTagObj.requires) {
-        const exclusiveAttributeList = sfccTagObj.requires.exclusive;
-        if (attrList.length === 0 && exclusiveAttributeList.length > 1) {
-            result         = {};
-            result.message = `The "${node.getType()}" tag needs to have either "${exclusiveAttributeList[0]}" or "${exclusiveAttributeList[1]}" attribute`;
-        }
-    }
-
-    return result;
-};
-
-const checkForExclusiveAttributes = (sfccTagObj, nodeAttribute, attrList) => {
-    let result = null;
-    if (sfccTagObj && sfccTagObj.requires && sfccTagObj.requires.exclusive) {
-        const exclusiveAttributeObj            = sfccTagObj.requires.exclusive;
-        const exclusiveAttributeOccurrenceList = [];
-
-        for (let i = 0; i < attrList.length; i++) {
-            const attr = attrList[i];
-            if (exclusiveAttributeObj.indexOf(attr.name) >= 0) {
-                exclusiveAttributeOccurrenceList.push(attr.name);
-            }
-        }
-
-        if (exclusiveAttributeOccurrenceList.length > 1) {
-            result         = {};
-            result.message = `The "${nodeAttribute.node.getType()}" tag cannot have "${exclusiveAttributeOccurrenceList[0]}" and "${exclusiveAttributeOccurrenceList[1]}" attributes simultaneously`;
-        }
-
-    }
-
-    return result;
-};
-
-const checkForConditionalAttributes = (sfccAttr, nodeAttribute, attrList) => {
-    const requiredAttributeObj = sfccAttr.requires;
-    let result                 = null;
-
-    if (requiredAttributeObj) {
-        const requiredAttributeName   = requiredAttributeObj.name;
-        const requiredAttributeValues = requiredAttributeObj.ifValues;
-        const isConditionFulfilled    = requiredAttributeValues.indexOf(nodeAttribute.value) >= 0;
-        const hasRequiredAttr         = attrList.some( attr => attr.name === requiredAttributeName );
-
-        if (isConditionFulfilled && !hasRequiredAttr) {
-            result         = nodeAttribute;
-            result.message = `"${requiredAttributeObj.name}" attribute is expected when "${nodeAttribute.name}" attribute has value of "${nodeAttribute.value}"`;
-        }
-    }
-
-    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.globalPos,
-            node.head.trim().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 = 'Embedded ISML is not allowed';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.isBroken = function(node) {
+    if (!node.isIsmlTag() || node.isCustomIsmlTag()) {
+        return false;
+    }
+
+    const attrList   = node.getAttributeList();
+    const nodeType   = node.getType();
+    const sfccTagObj = SfccTagContainer[nodeType];
+    let result       = null;
+
+    attrList.some( nodeAttribute => {
+        const sfccAttr = sfccTagObj.attributes[nodeAttribute.name];
+        result         = checkForExclusiveAttributes(sfccTagObj, nodeAttribute, attrList) ||
+                         checkForConditionalAttributes(sfccAttr, nodeAttribute, attrList);
+
+        return !result;
+    });
+
+    if (sfccTagObj.requires) {
+        const exclusiveAttributeList = sfccTagObj.requires.exclusive;
+        if (attrList.length === 0 && exclusiveAttributeList.length > 1) {
+            result         = {};
+            result.message = `The "${node.getType()}" tag needs to have either "${exclusiveAttributeList[0]}" or "${exclusiveAttributeList[1]}" attribute`;
+        }
+    }
+
+    return result;
+};
+
+const checkForExclusiveAttributes = (sfccTagObj, nodeAttribute, attrList) => {
+    let result = null;
+    if (sfccTagObj && sfccTagObj.requires && sfccTagObj.requires.exclusive) {
+        const exclusiveAttributeObj            = sfccTagObj.requires.exclusive;
+        const exclusiveAttributeOccurrenceList = [];
+
+        for (let i = 0; i < attrList.length; i++) {
+            const attr = attrList[i];
+            if (exclusiveAttributeObj.indexOf(attr.name) >= 0) {
+                exclusiveAttributeOccurrenceList.push(attr.name);
+            }
+        }
+
+        if (exclusiveAttributeOccurrenceList.length > 1) {
+            result         = {};
+            result.message = `The "${nodeAttribute.node.getType()}" tag cannot have "${exclusiveAttributeOccurrenceList[0]}" and "${exclusiveAttributeOccurrenceList[1]}" attributes simultaneously`;
+        }
+
+    }
+
+    return result;
+};
+
+const checkForConditionalAttributes = (sfccAttr, nodeAttribute, attrList) => {
+    const requiredAttributeObj = sfccAttr.requires;
+    let result                 = null;
+
+    if (requiredAttributeObj) {
+        const requiredAttributeName   = requiredAttributeObj.name;
+        const requiredAttributeValues = requiredAttributeObj.ifValues;
+        const isConditionFulfilled    = requiredAttributeValues.indexOf(nodeAttribute.value) >= 0;
+        const hasRequiredAttr         = attrList.some( attr => attr.name === requiredAttributeName );
+
+        if (isConditionFulfilled && !hasRequiredAttr) {
+            result         = nodeAttribute;
+            result.message = `"${requiredAttributeObj.name}" attribute is expected when "${nodeAttribute.name}" attribute has value of "${nodeAttribute.value}"`;
+        }
+    }
+
+    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.globalPos,
+            node.head.trim().length,
+            occurrence.message
+        );
+
+        occurrenceList.push(error);
+    }
+
+    return node.isRoot() ?
+        { occurrenceList } :
+        occurrenceList;
+};
+
+module.exports = Rule;

package/src/rules/tree/custom-tags.js

@@ -1,54 +1,54 @@
-const TreeRulePrototype  = require('../prototypes/TreeRulePrototype');
-const CustomTagContainer = require('../../util/CustomTagContainer');
-
-const ruleId      = require('path').basename(__filename).slice(0, -3);
-const description = 'Invalid custom tag';
-
-const Rule = Object.create(TreeRulePrototype);
-
-Rule.init(ruleId, description);
-
-Rule.addError = function(node, message) {
-    return this.getError(
-        node.head.trim(),
-        node.lineNumber,
-        node.columnNumber,
-        node.globalPos,
-        node.head.trim().length,
-        message
-    );
-};
-
-Rule.check = function(node, data) {
-
-    const occurrenceList = this.checkChildren(node, data);
-
-    if (data) {
-        const isUsedButNotDeclared = !data.moduleDefinition && data.customModuleArray && data.customModuleArray.length > 0;
-
-        if (node.head.indexOf('template="util/modules"') >= 0) {
-            const isUnnecessaryDefinition = data.moduleDefinition && !data.customModuleArray;
-
-            if (isUnnecessaryDefinition) {
-                const error = this.addError(node, 'Unnecessary inclusion of the modules template');
-                occurrenceList.push(error);
-            }
-        }
-
-        if (isUsedButNotDeclared && node.isCustomIsmlTag()) {
-            const error = this.addError(node,
-                CustomTagContainer[node.getType()] ?
-                    `Custom tag "${node.getType()}" could not be identified. Maybe you forgot to include the modules template?` :
-                    `Unknown tag "${node.getType()}". Maybe you forgot to add it to util/modules template?`
-            );
-
-            occurrenceList.push(error);
-        }
-    }
-
-    return node.isRoot() ?
-        { occurrenceList } :
-        occurrenceList;
-};
-
-module.exports = Rule;
+const TreeRulePrototype  = require('../prototypes/TreeRulePrototype');
+const CustomTagContainer = require('../../util/CustomTagContainer');
+
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = 'Invalid custom tag';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.addError = function(node, message) {
+    return this.getError(
+        node.head.trim(),
+        node.lineNumber,
+        node.columnNumber,
+        node.globalPos,
+        node.head.trim().length,
+        message
+    );
+};
+
+Rule.check = function(node, data) {
+
+    const occurrenceList = this.checkChildren(node, data);
+
+    if (data) {
+        const isUsedButNotDeclared = !data.moduleDefinition && data.customModuleArray && data.customModuleArray.length > 0;
+
+        if (node.head.indexOf('template="util/modules"') >= 0) {
+            const isUnnecessaryDefinition = data.moduleDefinition && !data.customModuleArray;
+
+            if (isUnnecessaryDefinition) {
+                const error = this.addError(node, 'Unnecessary inclusion of the modules template');
+                occurrenceList.push(error);
+            }
+        }
+
+        if (isUsedButNotDeclared && node.isCustomIsmlTag()) {
+            const error = this.addError(node,
+                CustomTagContainer[node.getType()] ?
+                    `Custom tag "${node.getType()}" could not be identified. Maybe you forgot to include the modules template?` :
+                    `Unknown tag "${node.getType()}". Maybe you forgot to add it to util/modules template?`
+            );
+
+            occurrenceList.push(error);
+        }
+    }
+
+    return node.isRoot() ?
+        { occurrenceList } :
+        occurrenceList;
+};
+
+module.exports = Rule;