isml-linter 5.41.0 → 5.42.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [5.42.1] - 2023-01-28
+
+### Fixed
+ - Keep template original linebreak if one is not explictly set in the ISML Linter configuration file. It was forcing a Unix linebreak;
+ 
+## [5.42.0] - 2023-01-25
+
+### Added
+ - Introducing ["strict-void-elements" rule][strict-void-elements-readme];
+
+### Changed
+ - Allow Closing Tags for Void Elements in AST. "strict-void-elements" rule will optionally handle that invalid scenario;
+
+### Fixed
+ - "indent" Rule - Add "line" Attribute to Quote Issue Report;
+ 
 ## [5.41.0] - 2023-01-21
 
 ### Added
@@ -1048,6 +1064,8 @@
 ### Added
 - Linter is published;
 
+[5.42.1]: https://github.com/FabiowQuixada/isml-linter/compare/v5.42.0...v5.42.1
+[5.42.0]: https://github.com/FabiowQuixada/isml-linter/compare/v5.41.0...v5.42.0
 [5.41.0]: https://github.com/FabiowQuixada/isml-linter/compare/v5.40.5...v5.41.0
 [5.40.5]: https://github.com/FabiowQuixada/isml-linter/compare/v5.40.4...v5.40.5
 [5.40.4]: https://github.com/FabiowQuixada/isml-linter/compare/v5.40.3...v5.40.4
@@ -1211,11 +1229,12 @@
 [api-docs]: <docs/api.md>
 [license]:  <LICENSE>
 
-[disallow-tags-readme]:      <docs/rules/disallow-tags.md>
-[no-br-readme]:              <docs/rules/no-br.md>
-[no-inline-style-readme]:    <docs/rules/no-br.md>
-[no-isscript-readme]:        <docs/rules/no-isscript.md>
-[enforce-security-readme]:   <docs/rules/enforce-security.md>
-[no-hardcode-readme]:        <docs/rules/no-hardcode.md>
-[indent-readme]:             <docs/rules/indent.md>
-[eslint-to-isscript-readme]: <docs/rules/eslint-to-isscript.md>
+[strict-void-elements-readme]: <docs/rules/strict-void-elements.md>
+[disallow-tags-readme]:        <docs/rules/disallow-tags.md>
+[no-br-readme]:                <docs/rules/no-br.md>
+[no-inline-style-readme]:      <docs/rules/no-br.md>
+[no-isscript-readme]:          <docs/rules/no-isscript.md>
+[enforce-security-readme]:     <docs/rules/enforce-security.md>
+[no-hardcode-readme]:          <docs/rules/no-hardcode.md>
+[indent-readme]:               <docs/rules/indent.md>
+[eslint-to-isscript-readme]:   <docs/rules/eslint-to-isscript.md>

package/README.md

@@ -3,7 +3,7 @@ ISML Linter is a tool for examining if your project's templates follow a specifi
 
  - Styles that are defined by your team;
  - Syntactic errors related to `<is* >` tags;
- - Coding conventions recommended by SalesForce;
+ - Coding conventions recommended by Salesforce;
  - Git conflicts that may accidentally be left unresolved;
 
 Please feel free to make suggestions and help make this linter better. :) The set of currently available rules can be found below.
@@ -161,7 +161,7 @@ Please check the [Generic Configurations for Rules][generic-rule-config] page.
 | ------------------------------------------------------------------------------------ |:-----------------------------------------|
 | :exclamation: [no-br][no-br-readme]                                                  | <span style="color:orange">[Deprecated]</span> Disallows `<br/>` tags. Enable this rule if you prefer to use CSS to handle vertical spacing |
 | [no-git-conflict][no-git-conflict-readme]                                            | Disallows unresolved Git conflicts |
-| [no-import-package][no-import-package-readme]                                        | Disallows `importPackage()` function. It is recommended by SalesForce to use `require()` instead |
+| [no-import-package][no-import-package-readme]                                        | Disallows `importPackage()` function. It is recommended by Salesforce to use `require()` instead |
 | :exclamation: [no-isscript][no-isscript-readme]                                      | <span style="color:orange">[Deprecated]</span> Disallows `<isscript/>` tag in template. Enable this rule if you prefer logic to be kept in a separate .ds/.js file |
 | :wrench: [no-trailing-spaces][no-trailing-spaces-readme]                             | Disallows trailing blank spaces |
 | :wrench: [no-space-only-lines][no-space-only-lines-readme]                           | Disallows lines that contain only blank spaces, i.e., unnecessarily indented |
@@ -189,6 +189,7 @@ Please check the [Generic Configurations for Rules][generic-rule-config] page.
 | :small_orange_diamond: [align-isset][align-isset-readme]                             | Aligns contiguous `<isset>` tags attributes' columns |
 | :small_orange_diamond: [enforce-security][enforce-security-readme]                   | Enforces security measures |
 | :wrench: :small_orange_diamond: [no-redundant-context][no-redundant-context-readme]  | Prevents use of unnecessary contexts, such as `dw.web.Resource` |
+| :small_orange_diamond: [strict-void-elements][strict-void-elements-readme]  | Disallows closing tags for void elements, such as `<input>` and `<img>` |
 
 You are more than welcome to contribute with us! Please check the [contribute section][contribute-docs].
 
@@ -235,6 +236,7 @@ This project was conceived by its author without any financial support, with the
 [disallow-tags-readme]:          <docs/rules/disallow-tags.md>
 [enforce-security-readme]:       <docs/rules/enforce-security.md>
 [no-redundant-context-readme]:   <docs/rules/no-redundant-context.md>
+[strict-void-elements-readme]:   <docs/rules/strict-void-elements.md>
 
 [api-docs]:        <docs/api.md>
 [cli-docs]:        <docs/cli.md>

package/package.json

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

package/scaffold_files/ismllinter.config.js

@@ -38,6 +38,7 @@ const config = {
             values : ['isscript', 'br', 'style', 'iframe']
         },
         'enforce-security'     : {},
+        'strict-void-elements' : {},
 
         // Other
         'lowercase-filename' : {}

package/src/IsmlLinter.js

@@ -101,12 +101,12 @@ const getEmptyResult = () => {
     };
 };
 
-const checkTemplate = (templatePath, data, content, templateName) => {
+const parseAndPossiblyFixTemplate = (templatePath, data, content, templateName) => {
     const formattedTemplatePath = GeneralUtils.formatTemplatePath(templatePath);
     const templateResults       = getEmptyResult();
 
     try {
-        const parseResult = RuleUtils.checkTemplate(templatePath, data, content, templateName);
+        const parseResult = RuleUtils.parseAndPossiblyFixTemplate(templatePath, data, content, templateName);
 
         if (parseResult.fixed) {
             templateResults.templatesFixed++;
@@ -232,7 +232,7 @@ Linter.run = (pathData, content, data = {}) => {
             const isIgnored    = FileUtils.isIgnored(templatePath);
 
             if (!isIgnored) {
-                const templateResults = checkTemplate(templatePath, data, content, templateName);
+                const templateResults = parseAndPossiblyFixTemplate(templatePath, data, content, templateName);
 
                 finalResult = merge(finalResult, templateResults);
             }

package/src/isml_tree/IsmlNode.js

@@ -6,6 +6,7 @@ const SfccTagContainer = require('../enums/SfccTagContainer');
 const ParseUtils       = require('./ParseUtils');
 const MaskUtils        = require('./MaskUtils');
 const ExceptionUtils   = require('../util/ExceptionUtils');
+const GeneralUtils     = require('../util/GeneralUtils');
 
 let ID_COUNTER = 0;
 
@@ -149,6 +150,7 @@ class IsmlNode {
         newNode.isEmbeddedNode = this.isEmbeddedNode;
     }
 
+    getChild(number) { return this.children[number];                   }
     getLastChild()   { return this.children[this.children.length - 1]; }
     getChildrenQty() { return this.children.length;                    }
     hasChildren()    { return this.children.length > 0;                }
@@ -382,24 +384,11 @@ class IsmlNode {
         return rootNode;
     }
 
-    toString(stream = '') {
+    toString() {
 
-        if (!this.isContainer() && this.isEmpty() && !this.isLastChild()) {
-            return stream;
-        }
-
-        if (!this.isRoot() && !this.isContainer()) {
-            stream += this.head;
-        }
-
-        for (let i = 0; i < this.children.length; i++) {
-            const child = this.children[i];
-            stream      = child.toString(stream);
-        }
+        let stream = privateToString(this);
 
-        if (!this.isRoot() && !this.isContainer()) {
-            stream += this.tail;
-        }
+        stream = GeneralUtils.applyLineBreak(stream, this.getRoot().tree.originalLineBreak);
 
         return stream;
     }
@@ -428,6 +417,27 @@ class IsmlNode {
  * will be available for use only within IsmlNode methods;
 */
 
+const privateToString = (node, stream = '') => {
+    if (!node.isContainer() && node.isEmpty() && !node.isLastChild()) {
+        return stream;
+    }
+
+    if (!node.isRoot() && !node.isContainer()) {
+        stream += node.head;
+    }
+
+    for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        stream      = privateToString(child, stream);
+    }
+
+    if (!node.isRoot() && !node.isContainer()) {
+        stream += node.tail;
+    }
+
+    return stream;
+};
+
 const getAttributes = node => {
     const trimmedHead              = node.head.trim();
     const nodeHead                 = trimmedHead.substring(1, trimmedHead.length - 1);

package/src/isml_tree/ParseUtils.js

@@ -136,7 +136,7 @@ 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,
@@ -275,6 +275,7 @@ const getNextClosingTagOrExpressionEndPos = content => {
 };
 
 const getInitialState = (templateContent, templatePath, isCrlfLineBreak) => {
+    // TODO Check if "GeneralUtils.toLF" can be removed;
     const originalContent       = GeneralUtils.toLF(templateContent);
     const originalShadowContent = MaskUtils.maskIgnorableContent(originalContent, null, templatePath);
 

package/src/isml_tree/TreeBuilder.js

@@ -32,6 +32,10 @@ const parse = (content, templatePath, isCrlfLineBreak, isEmbeddedNode) => {
 
     ParseUtils.checkBalance(rootNode, templatePath);
 
+    rootNode.tree = {
+        originalLineBreak : GeneralUtils.getFileLineBreakStyle(content),
+    };
+
     return rootNode;
 };
 
@@ -110,14 +114,8 @@ const parseContainerElements = (element, currentParent, newNode, templatePath) =
 
 const parseNonContainerElements = (element, currentParent, newNode, templatePath) => {
     if (element.isSelfClosing) {
-        if (element.isClosingTag && element.isVoidElement) {
-            throw ExceptionUtils.voidElementClosingTag(
-                element.tagType,
-                element.lineNumber,
-                element.globalPos,
-                element.value.trim().length,
-                templatePath
-            );
+        if (element.isClosingTag  && element.isVoidElement) {
+            currentParent.getLastChild().setTail(element.value, element.lineNumber, element.columnNumber, element.globalPos);
         } else {
             currentParent.addChild(newNode);
         }
@@ -209,15 +207,17 @@ const build = (templatePath, content, isCrlfLineBreak) => {
 
     const ParseStatus = require('../enums/ParseStatus');
 
-    const result = {
+    const templateContent = content || fs.readFileSync(templatePath, 'utf-8');
+    const result          = {
+        originalLineBreak : GeneralUtils.getFileLineBreakStyle(templateContent),
         templatePath,
         status : ParseStatus.NO_ERRORS
     };
 
     try {
-        const templateContent = GeneralUtils.toLF(content || fs.readFileSync(templatePath, 'utf-8'));
-        result.rootNode       = parse(templateContent, templatePath, isCrlfLineBreak);
-        result.data           = postProcess(result.rootNode);
+        const formattedTemplateContent = templateContent;
+        result.rootNode                = parse(formattedTemplateContent, templatePath, isCrlfLineBreak);
+        result.data                    = postProcess(result.rootNode);
 
         result.rootNode.tree = result;
 

package/src/publicApi.js

@@ -24,7 +24,7 @@ module.exports = {
             autofixConfig.autoFix = true;
             IsmlLinter.setConfig(autofixConfig);
         } else {
-            autofixConfig = IsmlLinter.getConfig();
+            autofixConfig         = IsmlLinter.getConfig();
             autofixConfig.autoFix = true;
             IsmlLinter.setConfig(autofixConfig);
         }

package/src/rules/line_by_line/max-lines.js

@@ -1,5 +1,4 @@
 const SingleLineRulePrototype = require('../prototypes/SingleLineRulePrototype');
-const Constants               = require('../../Constants');
 const GeneralUtils            = require('../../util/GeneralUtils');
 
 const ruleId      = require('path').basename(__filename).slice(0, -3);
@@ -21,8 +20,9 @@ Rule.getColumnNumber = function() {
 
 Rule.check = function(templateContent) {
 
+    const lineBreak      = GeneralUtils.getFileLineBreakStyle(templateContent);
     const maxLines       = this.getConfigs().max;
-    const lineArray      = GeneralUtils.toLF(templateContent).split(Constants.EOL);
+    const lineArray      = templateContent.split(lineBreak);
     const columnNumber   = this.getColumnNumber();
     const occurrenceList = [];
 

package/src/rules/line_by_line/no-space-only-lines.js

@@ -17,9 +17,9 @@ Rule.getColumnNumber = function() {
 Rule.getFixedContent = function(templateContent) {
     const GeneralUtils = require('../../util/GeneralUtils');
 
-    const activeLineBreak = GeneralUtils.getActiveLineBreak();
-    const lineArray       = templateContent.split(Constants.EOL);
-    const result          = [];
+    const lineBreak = GeneralUtils.getFileLineBreakStyle(templateContent);
+    const lineArray = templateContent.split(lineBreak);
+    const result    = [];
 
     for (let i = 0; i < lineArray.length; i++) {
         const line = lineArray[i];
@@ -27,7 +27,7 @@ Rule.getFixedContent = function(templateContent) {
         result.push(line.trim() ? line : line.trim());
     }
 
-    return result.join(activeLineBreak);
+    return GeneralUtils.applyLineBreak(result.join(lineBreak));
 };
 
 Rule.getFirstOccurrence = function(line) {

package/src/rules/line_by_line/no-tabs.js

@@ -16,9 +16,11 @@ Rule.getColumnNumber = function(line) {
 };
 
 Rule.getFixedContent = function(templateContent) {
+    const lineBreak    = GeneralUtils.getFileLineBreakStyle(templateContent);
     const indent       = IndentRule.getIndentation();
     const fixedContent = templateContent.replace(/\t/g, indent);
-    return GeneralUtils.applyActiveLineBreaks(fixedContent);
+
+    return GeneralUtils.applyLineBreak(fixedContent, lineBreak);
 };
 
 Rule.getFirstOccurrence = function(line) {

package/src/rules/line_by_line/no-trailing-spaces.js

@@ -1,5 +1,4 @@
 const SingleLineRulePrototype = require('../prototypes/SingleLineRulePrototype');
-const Constants               = require('../../Constants');
 const ParseUtils              = require('../../isml_tree/ParseUtils');
 
 const ruleId      = require('path').basename(__filename).slice(0, -3);
@@ -19,9 +18,9 @@ Rule.getColumnNumber = function(line) {
 Rule.getFixedContent = function(templateContent) {
     const GeneralUtils = require('../../util/GeneralUtils');
 
-    const activeLineBreak = GeneralUtils.getActiveLineBreak();
-    const lineArray       = GeneralUtils.toLF(templateContent).split(Constants.EOL);
-    const result          = [];
+    const lineBreak = GeneralUtils.getFileLineBreakStyle(templateContent);
+    const lineArray = templateContent.split(lineBreak);
+    const result    = [];
 
     for (let i = 0; i < lineArray.length; i++) {
         const line = lineArray[i];
@@ -29,7 +28,7 @@ Rule.getFixedContent = function(templateContent) {
         result.push(line.replace(/\s+$/g, ''));
     }
 
-    return result.join(activeLineBreak);
+    return GeneralUtils.applyLineBreak(result.join(lineBreak), lineBreak);
 };
 
 Rule.getFirstOccurrence = function(line) {

package/src/rules/prototypes/SingleLineRulePrototype.js

@@ -1,14 +1,14 @@
 const RulePrototype = require('./RulePrototype');
 const ConfigUtils   = require('../../util/ConfigUtils');
-const Constants     = require('../../Constants');
 const GeneralUtils  = require('../../util/GeneralUtils');
 
 const SingleLineRulePrototype = Object.create(RulePrototype);
 
 SingleLineRulePrototype.check = function(templateContent, data = { isCrlfLineBreak : false }) {
 
+    const lineBreak      = GeneralUtils.getFileLineBreakStyle(templateContent);
     const config         = ConfigUtils.load();
-    const lineArray      = GeneralUtils.toLF(templateContent).split(Constants.EOL);
+    const lineArray      = templateContent.split(lineBreak);
     const occurrenceList = [];
     let globalPos        = 0;
 
@@ -41,10 +41,10 @@ SingleLineRulePrototype.check = function(templateContent, data = { isCrlfLineBre
         };
     }
 
-    return { 
+    return {
         occurrenceList,
         fixedContent : templateContent
-     };
+    };
 };
 
 module.exports = SingleLineRulePrototype;

package/src/rules/prototypes/TreeRulePrototype.js

@@ -65,20 +65,4 @@ TreeRulePrototype.return = function(node, occurrenceList, config) {
     }
 };
 
-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/eslint-to-isscript.js

@@ -2,7 +2,6 @@ const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
 const ParseUtils        = require('../../isml_tree/ParseUtils');
 const Constants         = require('../../Constants');
 const ConfigUtils       = require('../../util/ConfigUtils');
-const GeneralUtils      = require('../../util/GeneralUtils');
 
 const ruleId          = require('path').basename(__filename).slice(0, -3);
 const description     = 'Not eslint-valid';
@@ -121,7 +120,7 @@ Rule.getFixedContent = function(node) {
         node.head = reIndent(content, ismlOffset);
     }
 
-    return GeneralUtils.applyActiveLineBreaks(node.toString());
+    return node.toString();
 };
 
 const unindent = (content, indentSize) => {

package/src/rules/tree/indent.js

@@ -161,8 +161,15 @@ Rule.isQuoteClosingCharBroken = function(node) {
                     '';
 
             if (message) {
+                const lineBreak = node.getRoot().tree.originalLineBreak;
+                const line      = node
+                    .getRoot()
+                    .toString()
+                    .split(lineBreak)[lineNumber - 1];
+
                 result.push({
                     quoteChar    : attribute.quoteChar,
+                    line         : line,
                     lineNumber   : lineNumber,
                     columnNumber : columnNumber,
                     globalPos    : globalPos,

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

@@ -1,7 +1,6 @@
 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);
@@ -33,7 +32,7 @@ Rule.getFixedContent = function(rootNode) {
         }
     }
 
-    return GeneralUtils.applyActiveLineBreaks(rootNode.toString());
+    return rootNode.toString();
 };
 
 module.exports = Rule;

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

@@ -1,7 +1,6 @@
 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);
@@ -29,7 +28,7 @@ Rule.getFixedContent = function(rootNode) {
         }
     }
 
-    return GeneralUtils.applyActiveLineBreaks(rootNode.toString());
+    return rootNode.toString();
 };
 
 module.exports = Rule;

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

@@ -1,6 +1,5 @@
 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';
@@ -29,7 +28,7 @@ Rule.getFixedContent = function(node) {
         this.getFixedContent(child);
     }
 
-    return GeneralUtils.applyActiveLineBreaks(node.toString());
+    return node.toString();
 };
 
 module.exports = Rule;

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

@@ -2,7 +2,6 @@ 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 TreeBuilder       = require('../../isml_tree/TreeBuilder');
 
 const ruleId      = require('path').basename(__filename).slice(0, -3);
@@ -42,7 +41,7 @@ Rule.getFixedContent = rootNode => {
     const newRootNode       = TreeBuilder.build(null, stringifiedTree).rootNode;
     const partialFixContent = IndentRule.getFixedContent(newRootNode);
 
-    return GeneralUtils.applyActiveLineBreaks(partialFixContent);
+    return partialFixContent;
 };
 
 const addLineBreaks = node => {

package/src/rules/tree/strict-void-elements.js

@@ -0,0 +1,46 @@
+const TreeRulePrototype = require('../prototypes/TreeRulePrototype');
+
+const ruleId      = require('path').basename(__filename).slice(0, -3);
+const description = 'This is a void element, and as such, should not have a corresponding closing tag';
+
+const Rule = Object.create(TreeRulePrototype);
+
+Rule.init(ruleId, description);
+
+Rule.isBroken = function(node) {
+    return node.isVoidElement() && node.tail.length > 0;
+};
+
+Rule.check = function(node, data) {
+
+    const ruleConfig   = this.getConfigs();
+    let occurrenceList = [];
+
+    occurrenceList = this.checkChildren(node, data);
+
+    if (this.isBroken(node)) {
+        const error = this.getError(
+            node.tail.trim(),
+            node.tailLineNumber,
+            node.tailColumnNumber,
+            node.tailGlobalPos,
+            node.tail.trim().length,
+            `"<${node.getType()}>" is a void element, and as such, should not have a corresponding closing tag`
+        );
+
+        occurrenceList.push(error);
+    }
+
+    return this.return(node, occurrenceList, ruleConfig);
+};
+
+Rule.getFixedContent = node => {
+
+    if (node.isVoidElement()) {
+        node.setTail('', null, null, null);
+    }
+
+    return node.toString();
+};
+
+module.exports = Rule;

package/src/util/ConsoleUtils.js

@@ -126,6 +126,8 @@ const displayUnknownErrors = lintResult => {
     return partialSum;
 };
 
+const getPluralTermString = (singularTerm, qty) => `${qty} ${singularTerm}${qty > 1 ? 's' : ''}`;
+
 const displayOccurrenceList = lintResult => {
 
     displayUnparseableErrors(lintResult);
@@ -148,19 +150,19 @@ const displayOccurrenceList = lintResult => {
         console.log(Constants.EOL + chalk`{bold Linted ${lintResult.totalTemplatesQty} templates in ${lintResult.elapsedTime} seconds.}`);
 
         if (occurrenceList.error.qty > 0) {
-            console.log(chalk`{bold ${occurrenceList.error.qty} error(s) found.}`);
+            console.log(chalk`{bold ${getPluralTermString('error', occurrenceList.error.qty)} found.}`);
         }
 
         if (occurrenceList.warning.qty > 0) {
-            console.log(chalk`{bold ${occurrenceList.warning.qty} warning(s) found.}`);
+            console.log(chalk`{bold ${getPluralTermString('warning', occurrenceList.warning.qty)} found.}`);
         }
 
         if (occurrenceList.info.qty > 0) {
-            console.log(chalk`{bold ${occurrenceList.info.qty} info(s) found.}`);
+            console.log(chalk`{bold ${getPluralTermString('info', occurrenceList.info.qty)} found.}`);
         }
 
         if (lintResult.INVALID_TEMPLATE && lintResult.INVALID_TEMPLATE.length > 0) {
-            console.log(chalk`{bold ${lintResult.INVALID_TEMPLATE.length} template(s) have an invalid ISML tree.}`);
+            console.log(chalk`{bold ${getPluralTermString('template', lintResult.INVALID_TEMPLATE.length)} have an invalid ISML tree.}`);
         }
 
         if (lintResult.UNKNOWN_ERROR && lintResult.UNKNOWN_ERROR.length > 0) {

package/src/util/GeneralUtils.js

@@ -34,12 +34,52 @@ const getActiveLineBreak = () => {
     return configLineBreak || Constants.EOL;
 };
 
+const getFileLineBreakStyle = templateContent => {
+    const indexOfLF = templateContent.indexOf(Constants.lineBreak.unix, 1);
+
+    if (indexOfLF === -1) {
+        if (templateContent.indexOf('\r') !== -1) {
+            return '\r';
+        }
+
+        return Constants.lineBreak.unix;
+    }
+
+    if (templateContent[indexOfLF - 1] === '\r') {
+        return Constants.lineBreak.windows;
+    }
+
+    return Constants.lineBreak.unix;
+};
+
 module.exports.formatTemplatePath = filePath => {
     return filePath.replace(/\//g, path.sep);
 };
 
 module.exports.toLF = content => {
-    return content.replace(/\r\n/g, '\n');
+    return content.replace(/\r\n/g, Constants.lineBreak.unix);
+};
+
+module.exports.getFileLineBreakStyle = getFileLineBreakStyle;
+
+module.exports.applyLineBreak = (content, lineBreak) => {
+    const config                      = ConfigUtils.load();
+    const configLineBreak             = config.linebreakStyle && Constants.lineBreak[config.linebreakStyle];
+    const templateHasWindowsLineBreak = content.indexOf(Constants.lineBreak.windows) >= 0;
+
+    if (configLineBreak) {
+        lineBreak = configLineBreak;
+    }
+
+    if (lineBreak === Constants.lineBreak.windows && !templateHasWindowsLineBreak) {
+        return content
+            .replace(new RegExp(Constants.lineBreak.unix, 'g'), lineBreak);
+    } else if (lineBreak === Constants.lineBreak.unix && templateHasWindowsLineBreak) {
+        return content
+            .replace(new RegExp(Constants.lineBreak.windows, 'g'), lineBreak);
+    }
+
+    return content;
 };
 
 module.exports.applyActiveLineBreaks = content => {

package/src/util/RuleUtils.js

@@ -6,7 +6,6 @@ const ConfigUtils           = require('./ConfigUtils');
 const lowercaseFilenameRule = require('../rules/line_by_line/lowercase-filename');
 const CustomTagContainer    = require('./CustomTagContainer');
 const CustomModulesRule     = require('../rules/tree/custom-tags');
-const GeneralUtils          = require('./GeneralUtils');
 const ConsoleUtils          = require('./ConsoleUtils');
 const ExceptionUtils        = require('./ExceptionUtils');
 
@@ -64,7 +63,7 @@ const checkCustomTag = tag => {
     }
 };
 
-const applyRuleResult = (config, ruleResult, templatePath, templateResults, rule) => {
+const fixTemplateOrReportIssues = (config, ruleResult, templatePath, templateResults, rule) => {
     if (config.autoFix && ruleResult.fixedContent) {
         fs.writeFileSync(templatePath, ruleResult.fixedContent);
         templateResults.fixed = true;
@@ -78,7 +77,7 @@ const applyRuleResult = (config, ruleResult, templatePath, templateResults, rule
     }
 };
 
-const applyRuleOnTemplate = (ruleArray, templatePath, root, config, data) => {
+const fixTemplateOrReportIssuesForRuleList = (ruleArray, templatePath, root, config, data) => {
     const templateResults = {
         fixed    : false,
         errors   : {},
@@ -92,9 +91,9 @@ const applyRuleOnTemplate = (ruleArray, templatePath, root, config, data) => {
         if (!rule.shouldIgnore(templatePath)) {
             try {
                 ConsoleUtils.displayVerboseMessage(`Applying "${rule.id}" rule`, 1);
-                const ruleResults = rule.check(root, templateResults.data);
+                const ruleResults            = rule.check(root, templateResults.data);
                 templateResults.finalContent = ruleResults.fixedContent;
-                applyRuleResult(config, ruleResults, templatePath, templateResults, rule);
+                fixTemplateOrReportIssues(config, ruleResults, templatePath, templateResults, rule);
 
             } catch (error) {
                 throw ExceptionUtils.ruleApplianceError(rule, error, templatePath);
@@ -112,10 +111,10 @@ const findNodeOfType = (node, type) => {
         if (child.isOfType(type)) {
             result = child;
             return true;
-        } else {
-            result = findNodeOfType(child, type) || result;
         }
 
+        result = findNodeOfType(child, type) || result;
+
         return false;
     });
 
@@ -170,7 +169,7 @@ const checkFileName = (filename, templateContent) => {
     return templateResults;
 };
 
-const checkTreeRules = (templatePath, templateContent, config, data) => {
+const checkAndPossiblyFixTreeRules = (templatePath, templateContent, config, data) => {
     if (!config.disableTreeParse) {
         ConsoleUtils.displayVerboseMessage(`Building tree for "${templatePath}"`, 1);
         const tree = TreeBuilder.build(templatePath, templateContent);
@@ -181,7 +180,7 @@ const checkTreeRules = (templatePath, templateContent, config, data) => {
 
         const ruleArray = getEnabledTreeRules();
 
-        return applyRuleOnTemplate(
+        return fixTemplateOrReportIssuesForRuleList(
             ruleArray,
             templatePath,
             tree.rootNode,
@@ -190,10 +189,10 @@ const checkTreeRules = (templatePath, templateContent, config, data) => {
     }
 };
 
-const checkLineByLineRules = (templatePath, templateContent, config, data) => {
+const checkAndPossiblyFixLineByLineRules = (templatePath, templateContent, config, data) => {
     const ruleArray = getEnabledLineRules();
 
-    return applyRuleOnTemplate(
+    return fixTemplateOrReportIssuesForRuleList(
         ruleArray,
         templatePath,
         templateContent,
@@ -222,12 +221,12 @@ const checkCustomModules = () => {
     return moduleResults;
 };
 
-const checkTemplate = (templatePath, data, content = '', templateName = '') => {
+const parseAndPossiblyFixTemplate = (templatePath, data, content = '', templateName = '') => {
     ConsoleUtils.displayVerboseMessage(`\nChecking "${templatePath}" template`);
     const config          = ConfigUtils.load();
-    const templateContent = GeneralUtils.toLF(content || fs.readFileSync(templatePath, 'utf-8'));
-    const lineResults     = checkLineByLineRules(templatePath, templateContent, config, data);
-    const treeResults     = checkTreeRules(templatePath, lineResults.finalContent, config, data) || { errors : [] };
+    const templateContent = content || fs.readFileSync(templatePath, 'utf-8');
+    const lineResults     = checkAndPossiblyFixLineByLineRules(templatePath, templateContent, config, data);
+    const treeResults     = checkAndPossiblyFixTreeRules(templatePath, lineResults.finalContent, config, data) || { errors : [] };
     const filenameResults = checkFileName(templateName, templateContent);
 
     return {
@@ -290,7 +289,7 @@ const getEnabledTreeRules = () => {
 module.exports.getAllLineRules             = () => lineByLineRules;
 module.exports.findNodeOfType              = findNodeOfType;
 module.exports.isTypeAmongTheFirstElements = isTypeAmongTheFirstElements;
-module.exports.checkTemplate               = checkTemplate;
+module.exports.parseAndPossiblyFixTemplate = parseAndPossiblyFixTemplate;
 module.exports.checkCustomModules          = checkCustomModules;
 module.exports.getAvailableRulesQty        = getAvailableRulesQty;
 module.exports.getLevelGroup               = getLevelGroup;

package/src/util/TempRuleUtils.js

@@ -6,7 +6,6 @@
     ===========================================================================
 **/
 
-const path                  = require('path');
 const fs                    = require('fs');
 const Constants             = require('../Constants');
 const TreeBuilder           = require('../isml_tree/TreeBuilder');
@@ -38,7 +37,7 @@ const checkCustomTag = tag => {
     }
 };
 
-const applyRuleResult = (config, ruleResult, templatePath, templateResults, rule) => {
+const fixTemplateOrReportIssues = (config, ruleResult, templatePath, templateResults, rule) => {
     if (config.autoFix && ruleResult.fixedContent) {
         fs.writeFileSync(templatePath, ruleResult.fixedContent);
         templateResults.fixed = true;
@@ -49,7 +48,7 @@ const applyRuleResult = (config, ruleResult, templatePath, templateResults, rule
     }
 };
 
-const applyRuleOnTemplate = (ruleArray, templatePath, root, config) => {
+const fixTemplateOrReportIssuesForRuleList = (ruleArray, templatePath, root, config) => {
     const templateResults = {
         fixed  : false,
         errors : {}
@@ -59,7 +58,7 @@ const applyRuleOnTemplate = (ruleArray, templatePath, root, config) => {
         const rule = ruleArray[i];
         if (!rule.shouldIgnore(templatePath)) {
             const ruleResults = rule.check(root, templateResults.data);
-            applyRuleResult(config, ruleResults, templatePath, templateResults, rule);
+            fixTemplateOrReportIssues(config, ruleResults, templatePath, templateResults, rule);
         }
     }
 
@@ -130,7 +129,7 @@ const checkFileName = (filename, templateContent) => {
     return templateResults;
 };
 
-const checkTreeRules = (templatePath, templateContent, config) => {
+const checkAndPossiblyFixTreeRules = (templatePath, templateContent, config) => {
     if (!config.disableTreeParse) {
         const tree = TreeBuilder.build(templatePath, templateContent);
 
@@ -140,7 +139,7 @@ const checkTreeRules = (templatePath, templateContent, config) => {
 
         const ruleArray = getEnabledTreeRules();
 
-        return applyRuleOnTemplate(
+        return fixTemplateOrReportIssuesForRuleList(
             ruleArray,
             templatePath,
             tree.rootNode,
@@ -148,10 +147,10 @@ const checkTreeRules = (templatePath, templateContent, config) => {
     }
 };
 
-const checkLineByLineRules = (templatePath, templateContent, config) => {
+const checkAndPossiblyFixLineByLineRules = (templatePath, templateContent, config) => {
     const ruleArray = getEnabledLineRules();
 
-    return applyRuleOnTemplate(
+    return fixTemplateOrReportIssuesForRuleList(
         ruleArray,
         templatePath,
         templateContent,
@@ -176,11 +175,11 @@ const checkCustomModules = () => {
     return moduleResults;
 };
 
-const checkTemplate = (templatePath, content, templateName) => {
+const parseAndPossiblyFixTemplate = (templatePath, content, templateName) => {
     const config          = ConfigUtils.load();
     const templateContent = content || fs.readFileSync(templatePath, 'utf-8');
-    const lineResults     = checkLineByLineRules(templatePath, templateContent, config);
-    const treeResults     = checkTreeRules(templatePath, templateContent, config) || { errors : [] };
+    const lineResults     = checkAndPossiblyFixLineByLineRules(templatePath, templateContent, config);
+    const treeResults     = checkAndPossiblyFixTreeRules(templatePath, templateContent, config) || { errors : [] };
     const filenameResults = checkFileName(templateName, templateContent);
 
     return {
@@ -227,6 +226,6 @@ const getEnabledTreeRules = () => {
 module.exports.getAllLineRules             = () => lineByLineRules;
 module.exports.findNodeOfType              = findNodeOfType;
 module.exports.isTypeAmongTheFirstElements = isTypeAmongTheFirstElements;
-module.exports.checkTemplate               = checkTemplate;
+module.exports.parseAndPossiblyFixTemplate = parseAndPossiblyFixTemplate;
 module.exports.checkCustomModules          = checkCustomModules;
 module.exports.getAvailableRulesQty        = getAvailableRulesQty;