isml-linter 5.43.4 → 5.43.6

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [5.43.6] - 2023-02-25
+
+### Fixed
+ - "indent" Rule - don't add indentation to embbeded "isprint" tag if it's in the same line as previous attribute;
+ 
+## [5.43.5] - 2023-02-21
+
+### Fixed
+ - "indent" Rule - keep indentation of closing tag that is in same line as corresponding opening tag;
+ - Tree build for an empty template;
+ 
 ## [5.43.4] - 2023-02-20
 
 ### Fixed
@@ -1108,6 +1119,8 @@
 ### Added
 - Linter is published;
 
+[5.43.6]: https://github.com/FabiowQuixada/isml-linter/compare/v5.43.5...v5.43.6
+[5.43.5]: https://github.com/FabiowQuixada/isml-linter/compare/v5.43.4...v5.43.5
 [5.43.4]: https://github.com/FabiowQuixada/isml-linter/compare/v5.43.3...v5.43.4
 [5.43.3]: https://github.com/FabiowQuixada/isml-linter/compare/v5.43.2...v5.43.3
 [5.43.2]: https://github.com/FabiowQuixada/isml-linter/compare/v5.43.1...v5.43.2

package/package.json

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

package/src/isml_tree/IsmlNode.js

@@ -445,16 +445,16 @@ const privateToString = (node, stream = '') => {
 };
 
 const getAttributes = node => {
-    const trimmedHead              = node.head.trim();
-    const nodeHead                 = trimmedHead.substring(1, trimmedHead.length - 1);
-    const firstSpaceAfterTagPos    = ParseUtils.getFirstEmptyCharPos(trimmedHead);
-    const leadingEmptySpaceQty     = ParseUtils.getNextNonEmptyCharPos(nodeHead);
-    const afterTagContent          = nodeHead.substring(leadingEmptySpaceQty + firstSpaceAfterTagPos);
-    const stringifiedAttributeList = getStringifiedAttributeArray(afterTagContent);
-    const attributeList            = [];
-
-    for (let i = 0; i < stringifiedAttributeList.length; i++) {
-        const attr = parseAttribute(node, stringifiedAttributeList, i);
+    const trimmedHead           = node.head.trim();
+    const nodeHead              = trimmedHead.substring(1, trimmedHead.length - 1);
+    const firstSpaceAfterTagPos = ParseUtils.getFirstEmptyCharPos(trimmedHead);
+    const leadingEmptySpaceQty  = ParseUtils.getNextNonEmptyCharPos(nodeHead);
+    const afterTagContent       = nodeHead.substring(leadingEmptySpaceQty + firstSpaceAfterTagPos);
+    const rawAttributeList      = getStringifiedAttributeArray(afterTagContent);
+    const attributeList         = [];
+
+    for (let i = 0; i < rawAttributeList.length; i++) {
+        const attr = parseAttribute(node, rawAttributeList, attributeList, i);
         attributeList.push(attr);
     }
 
@@ -525,8 +525,8 @@ const getStringifiedAttributeArray = content => {
     return result;
 };
 
-const parseAttribute = (node, attributeList, index) => {
-    const attribute                             = attributeList[index];
+const parseAttribute = (node, rawAttributeList, resultingAttributeList, index) => {
+    const attribute                             = rawAttributeList[index];
     const isAttributeANestedIsmlTag             = attribute.startsWith('<is');
     const isExpressionAttribute                 = attribute.startsWith('${') && attribute.endsWith('}');
     const trimmedAttribute                      = attribute.trim();
@@ -547,6 +547,7 @@ const parseAttribute = (node, attributeList, index) => {
     const isFirstValueInSameLineAsAttributeName = value && ParseUtils.getLeadingLineBreakQty(value) === 0;
     const quoteChar                             = getQuoteChar(trimmedAttribute);
     const attributeNameFirstLine                = name.split(Constants.EOL)[0];
+    const isInSameLineAsPreviousAttribute       = index >= 1 && resultingAttributeList[index - 1].lineNumber === lineNumber;
 
     const columnNumber = isInSameLineAsTagName ?
         node.columnNumber + leadingContent.length :
@@ -572,6 +573,7 @@ const parseAttribute = (node, attributeList, index) => {
             isInSameLineAsTagName,
             isFirstInLine,
             isFirstValueInSameLineAsAttributeName,
+            isInSameLineAsPreviousAttribute,
             isExpressionAttribute,
             hasMultilineValue,
             isNestedIsmlTag : isAttributeANestedIsmlTag,
@@ -594,6 +596,7 @@ const parseAttribute = (node, attributeList, index) => {
             isInSameLineAsTagName,
             isFirstInLine,
             isFirstValueInSameLineAsAttributeName,
+            isInSameLineAsPreviousAttribute,
             isExpressionAttribute,
             hasMultilineValue,
             isNestedIsmlTag: isAttributeANestedIsmlTag,

package/src/isml_tree/ParseUtils.js

@@ -491,6 +491,10 @@ const getElementList = (templateContent, templatePath, isCrlfLineBreak) => {
     const elementList        = state.elementList;
     let previousStateContent = state.remainingShadowContent;
 
+    if (templateContent === '') {
+        return [];
+    }
+
     do {
         initLoopState(state);
         parseNextElement(state);

package/src/rules/tree/indent.js

@@ -441,21 +441,24 @@ const addIndentationToText = node => {
 };
 
 const getIndentedNestedIsmlContent = (attribute, nodeIndentation, attributeOffset) => {
-    if (attribute.fullContent.startsWith('<isif')) {
-        const attributeRootNode = TreeBuilder.parse(attribute.fullContent, null, null, true);
-        const fixedContent      = Rule.getFixedContent(attributeRootNode);
+    const attributeRootNode = TreeBuilder.parse(attribute.fullContent, null, null, true);
+    const fixedContent      = Rule.getFixedContent(attributeRootNode);
 
-        return fixedContent
-            .split(Constants.EOL)
-            .map( (line, i) => {
-                if (i === 0 && attribute.isFirstInLine && !attribute.isInSameLineAsTagName && attribute.index !== 0) {
-                    return Constants.EOL + nodeIndentation + attributeOffset + line;
-                }
+    return fixedContent
+        .split(Constants.EOL)
+        .map( (line, i) => {
+            const shouldAddLineBreak = i === 0 && attribute.isFirstInLine && !attribute.isInSameLineAsTagName && attribute.index !== 0;
 
-                return nodeIndentation + attributeOffset + line;
-            })
-            .join(Constants.EOL);
-    }
+            if (attribute.isInSameLineAsPreviousAttribute) {
+                return ' ' + line;
+            }
+
+            return (shouldAddLineBreak ? Constants.EOL : '')
+                + nodeIndentation
+                + attributeOffset
+                + line;
+        })
+        .join(Constants.EOL);
 };
 
 const getTreeBuiltAttributeIndentedValue = (attribute, nodeIndentation, attributeOffset) => {
@@ -763,6 +766,7 @@ const checkIfShouldAddIndentationToTail = node => {
     const isInSameLineAsChild       = !node.hasChildren() || node.getLastChild().isInSameLineAsParent();
     const isTailInSameLineAsChild   = !node.hasChildren() || node.tailLineNumber === node.getLastChild().getLastLineNumber();
     const isBrokenIntoMultipleLines = !node.hasChildren() && node.tailLineNumber && node.lineNumber !== node.tailLineNumber;
+    const isInSameLineAsOpeningTag  = !node.hasChildren() && node.tailLineNumber && node.endLineNumber === node.tailLineNumber;
 
     const shouldAdd = hasTail &&
         !isTailInSameLineAsChild &&
@@ -774,6 +778,11 @@ const checkIfShouldAddIndentationToTail = node => {
     ||
         isBrokenIntoMultipleLines;
 
+    // TODO Merge this condition into the above ones;
+    if (isInSameLineAsOpeningTag) {
+        return false;
+    }
+
     return shouldAdd;
 };