isml-linter 5.38.2 → 5.39.0

package/src/rules/prototypes/TreeRulePrototype.js

@@ -10,14 +10,14 @@ TreeRulePrototype.check = function(node, data) {
     const occurrenceList = this.checkChildren(node, data);
 
     if (this.isBroken(node)) {
-        let length = node.value.trim().length;
+        let length = node.head.trim().length;
 
         if (data.isCrlfLineBreak) {
-            length += ParseUtils.getLineBreakQty(node.value.trim());
+            length += ParseUtils.getLineBreakQty(node.head.trim());
         }
 
         const error = this.getError(
-            node.value.trim(),
+            node.head.trim(),
             node.lineNumber,
             node.columnNumber,
             node.globalPos,
@@ -68,7 +68,7 @@ TreeRulePrototype.return = function(node, occurrenceList, config) {
 TreeRulePrototype.fix = function(stream = '') {
 
     if (!this.isRoot() && !this.isContainer()) {
-        stream += this.value;
+        stream += this.head;
     }
 
     for (let i = 0; i < this.children.length; i++) {
@@ -78,10 +78,6 @@ TreeRulePrototype.fix = function(stream = '') {
             this.getFixedContent(node, stream);
     }
 
-    if (!this.isRoot() && !this.isContainer()) {
-        stream += this.suffix;
-    }
-
     return stream;
 };
 

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

@@ -67,11 +67,11 @@ Rule.checkAttributesAlignments = function(issetChildren, attrPosContainer) {
             const attr = attrArray[i];
             if (attr.localPos !== attrPosContainer[attr.name]) {
                 const error = this.getError(
-                    issetNode.value.trim(),
+                    issetNode.head.trim(),
                     issetNode.lineNumber,
                     issetNode.columnNumber,
                     issetNode.globalPos,
-                    issetNode.value.trim().length,
+                    issetNode.head.trim().length,
                     description
                 );
 

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

@@ -1,5 +1,5 @@
 const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const SfccTags          = require('../../enums/SfccTags');
+const SfccTagContainer  = require('../../enums/SfccTagContainer');
 
 const ruleId      = require('path').basename(__filename).slice(0, -3);
 const description = 'Embedded ISML is not allowed';
@@ -15,7 +15,7 @@ Rule.isBroken = function(node) {
 
     const attrList   = node.getAttributeList();
     const nodeType   = node.getType();
-    const sfccTagObj = SfccTags[nodeType];
+    const sfccTagObj = SfccTagContainer[nodeType];
     let result       = null;
 
     attrList.some( nodeAttribute => {
@@ -86,11 +86,11 @@ Rule.check = function(node, data) {
     const occurrence = this.isBroken(node);
     if (occurrence) {
         const error = this.getError(
-            node.value.trim(),
+            node.head.trim(),
             node.lineNumber,
             node.columnNumber,
             node.globalPos,
-            node.value.trim().length,
+            node.head.trim().length,
             occurrence.message
         );
 

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

@@ -1,5 +1,5 @@
-const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
-const CustomTags        = require('../../util/CustomTagUtils');
+const TreeRulePrototype  = require('../prototypes/TreeRulePrototype');
+const CustomTagContainer = require('../../util/CustomTagContainer');
 
 const ruleId      = require('path').basename(__filename).slice(0, -3);
 const description = 'Invalid custom tag';
@@ -10,11 +10,11 @@ Rule.init(ruleId, description);
 
 Rule.addError = function(node, message) {
     return this.getError(
-        node.value.trim(),
+        node.head.trim(),
         node.lineNumber,
         node.columnNumber,
         node.globalPos,
-        node.value.trim().length,
+        node.head.trim().length,
         message
     );
 };
@@ -26,7 +26,7 @@ Rule.check = function(node, data) {
     if (data) {
         const isUsedButNotDeclared = !data.moduleDefinition && data.customModuleArray && data.customModuleArray.length > 0;
 
-        if (node.value.indexOf('template="util/modules"') >= 0) {
+        if (node.head.indexOf('template="util/modules"') >= 0) {
             const isUnnecessaryDefinition = data.moduleDefinition && !data.customModuleArray;
 
             if (isUnnecessaryDefinition) {
@@ -37,7 +37,7 @@ Rule.check = function(node, data) {
 
         if (isUsedButNotDeclared && node.isCustomIsmlTag()) {
             const error = this.addError(node,
-                CustomTags[node.getType()] ?
+                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?`
             );

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

@@ -22,11 +22,11 @@ Rule.check = function(node, data) {
 
     if (this.isBroken(node)) {
         const error = this.getError(
-            node.value.trim(),
+            node.head.trim(),
             node.lineNumber,
             node.columnNumber,
             node.globalPos,
-            node.value.trim().length,
+            node.head.trim().length,
             `Tag "${node.getType()}" is not allowed.`
         );
 

package/src/rules/tree/empty-eof.js

@@ -12,9 +12,9 @@ Rule.init(ruleId, description);
 Rule.isBroken = function(node) {
     const tempNode = node.isContainer() ? node.getLastChild() : node;
 
-    return !(tempNode.suffixValue ?
-        tempNode.suffixValue.endsWith(Constants.EOL) :
-        tempNode.value.endsWith(Constants.EOL));
+    return !(tempNode.tail ?
+        tempNode.tail.endsWith(Constants.EOL) :
+        tempNode.head.endsWith(Constants.EOL));
 };
 
 Rule.check = function(rootNode, data) {
@@ -28,22 +28,22 @@ Rule.check = function(rootNode, data) {
         const lineBreakQty = ParseUtils.getLineBreakQty(node.toString());
         const lineNumber   = node.lineNumber + lineBreakQty - 1;
         let globalPos      = node.globalPos;
-        let length         = node.value.trim().length;
+        let length         = node.head.trim().length;
 
-        if (node.suffixValue) {
-            const lastLineBreakPos = node.suffixValue.lastIndexOf(Constants.EOL);
-            const trailingSpaces   = node.suffixValue.substring(lastLineBreakPos + 1);
+        if (node.tail) {
+            const lastLineBreakPos = node.tail.lastIndexOf(Constants.EOL);
+            const trailingSpaces   = node.tail.substring(lastLineBreakPos + 1);
 
             if (trailingSpaces.length > 0) {
-                globalPos = node.suffixGlobalPos + node.suffixValue.trim().length + 1;
+                globalPos = node.tailGlobalPos + node.tail.trim().length + 1;
                 length    = trailingSpaces.length;
 
                 if (data.isCrlfLineBreak) {
-                    globalPos += ParseUtils.getLineBreakQty(node.suffixValue.trimStart());
+                    globalPos += ParseUtils.getLineBreakQty(node.tail.trimStart());
                 }
             } else {
-                globalPos = node.suffixGlobalPos + 1;
-                length    = node.suffixValue.trim().length;
+                globalPos = node.tailGlobalPos + 1;
+                length    = node.tail.trim().length;
             }
         }
 

package/src/rules/tree/enforce-security.js

@@ -42,11 +42,11 @@ Rule.check = function(node, data) {
 
     for (let i = 0; i < errorMessageList.length; i++) {
         const error = this.getError(
-            node.value.trim(),
+            node.head.trim(),
             node.lineNumber,
             node.columnNumber,
             node.globalPos,
-            node.value.trim().length,
+            node.head.trim().length,
             errorMessageList[i]
         );
 

package/src/rules/tree/eslint-to-isscript.js

@@ -17,10 +17,10 @@ Rule.init(ruleId, description);
 Rule.addError = function(node, eslintError, ismlOffset, linter, data) {
     const errorLine = linter.getSourceCode() ?
         linter.getSourceCode().lines[eslintError.line - 1] :
-        node.value.split('\n')[eslintError.line - 1];
+        node.head.split('\n')[eslintError.line - 1];
 
-    const duplicatedOffset = ParseUtils.getNextNonEmptyCharPos(node.value);
-    const errorLocalPos    = node.value.indexOf(errorLine.trimStart()) - duplicatedOffset;
+    const duplicatedOffset = ParseUtils.getNextNonEmptyCharPos(node.head);
+    const errorLocalPos    = node.head.indexOf(errorLine.trimStart()) - duplicatedOffset;
     let errorGlobalPos     = node.globalPos;
     let columnNumber       = node.columnNumber;
     let length             = errorLine.trimStart().length;
@@ -28,7 +28,7 @@ Rule.addError = function(node, eslintError, ismlOffset, linter, data) {
 
     errorGlobalPos += data.isCrlfLineBreak ?
         errorLocalPos + eslintError.line - 2 :
-        node.value.trimStart().indexOf(errorLine.trimStart());
+        node.head.trimStart().indexOf(errorLine.trimStart());
 
     if (eslintError.ruleId === 'indent') {
         length         = getIndentErrorLength(eslintError, ismlOffset);
@@ -69,29 +69,30 @@ Rule.check = function(node, data) {
     }
 
     if (node.isRoot()) {
-        const Linter         = require('eslint').Linter;
-        const linter         = new Linter();
+        const ESLinter       = require('eslint').Linter;
+        const ruleConfig     = this.getConfigs();
+        const eslinter       = new ESLinter();
         const occurrenceList = [];
 
         for (let index = 0; index < isscriptContentArray.length; index++) {
             const jsContentNode = isscriptContentArray[index];
-            let content         = jsContentNode.value;
+            let content         = jsContentNode.head;
 
             const ismlOffset = getIsmlOffset(jsContentNode);
 
             content = unindent(content, ismlOffset.length);
 
-            const errorArray = linter.verify(content, eslintConfig);
+            const errorArray = eslinter.verify(content, eslintConfig);
 
             for (let i = 0; i < errorArray.length; i++) {
-                const error = this.addError(jsContentNode, errorArray[i], ismlOffset, linter, data);
+                const error = this.addError(jsContentNode, errorArray[i], ismlOffset, eslinter, data);
                 occurrenceList.push(error);
             }
         }
 
         isscriptContentArray = [];
 
-        return { occurrenceList };
+        return this.return(node, occurrenceList, ruleConfig);
     }
 };
 
@@ -112,12 +113,12 @@ Rule.getFixedContent = function(node) {
     if (node.isIsscriptContent()) {
         const Linter     = require('eslint').Linter;
         const linter     = new Linter();
-        let content      = node.value;
+        let content      = node.head;
         const ismlOffset = getIsmlOffset(node);
 
         this.result.fixedContent = content = linter.verifyAndFix(content, eslintConfig).output;
 
-        node.value = reIndent(content, ismlOffset);
+        node.head = reIndent(content, ismlOffset);
     }
 
     return GeneralUtils.applyActiveLineBreaks(node.toString());

package/src/rules/tree/indent.js

@@ -58,13 +58,13 @@ Rule.isBroken = function(node) {
         !node.isInSameLineAsPreviousSibling();
 };
 
-Rule.isBrokenForSuffix = function(node) {
+Rule.isTailBroken = function(node) {
 
     const configIndentSize         = this.getConfigs().indent;
     const expectedIndentation      = getExpectedIndentation(node, configIndentSize);
-    const actualIndentation        = getActualIndentationForSuffix(node);
-    const isInSameLineAsOpeningTag = node.lineNumber === node.suffixLineNumber;
-    const isInSameLineAsLastChild  = node.hasChildren() && node.getLastChild().getLastLineNumber() === node.suffixLineNumber;
+    const actualIndentation        = getActualTailIndentation(node);
+    const isInSameLineAsOpeningTag = node.lineNumber === node.tailLineNumber;
+    const isInSameLineAsLastChild  = node.hasChildren() && node.getLastChild().getLastLineNumber() === node.tailLineNumber;
 
     return !node.isRoot() &&
         !node.isContainer() &&
@@ -94,8 +94,8 @@ Rule.isClosingCharBroken = function(node) {
 
     if (node.isSelfClosing()) {
         if (closingCharsConfigs.selfClosingTag === 'always') {
-            const nodeValueLineList          = node.value.trim().split(Constants.EOL);
-            const isClosingCharStandingAlone = nodeValueLineList[nodeValueLineList.length - 1].trim() === '/>';
+            const nodeHeadLineList           = node.head.trim().split(Constants.EOL);
+            const isClosingCharStandingAlone = nodeHeadLineList[nodeHeadLineList.length - 1].trim() === '/>';
 
             return {
                 isBroken : !isClosingCharStandingAlone,
@@ -103,8 +103,8 @@ Rule.isClosingCharBroken = function(node) {
             };
 
         } else if (closingCharsConfigs.selfClosingTag === 'never') {
-            const nodeValueLineList          = node.value.trim().split(Constants.EOL);
-            const isClosingCharStandingAlone = nodeValueLineList[nodeValueLineList.length - 1].trim() === '/>';
+            const nodeHeadLineList           = node.head.trim().split(Constants.EOL);
+            const isClosingCharStandingAlone = nodeHeadLineList[nodeHeadLineList.length - 1].trim() === '/>';
 
             return {
                 isBroken : isClosingCharStandingAlone,
@@ -113,8 +113,8 @@ Rule.isClosingCharBroken = function(node) {
         }
     } else {
         if (closingCharsConfigs.nonSelfClosingTag === 'always') {
-            const nodeValueLineList          = node.value.trim().split(Constants.EOL);
-            const isClosingCharStandingAlone = nodeValueLineList[nodeValueLineList.length - 1].trim() === '>';
+            const nodeHeadLineList           = node.head.trim().split(Constants.EOL);
+            const isClosingCharStandingAlone = nodeHeadLineList[nodeHeadLineList.length - 1].trim() === '>';
 
             return {
                 isBroken : !isClosingCharStandingAlone,
@@ -122,8 +122,8 @@ Rule.isClosingCharBroken = function(node) {
             };
 
         } else if (closingCharsConfigs.nonSelfClosingTag === 'never') {
-            const nodeValueLineList          = node.value.trim().split(Constants.EOL);
-            const isClosingCharStandingAlone = nodeValueLineList[nodeValueLineList.length - 1].trim() === '>';
+            const nodeHeadLineList           = node.head.trim().split(Constants.EOL);
+            const isClosingCharStandingAlone = nodeHeadLineList[nodeHeadLineList.length - 1].trim() === '>';
 
             return {
                 isBroken : isClosingCharStandingAlone,
@@ -193,13 +193,13 @@ Rule.check = function(node, data) {
             const configIndentSize    = ruleConfig.indent;
             const expectedIndentation = getExpectedIndentation(node, configIndentSize);
             const actualIndentation   = getActualIndentation(node);
-            const nodeValue           = node.value.trim();
+            const nodeHead            = node.head.trim();
             const occurrenceLength    = actualIndentation === 0 ?
-                nodeValue.length + ParseUtils.getLineBreakQty(nodeValue) :
+                nodeHead.length + ParseUtils.getLineBreakQty(nodeHead) :
                 getActualIndentation(node);
 
             const error = this.getError(
-                node.value.trim(),
+                node.head.trim(),
                 node.lineNumber,
                 node.columnNumber,
                 errorGlobalPos,
@@ -217,22 +217,22 @@ Rule.check = function(node, data) {
             }
         }
 
-        // Checks node suffix value;
-        if (node.suffixValue && this.isBrokenForSuffix(node)) {
+        // Checks node tail value;
+        if (node.tail && this.isTailBroken(node)) {
             const configIndentSize    = ruleConfig.indent;
             const expectedIndentation = getExpectedIndentation(node, configIndentSize);
-            const actualIndentation   = getActualIndentationForSuffix(node);
-            const nodeSuffixValue     = node.suffixValue.trim();
+            const actualIndentation   = getActualTailIndentation(node);
+            const nodeTail            = node.tail.trim();
             const occurrenceLength    = actualIndentation === 0 ?
-                nodeSuffixValue.length +  ParseUtils.getLineBreakQty(nodeSuffixValue) :
-                getActualIndentationForSuffix(node);
-            const suffixGlobalPos     = node.suffixGlobalPos - getActualIndentationForSuffix(node);
+                nodeTail.length +  ParseUtils.getLineBreakQty(nodeTail) :
+                getActualTailIndentation(node);
+            const tailGlobalPos       = node.tailGlobalPos - getActualTailIndentation(node);
 
             const error = this.getError(
-                node.suffixValue.trim(),
-                node.suffixLineNumber,
-                node.suffixColumnNumber,
-                suffixGlobalPos,
+                node.tail.trim(),
+                node.tailLineNumber,
+                node.tailColumnNumber,
+                tailGlobalPos,
                 occurrenceLength,
                 getOccurrenceDescription(expectedIndentation, actualIndentation)
             );
@@ -248,15 +248,15 @@ Rule.check = function(node, data) {
             if (node.isSelfClosing()) {
                 const closingChar  = '/>';
                 const globalPos    = node.globalPos
-                    + node.value.trim().lastIndexOf(closingChar);
-                const lineList     = node.value.split(Constants.EOL);
+                    + node.head.trim().lastIndexOf(closingChar);
+                const lineList     = node.head.split(Constants.EOL);
                 const columnNumber = lineList[lineList.length - 1].lastIndexOf(closingChar) + 1;
                 const message      = checkResult.config === 'always' ?
                     getStandAloneCharDescription(node.getType(), closingChar) :
                     getNonStandAloneCharDescription(node.getType(), closingChar);
 
                 const error = this.getError(
-                    node.value.trim(),
+                    node.head.trim(),
                     node.endLineNumber,
                     columnNumber,
                     globalPos,
@@ -269,15 +269,15 @@ Rule.check = function(node, data) {
             } else {
                 const closingChar  = '>';
                 const globalPos    = node.globalPos
-                    + node.value.trim().length - closingChar.length;
-                const lineList     = node.value.trim().split(Constants.EOL);
+                    + node.head.trim().length - closingChar.length;
+                const lineList     = node.head.trim().split(Constants.EOL);
                 const columnNumber = lineList[lineList.length - 1].lastIndexOf(closingChar) + 1;
                 const message      = checkResult.config === 'always' ?
                     getStandAloneCharDescription(node.getType(), closingChar) :
                     getNonStandAloneCharDescription(node.getType(), closingChar);
 
                 const error = this.getError(
-                    node.value.trim(),
+                    node.head.trim(),
                     node.endLineNumber,
                     columnNumber,
                     globalPos,
@@ -406,7 +406,7 @@ const removeIndentation = content => {
 };
 
 const addIndentationToText = node => {
-    const content   = node.value;
+    const content   = node.head;
     const lineArray = content
         .split(Constants.EOL)
         .filter( (line, i) => !(i === 0 && line === ''))
@@ -584,15 +584,15 @@ const getExpressionAttributeIndentation = (attributeValue, nodeIndentation, attr
 };
 
 const getClosingChars = node => {
-    const nodeValue = node.value.trim();
+    const nodeHead = node.head.trim();
 
-    if (nodeValue.endsWith(' />')) {
+    if (nodeHead.endsWith(' />')) {
         return ' />';
-    } else if (nodeValue.endsWith('/>')) {
+    } else if (nodeHead.endsWith('/>')) {
         return ' />';
-    } else if (nodeValue.endsWith(' >')) {
+    } else if (nodeHead.endsWith(' >')) {
         return ' >';
-    } else if (nodeValue.endsWith('>')) {
+    } else if (nodeHead.endsWith('>')) {
         return '>';
     }
 
@@ -600,7 +600,7 @@ const getClosingChars = node => {
 };
 
 const addIndentation = (node, isOpeningTag) => {
-    const content             = isOpeningTag ? node.value : node.suffixValue;
+    const content             = isOpeningTag ? node.head : node.tail;
     const startingPos         = ParseUtils.getNextNonEmptyCharPos(content);
     const endingPos           = content.length - ParseUtils.getNextNonEmptyCharPos(content.split('').reverse().join(''));
     const fullLeadingContent  = content.substring(0, startingPos);
@@ -614,13 +614,13 @@ const addIndentation = (node, isOpeningTag) => {
     if (isOpeningTag) {
         const shouldAddIndentationToClosingChar = shouldAddIndentationToClosingChars(node);
         const closingChars                      = getClosingChars(node);
-        const tagNameEndPos                     = ParseUtils.getLeadingLineBreakQty(node.value)
-            + ParseUtils.getFirstEmptyCharPos(node.value.trim()) + 1;
+        const tagNameEndPos                     = ParseUtils.getLeadingLineBreakQty(node.head)
+            + ParseUtils.getFirstEmptyCharPos(node.head.trim()) + 1;
 
-        if (ParseUtils.getLineBreakQty(node.value.trim()) > 0 || shouldAddIndentationToClosingChar && node.isSelfClosing()) {
+        if (ParseUtils.getLineBreakQty(node.head.trim()) > 0 || shouldAddIndentationToClosingChar && node.isSelfClosing()) {
             contentResult = attributeList.length > 0 ?
-                node.value.substring(0, tagNameEndPos).trimStart() :
-                node.value.trimStart();
+                node.head.substring(0, tagNameEndPos).trimStart() :
+                node.head.trimStart();
 
             for (let i = 0; i < attributeList.length; i++) {
                 contentResult += indentAttribute(attributeList, i, nodeIndentation, attributeOffset);
@@ -632,10 +632,10 @@ const addIndentation = (node, isOpeningTag) => {
                     closingChars;
             }
         } else {
-            contentResult = node.value.trim();
+            contentResult = node.head.trim();
         }
     } else {
-        contentResult = node.suffixValue.trim();
+        contentResult = node.tail.trim();
     }
 
     return preLineBreakContent + nodeIndentation + contentResult + fullTrailingContent;
@@ -644,15 +644,15 @@ const addIndentation = (node, isOpeningTag) => {
 const removeAllIndentation = node => {
     if (!node.isRoot() && !node.isContainer() && !node.parent.isOneOfTypes(['isscript', 'script'])) {
 
-        const shouldRemoveValueIndentation  = node.value && !node.isInSameLineAsPreviousSibling() && !node.isInSameLineAsParent() && !(node.lineNumber === node.parent.endLineNumber);
-        const shouldRemoveSuffixIndentation = node.suffixValue && !(node.hasChildren() && node.getLastChild().lineNumber === node.suffixLineNumber);
+        const shouldRemoveHeadIndentation = node.head && !node.isInSameLineAsPreviousSibling() && !node.isInSameLineAsParent() && !(node.lineNumber === node.parent.endLineNumber);
+        const shouldRemoveTailIndentation = node.tail && !(node.hasChildren() && node.getLastChild().lineNumber === node.tailLineNumber);
 
-        if (shouldRemoveValueIndentation) {
-            node.value = removeIndentation(node.value);
+        if (shouldRemoveHeadIndentation) {
+            node.head = removeIndentation(node.head);
         }
 
-        if (shouldRemoveSuffixIndentation) {
-            node.suffixValue = removeIndentation(node.suffixValue);
+        if (shouldRemoveTailIndentation) {
+            node.tail = removeIndentation(node.tail);
         }
     }
 
@@ -665,21 +665,21 @@ const addCorrectIndentation = node => {
 
     if (!node.isRoot() && !node.isContainer() && !node.parent.isOneOfTypes(['isscript', 'script'])) {
         if (node.parent.isOfType('iscomment')) {
-            const shouldAddIndentationToText = checkIfShouldAddIndentationToValue(node);
+            const shouldAddIndentationToText = checkIfShouldAddIndentationToHead(node);
 
             if (shouldAddIndentationToText) {
-                node.value = addIndentationToText(node);
+                node.head = addIndentationToText(node);
             }
         } else {
-            const shouldAddIndentationToValue  = checkIfShouldAddIndentationToValue(node);
-            const shouldAddIndentationToSuffix = checkIfShouldAddIndentationToSuffix(node);
+            const shouldAddIndentationToHead = checkIfShouldAddIndentationToHead(node);
+            const shouldAddIndentationToTail = checkIfShouldAddIndentationToTail(node);
 
-            if (shouldAddIndentationToValue) {
-                node.value = addIndentation(node, true);
+            if (shouldAddIndentationToHead) {
+                node.head = addIndentation(node, true);
             }
 
-            if (shouldAddIndentationToSuffix) {
-                node.suffixValue = addIndentation(node, false);
+            if (shouldAddIndentationToTail) {
+                node.tail = addIndentation(node, false);
             }
         }
     }
@@ -706,7 +706,7 @@ const shouldAddIndentationToClosingChars = node => {
         }
     }
 
-    const lineList = node.value.split(Constants.EOL);
+    const lineList = node.head.split(Constants.EOL);
     const lastLine = lineList[lineList.length - 1];
 
     return ['/>', '>'].indexOf(lastLine) >= 0;
@@ -727,31 +727,31 @@ const shouldAddIndentationToClosingQuote = attribute => {
     return lastLine.trim().length === 0;
 };
 
-const checkIfShouldAddIndentationToValue = node => {
+const checkIfShouldAddIndentationToHead = node => {
     const previousSibling                   = node.getPreviousSibling();
     const isInSameLineAsPrevSiblingLastLine = !node.isRoot() &&
         previousSibling &&
         node.lineNumber === previousSibling.getLastLineNumber();
-    const isInSameLineAsParentValueEnd      = node.parent.endLineNumber === node.lineNumber && !node.parent.isContainer();
+    const isInSameLineAsParentHeadEnd       = node.parent.endLineNumber === node.lineNumber && !node.parent.isContainer();
 
     const shouldAdd = !node.isRoot() &&
         !isInSameLineAsPrevSiblingLastLine &&
-        !isInSameLineAsParentValueEnd &&
+        !isInSameLineAsParentHeadEnd &&
         (node.isFirstChild() || previousSibling && node.lineNumber !== previousSibling.lineNumber) &&
-        node.value && node.lineNumber !== node.parent.endLineNumber;
+        node.head && node.lineNumber !== node.parent.endLineNumber;
 
     return shouldAdd;
 };
 
-const checkIfShouldAddIndentationToSuffix = node => {
-    const hasSuffix                 = !!node.suffixValue;
+const checkIfShouldAddIndentationToTail = node => {
+    const hasTail                   = !!node.tail;
     const isLastClause              = !!node.parent && node.parent.isContainer() && !node.isLastChild();
     const isInSameLineAsChild       = !node.hasChildren() || node.getLastChild().isInSameLineAsParent();
-    const isSuffixInSameLineAsChild = !node.hasChildren() || node.suffixLineNumber === node.getLastChild().getLastLineNumber();
-    const isBrokenIntoMultipleLines = !node.hasChildren() && node.suffixLineNumber && node.lineNumber !== node.suffixLineNumber;
+    const isTailInSameLineAsChild   = !node.hasChildren() || node.tailLineNumber === node.getLastChild().getLastLineNumber();
+    const isBrokenIntoMultipleLines = !node.hasChildren() && node.tailLineNumber && node.lineNumber !== node.tailLineNumber;
 
-    const shouldAdd = hasSuffix &&
-        !isSuffixInSameLineAsChild &&
+    const shouldAdd = hasTail &&
+        !isTailInSameLineAsChild &&
         !isInSameLineAsChild &&
         !isLastClause
     ||
@@ -765,7 +765,7 @@ const getEslintChildTrailingSpaces = node => {
     if (node.isOfType('isscript')) {
         const child = node.getLastChild();
 
-        const trailingSpacesQty = child.value
+        const trailingSpacesQty = child.head
             .replace(/\r\n/g, '_')
             .split('')
             .reverse()
@@ -848,6 +848,6 @@ const getNonStandAloneCharDescription  = (tagName, closingChars) => `"${closingC
 const getOccurrenceDescription         = (expected, actual) => `Expected indentation of ${expected} spaces but found ${actual}`;
 const getExpectedIndentation           = (node, configIndentSize) => (node.depth - 1) * configIndentSize;
 const getActualIndentation             = node => node.getIndentationSize();
-const getActualIndentationForSuffix    = node => node.getSuffixIndentationSize() + getEslintChildTrailingSpaces(node);
+const getActualTailIndentation         = node => node.getTailIndentationSize() + getEslintChildTrailingSpaces(node);
 
 module.exports = Rule;

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

@@ -32,7 +32,7 @@ Rule.getFixedContent = function(rootNode) {
 
         if (isContentNode) {
             isContentNode.parent.removeChild(isContentNode);
-            isContentNode.value = isContentNode.value.trim() + Constants.EOL;
+            isContentNode.head = isContentNode.head.trim() + Constants.EOL;
             rootNode.addChildNodeToPos(isContentNode, 0);
         }
     }

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

@@ -28,7 +28,7 @@ Rule.getFixedContent = function(rootNode) {
 
         if (isContentNode) {
             isContentNode.parent.removeChild(isContentNode);
-            isContentNode.value = isContentNode.value.trim() + Constants.EOL;
+            isContentNode.head = isContentNode.head.trim() + Constants.EOL;
             rootNode.addChildNodeToPos(isContentNode, 0);
         }
     }