isml-linter 5.39.4 → 5.40.2

package/.gitattributes

@@ -0,0 +1 @@
+bin/isml-linter.js text eol=lf

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+
+## [5.40.2] - 2022-09-05
+
+### Fixed
+ - [Issue #35][issue#35] - Set bin file linebreak to LF;
+
+## [5.40.1] - 2022-09-01
+
+### Fixed
+ - HTML-element embedded `<isif>` condition scenario;
+ - Added mechanism to prevent infinite loops in case of unexpected errors;
+ 
+## [5.40.0] - 2022-02-05
+
+### Added
+ - "one-element-per-line" rule autofix;
+
+### Fixed
+ - Small "indent" rule issue;
+ - Tree build edge case;
+ 
 ## [5.39.4] - 2022-01-30
 
 ### Fixed
@@ -1002,6 +1023,9 @@
 ### Added
 - Linter is published;
 
+[5.40.2]: https://github.com/FabiowQuixada/isml-linter/compare/v5.40.1...v5.40.2
+[5.40.1]: https://github.com/FabiowQuixada/isml-linter/compare/v5.40.0...v5.40.1
+[5.40.0]: https://github.com/FabiowQuixada/isml-linter/compare/v5.39.4...v5.40.0
 [5.39.4]: https://github.com/FabiowQuixada/isml-linter/compare/v5.39.3...v5.39.4
 [5.39.3]: https://github.com/FabiowQuixada/isml-linter/compare/v5.39.2...v5.39.3
 [5.39.2]: https://github.com/FabiowQuixada/isml-linter/compare/v5.39.1...v5.39.2
@@ -1152,6 +1176,7 @@
 [issue#29]: https://github.com/FabiowQuixada/isml-linter/issues/29
 [issue#30]: https://github.com/FabiowQuixada/isml-linter/issues/30
 [issue#31]: https://github.com/FabiowQuixada/isml-linter/issues/31
+[issue#35]: https://github.com/FabiowQuixada/isml-linter/issues/35
 
 [cli-docs]: <docs/cli.md>
 [api-docs]: <docs/api.md>

package/package.json

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

package/src/isml_tree/IsmlNode.js

@@ -251,6 +251,14 @@ class IsmlNode {
         return this.parent && this.parent.isIsmlComment();
     }
 
+    isHardCodedText() {
+        return !this.isRoot()
+            && !this.isContainer()
+            && !this.isConditionalComment()
+            && !this.isTag()
+            && !this.isExpression();
+    }
+
     getPreviousSibling() {
         if (!this.parent || !this.parent.isContainer() && this.isFirstChild() || this.parent.isContainer() && this.parent.isFirstChild() && this.isFirstChild()) {
             return null;

package/src/isml_tree/ParseUtils.js

@@ -132,6 +132,15 @@ 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,
+            newElement.lineNumber,
+            newElement.globalPos,
+            state.templatePath
+        );
+    }
 
     return newElement;
 };
@@ -193,6 +202,7 @@ const getElementType = trimmedElement => {
         const typeValueLastPos = Math.min(...[
             trimmedElement.indexOf(' '),
             trimmedElement.indexOf('/'),
+            trimmedElement.indexOf(Constants.EOL),
             trimmedElement.indexOf('>')
         ].filter(j => j >= 0));
 
@@ -453,13 +463,21 @@ const getNewElement = state => {
 
 const getElementList = (templateContent, templatePath, isCrlfLineBreak) => {
 
-    const state       = getInitialState(templateContent, templatePath, isCrlfLineBreak);
-    const elementList = state.elementList;
+    const state              = getInitialState(templateContent, templatePath, isCrlfLineBreak);
+    const elementList        = state.elementList;
+    let previousStateContent = state.remainingShadowContent;
 
     do {
         initLoopState(state);
         parseNextElement(state);
         finishLoopState(state);
+
+        if (previousStateContent.length === state.remainingShadowContent.length) {
+            throw ExceptionUtils.unkownError(templatePath);
+        }
+
+        previousStateContent = state.remainingShadowContent;
+
     } while (state.remainingShadowContent.length > 0);
 
     adjustTrailingSpaces(state);

package/src/rules/prototypes/TreeRulePrototype.js

@@ -58,7 +58,7 @@ TreeRulePrototype.return = function(node, occurrenceList, config) {
 
         return  {
             occurrenceList
-        } ;
+        };
 
     } else {
         return occurrenceList;

package/src/rules/tree/indent.js

@@ -754,6 +754,9 @@ const checkIfShouldAddIndentationToTail = node => {
         !isTailInSameLineAsChild &&
         !isInSameLineAsChild &&
         !isLastClause
+    // TODO Works for a specific case only. Might have side effects;
+    ||
+        node.isOfType('iscomment') && !isTailInSameLineAsChild
     ||
         isBrokenIntoMultipleLines;
 

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

@@ -1,7 +1,9 @@
 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 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';
@@ -28,49 +30,53 @@ Rule.isBroken = function(node) {
 
     return !node.isRoot() &&
         !node.parent.isContainer() &&
-        node.lineNumber === node.parent.lineNumber;
+        node.lineNumber === node.parent.endLineNumber;
 };
 
-// Rule.getFixedContent = rootNode => {
-//     fixContent(rootNode);
+Rule.getFixedContent = rootNode => {
+    addLineBreaks(rootNode);
 
-//     return GeneralUtils.applyActiveLineBreaks(rootNode.toString());
-// };
+    // 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);
 
-// 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);
+    return GeneralUtils.applyActiveLineBreaks(partialFixContent);
+};
 
-//             child.head = `${Constants.EOL}${indentation}${child.head}${Constants.EOL}${parentIndentation}`;
+const addLineBreaks = node => {
+    const config              = ConfigUtils.load();
+    const ruleConfig          = config.rules[ruleId];
+    const shouldIgnoreNonTags = ruleConfig && ruleConfig.except && ruleConfig.except.indexOf('non-tag') >= 0;
 
-//             if (child.tail) {
-//                 child.setTail(`${Constants.EOL}${indentation}${child.tail}${Constants.EOL}`);
-//             }
-//         }
+    for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
 
-//         fixContent(child);
-//     }
-// };
+        if (shouldAddLeadingLineBreakToChildHead(node, child, shouldIgnoreNonTags)) {
+            child.head = Constants.EOL + child.head;
+        }
 
-// const getCorrectIndentation = node => {
-//     const indentSize = node.depth - 1;
-//     const config     = ConfigUtils.load();
-//     let indentation  = '';
-//     let indentUnit   = '';
+        if (shouldAddLeadingLineBreakToParentTail(node, child, shouldIgnoreNonTags)) {
+            node.tail = Constants.EOL + node.tail;
+        }
 
-//     for (let i = 0; i < (config.indent || 4); ++i) {
-//         indentUnit += ' ';
-//     }
+        addLineBreaks(child);
+    }
+};
 
-//     for (let i = 0; i < indentSize; ++i) {
-//         indentation += indentUnit;
-//     }
+const shouldAddLeadingLineBreakToChildHead = (node, child, shouldIgnoreNonTags) => {
+    return (child.isFirstChild() && child.isInSameLineAsParentEnd() || child.isTag() && child.isInSameLineAsPreviousSibling())
+        && !node.isIsmlComment()
+        && (child.isTag() || !child.isTag() && !shouldIgnoreNonTags);
+};
 
-//     return indentation;
-// };
+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/ExceptionUtils.js

@@ -5,6 +5,7 @@ const types = {
     UNKNOWN_ERROR                    : 'UNKNOWN_ERROR',
     UNCLOSED_DEPRECATED_ISML_COMMENT : 'UNCLOSED_DEPRECATED_ISML_COMMENT',
     INVALID_TEMPLATE                 : 'INVALID_TEMPLATE',
+    INVALID_NESTED_ISIF              : 'INVALID_NESTED_ISIF',
     INVALID_CHARACTER                : 'INVALID_CHARACTER',
     RULE_ERROR                       : 'RULE_ERROR',
     NO_CONFIG                        : 'NO_CONFIG',
@@ -99,6 +100,18 @@ const invalidCharacterError = (character, lineNumber, globalPos, length, templat
     };
 };
 
+const invalidNestedIsifError = (tagType, lineNumber, globalPos, templatePath) => {
+    return {
+        message      : `An error occurred while parsing element "<${tagType}>" in line ${lineNumber}. Try moving the closing character ">" of the "<${tagType}>" element to outside of the "<isif>" condition.`,
+        templatePath : templatePath,
+        globalPos,
+        length       : tagType.length,
+        lineNumber   : lineNumber,
+        isCustom     : true,
+        type         : types.INVALID_NESTED_ISIF
+    };
+};
+
 const parseError = (elementType, lineNumber, globalPos, length, templatePath) => {
     return {
         message      : `An unexpected error happened while parsing element ${elementType} at ${templatePath}:${lineNumber}.`,
@@ -111,6 +124,15 @@ const parseError = (elementType, lineNumber, globalPos, length, templatePath) =>
     };
 };
 
+const unkownError = (templatePath) => {
+    return {
+        message      : `An unexpected error happened while parsing template ${templatePath}. Please consider adding it to the ignore list for now.`,
+        templatePath : templatePath,
+        isCustom     : true,
+        type         : types.UNKNOWN_ERROR
+    };
+};
+
 const noConfigError = () => {
     return {
         message  : `No configuration found. Please run the following command: ${Constants.EOL}${Constants.EOL}\t./node_modules/.bin/isml-linter --init${Constants.EOL}${Constants.EOL}`,
@@ -137,6 +159,8 @@ module.exports = {
     parseError,
     unbalancedQuotesError,
     ruleApplianceError,
+    unkownError,
+    invalidNestedIsifError,
     unclosedDeprecatedIsmlComment,
     unbalancedElementError,
     unexpectedClosingElementError,