feat(*): add line endings rule, add automatic formatting for fixable violations

src/rules/file/hasDoxygenHeader.spec.ts

@@ -1,3 +1,4 @@
+import { LintConfig } from '../../types'
 import { Severity } from '../../types/Severity'
 import { hasDoxygenHeader } from './hasDoxygenHeader'
 
@@ -68,4 +69,43 @@ describe('hasDoxygenHeader', () => {
       }
     ])
   })
+
+  it('should not alter the text if a doxygen header is already present', () => {
+    const content = `/**
+   @file
+   @brief Returns an unused libref
+ **/
+
+ %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+   %local x libref;
+   %let x={SAS002};
+   %do x=0 %to &maxtries;`
+
+    expect(hasDoxygenHeader.fix!(content)).toEqual(content)
+  })
+
+  it('should should add a doxygen header if not present', () => {
+    const content = `%macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+%local x libref;
+%let x={SAS002};
+%do x=0 %to &maxtries;`
+
+    expect(hasDoxygenHeader.fix!(content)).toEqual(
+      `/**
+  @file
+  @brief <Your brief here>
+**/` +
+        '\n' +
+        content
+    )
+  })
+
+  it('should use CRLF line endings when configured', () => {
+    const content = `%macro mf_getuniquelibref(prefix=mclib,maxtries=1000);\n%local x libref;\n%let x={SAS002};\n%do x=0 %to &maxtries;`
+    const config = new LintConfig({ lineEndings: 'crlf' })
+
+    expect(hasDoxygenHeader.fix!(content, config)).toEqual(
+      `/**\r\n  @file\r\n  @brief <Your brief here>\r\n**/` + '\r\n' + content
+    )
+  })
 })

src/rules/file/hasDoxygenHeader.ts

@@ -1,7 +1,11 @@
+import { LintConfig } from '../../types'
+import { LineEndings } from '../../types/LineEndings'
 import { FileLintRule } from '../../types/LintRule'
 import { LintRuleType } from '../../types/LintRuleType'
 import { Severity } from '../../types/Severity'
 
+const DoxygenHeader = `/**{lineEnding}  @file{lineEnding}  @brief <Your brief here>{lineEnding}**/`
+
 const name = 'hasDoxygenHeader'
 const description =
   'Enforce the presence of a Doxygen header at the start of each file.'
@@ -32,6 +36,19 @@ const test = (value: string) => {
   }
 }
 
+const fix = (value: string, config?: LintConfig): string => {
+  if (test(value).length === 0) {
+    return value
+  }
+  const lineEndingConfig = config?.lineEndings || LineEndings.LF
+  const lineEnding = lineEndingConfig === LineEndings.LF ? '\n' : '\r\n'
+
+  return `${DoxygenHeader.replace(
+    /{lineEnding}/g,
+    lineEnding
+  )}${lineEnding}${value}`
+}
+
 /**
  * Lint rule that checks for the presence of a Doxygen header in a given file.
  */
@@ -40,5 +57,6 @@ export const hasDoxygenHeader: FileLintRule = {
   name,
   description,
   message,
-  test
+  test,
+  fix
 }

src/rules/file/hasMacroNameInMend.ts

@@ -2,99 +2,97 @@ import { Diagnostic } from '../../types/Diagnostic'
 import { FileLintRule } from '../../types/LintRule'
 import { LintRuleType } from '../../types/LintRuleType'
 import { Severity } from '../../types/Severity'
-import { trimComments } from '../../utils/trimComments'
 import { getColumnNumber } from '../../utils/getColumnNumber'
+import { LintConfig } from '../../types'
+import { LineEndings } from '../../types/LineEndings'
+import { parseMacros } from '../../utils/parseMacros'
 
 const name = 'hasMacroNameInMend'
 const description =
   'Enforces the presence of the macro name in each %mend statement.'
 const message = '%mend statement has missing or incorrect macro name'
-const test = (value: string) => {
+const test = (value: string, config?: LintConfig) => {
+  const lineEnding = config?.lineEndings === LineEndings.CRLF ? '\r\n' : '\n'
+  const lines: string[] = value ? value.split(lineEnding) : []
+  const macros = parseMacros(value, config)
   const diagnostics: Diagnostic[] = []
-
-  const lines: string[] = value ? value.split('\n') : []
-
-  const declaredMacros: { name: string; lineNumber: number }[] = []
-  let isCommentStarted = false
-  lines.forEach((line, lineIndex) => {
-    const { statement: trimmedLine, commentStarted } = trimComments(
-      line,
-      isCommentStarted
-    )
-    isCommentStarted = commentStarted
-    const statements: string[] = trimmedLine ? trimmedLine.split(';') : []
-
-    statements.forEach((statement) => {
-      const { statement: trimmedStatement, commentStarted } = trimComments(
-        statement,
-        isCommentStarted
-      )
-      isCommentStarted = commentStarted
-
-      if (trimmedStatement.startsWith('%macro ')) {
-        const macroName = trimmedStatement
-          .slice(7, trimmedStatement.length)
-          .trim()
-          .split('(')[0]
-        if (macroName)
-          declaredMacros.push({
-            name: macroName,
-            lineNumber: lineIndex + 1
-          })
-      } else if (trimmedStatement.startsWith('%mend')) {
-        const declaredMacro = declaredMacros.pop()
-        const macroName = trimmedStatement
-          .split(' ')
-          .filter((s: string) => !!s)[1]
-
-        if (!declaredMacro) {
-          diagnostics.push({
-            message: `%mend statement is redundant`,
-            lineNumber: lineIndex + 1,
-            startColumnNumber: getColumnNumber(line, '%mend'),
-            endColumnNumber:
-              getColumnNumber(line, '%mend') + trimmedStatement.length,
-            severity: Severity.Warning
-          })
-        } else if (!macroName) {
-          diagnostics.push({
-            message: `%mend statement is missing macro name - ${
-              declaredMacro!.name
-            }`,
-            lineNumber: lineIndex + 1,
-            startColumnNumber: getColumnNumber(line, '%mend'),
-            endColumnNumber: getColumnNumber(line, '%mend') + 6,
-            severity: Severity.Warning
-          })
-        } else if (macroName !== declaredMacro!.name) {
-          diagnostics.push({
-            message: `%mend statement has mismatched macro name, it should be '${
-              declaredMacro!.name
-            }'`,
-            lineNumber: lineIndex + 1,
-            startColumnNumber: getColumnNumber(line, macroName),
-            endColumnNumber:
-              getColumnNumber(line, macroName) + macroName.length - 1,
-            severity: Severity.Warning
-          })
-        }
-      }
-    })
-  })
-
-  declaredMacros.forEach((declaredMacro) => {
-    diagnostics.push({
-      message: `Missing %mend statement for macro - ${declaredMacro.name}`,
-      lineNumber: declaredMacro.lineNumber,
-      startColumnNumber: 1,
-      endColumnNumber: 1,
-      severity: Severity.Warning
-    })
+  macros.forEach((macro) => {
+    if (macro.startLineNumber === null && macro.endLineNumber !== null) {
+      diagnostics.push({
+        message: `%mend statement is redundant`,
+        lineNumber: macro.endLineNumber,
+        startColumnNumber: getColumnNumber(
+          lines[macro.endLineNumber - 1],
+          '%mend'
+        ),
+        endColumnNumber:
+          getColumnNumber(lines[macro.endLineNumber - 1], '%mend') +
+          lines[macro.endLineNumber - 1].trim().length -
+          1,
+        severity: Severity.Warning
+      })
+    } else if (macro.endLineNumber === null && macro.startLineNumber !== null) {
+      diagnostics.push({
+        message: `Missing %mend statement for macro - ${macro.name}`,
+        lineNumber: macro.startLineNumber,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      })
+    } else if (macro.mismatchedMendMacroName) {
+      diagnostics.push({
+        message: `%mend statement has mismatched macro name, it should be '${
+          macro!.name
+        }'`,
+        lineNumber: macro.endLineNumber as number,
+        startColumnNumber: getColumnNumber(
+          lines[(macro.endLineNumber as number) - 1],
+          macro.mismatchedMendMacroName
+        ),
+        endColumnNumber:
+          getColumnNumber(
+            lines[(macro.endLineNumber as number) - 1],
+            macro.mismatchedMendMacroName
+          ) +
+          macro.mismatchedMendMacroName.length -
+          1,
+        severity: Severity.Warning
+      })
+    } else if (!macro.hasMacroNameInMend) {
+      diagnostics.push({
+        message: `%mend statement is missing macro name - ${macro.name}`,
+        lineNumber: macro.endLineNumber as number,
+        startColumnNumber: getColumnNumber(
+          lines[(macro.endLineNumber as number) - 1],
+          '%mend'
+        ),
+        endColumnNumber:
+          getColumnNumber(lines[(macro.endLineNumber as number) - 1], '%mend') +
+          6,
+        severity: Severity.Warning
+      })
+    }
   })
 
   return diagnostics
 }
 
+const fix = (value: string, config?: LintConfig): string => {
+  const lineEnding = config?.lineEndings === LineEndings.CRLF ? '\r\n' : '\n'
+  let formattedText = value
+  const macros = parseMacros(value, config)
+  macros
+    .filter((macro) => !macro.hasMacroNameInMend)
+    .forEach((macro) => {
+      formattedText = formattedText.replace(
+        macro.termination,
+        `%mend ${macro.name};${lineEnding}`
+      )
+    })
+
+  return formattedText
+}
+
 /**
  * Lint rule that checks for the presence of macro name in %mend statement.
  */
@@ -103,5 +101,6 @@ export const hasMacroNameInMend: FileLintRule = {
   name,
   description,
   message,
-  test
+  test,
+  fix
 }

src/rules/file/hasMacroParentheses.spec.ts

@@ -16,7 +16,6 @@ describe('hasMacroParentheses', () => {
   %macro somemacro;
     %put &sysmacroname;
   %mend somemacro;`
-
     expect(hasMacroParentheses.test(content)).toEqual([
       {
         message: 'Macro definition missing parentheses',
@@ -28,7 +27,7 @@ describe('hasMacroParentheses', () => {
     ])
   })
 
-  it('should return an array with a single diagnostics when macro defined without name', () => {
+  it('should return an array with a single diagnostic when macro defined without name', () => {
     const content = `
   %macro ();
     %put &sysmacroname;
@@ -45,7 +44,7 @@ describe('hasMacroParentheses', () => {
     ])
   })
 
-  it('should return an array with a single diagnostics when macro defined without name and parentheses', () => {
+  it('should return an array with a single diagnostic when macro defined without name and parentheses', () => {
     const content = `
   %macro ;
     %put &sysmacroname;
@@ -56,7 +55,7 @@ describe('hasMacroParentheses', () => {
         message: 'Macro definition missing name',
         lineNumber: 2,
         startColumnNumber: 3,
-        endColumnNumber: 9,
+        endColumnNumber: 10,
         severity: Severity.Warning
       }
     ])

src/rules/file/hasMacroParentheses.ts

@@ -2,74 +2,51 @@ import { Diagnostic } from '../../types/Diagnostic'
 import { FileLintRule } from '../../types/LintRule'
 import { LintRuleType } from '../../types/LintRuleType'
 import { Severity } from '../../types/Severity'
-import { trimComments } from '../../utils/trimComments'
 import { getColumnNumber } from '../../utils/getColumnNumber'
+import { parseMacros } from '../../utils/parseMacros'
+import { LintConfig } from '../../types'
 
 const name = 'hasMacroParentheses'
 const description = 'Enforces the presence of parentheses in macro definitions.'
 const message = 'Macro definition missing parentheses'
-const test = (value: string) => {
+const test = (value: string, config?: LintConfig) => {
   const diagnostics: Diagnostic[] = []
-
-  const lines: string[] = value ? value.split('\n') : []
-  let isCommentStarted = false
-  lines.forEach((line, lineIndex) => {
-    const { statement: trimmedLine, commentStarted } = trimComments(
-      line,
-      isCommentStarted
-    )
-    isCommentStarted = commentStarted
-    const statements: string[] = trimmedLine ? trimmedLine.split(';') : []
-
-    statements.forEach((statement) => {
-      const { statement: trimmedStatement, commentStarted } = trimComments(
-        statement,
-        isCommentStarted
-      )
-      isCommentStarted = commentStarted
-
-      if (trimmedStatement.startsWith('%macro')) {
-        const macroNameDefinition = trimmedStatement
-          .slice(7, trimmedStatement.length)
-          .trim()
-
-        const macroNameDefinitionParts = macroNameDefinition.split('(')
-        const macroName = macroNameDefinitionParts[0]
-
-        if (!macroName)
-          diagnostics.push({
-            message: 'Macro definition missing name',
-            lineNumber: lineIndex + 1,
-            startColumnNumber: getColumnNumber(line, '%macro'),
-            endColumnNumber:
-              getColumnNumber(line, '%macro') + trimmedStatement.length,
-            severity: Severity.Warning
-          })
-        else if (macroNameDefinitionParts.length === 1)
-          diagnostics.push({
-            message,
-            lineNumber: lineIndex + 1,
-            startColumnNumber: getColumnNumber(line, macroNameDefinition),
-            endColumnNumber:
-              getColumnNumber(line, macroNameDefinition) +
-              macroNameDefinition.length -
-              1,
-            severity: Severity.Warning
-          })
-        else if (macroName !== macroName.trim())
-          diagnostics.push({
-            message: 'Macro definition contains space(s)',
-            lineNumber: lineIndex + 1,
-            startColumnNumber: getColumnNumber(line, macroNameDefinition),
-            endColumnNumber:
-              getColumnNumber(line, macroNameDefinition) +
-              macroNameDefinition.length -
-              1,
-            severity: Severity.Warning
-          })
-      }
-    })
+  const macros = parseMacros(value, config)
+  macros.forEach((macro) => {
+    if (!macro.name) {
+      diagnostics.push({
+        message: 'Macro definition missing name',
+        lineNumber: macro.startLineNumber!,
+        startColumnNumber: getColumnNumber(macro.declaration, '%macro'),
+        endColumnNumber: macro.declaration.length,
+        severity: Severity.Warning
+      })
+    } else if (!macro.declaration.includes('(')) {
+      diagnostics.push({
+        message,
+        lineNumber: macro.startLineNumber!,
+        startColumnNumber: getColumnNumber(macro.declaration, macro.name),
+        endColumnNumber:
+          getColumnNumber(macro.declaration, macro.name) +
+          macro.name.length -
+          1,
+        severity: Severity.Warning
+      })
+    } else if (macro.name !== macro.name.trim()) {
+      diagnostics.push({
+        message: 'Macro definition contains space(s)',
+        lineNumber: macro.startLineNumber!,
+        startColumnNumber: getColumnNumber(macro.declaration, macro.name),
+        endColumnNumber:
+          getColumnNumber(macro.declaration, macro.name) +
+          macro.name.length -
+          1 +
+          `()`.length,
+        severity: Severity.Warning
+      })
+    }
   })
+
   return diagnostics
 }
 

src/rules/file/index.ts

@@ -1,4 +1,5 @@
 export { hasDoxygenHeader } from './hasDoxygenHeader'
 export { hasMacroNameInMend } from './hasMacroNameInMend'
 export { hasMacroParentheses } from './hasMacroParentheses'
+export { lineEndings } from './lineEndings'
 export { noNestedMacros } from './noNestedMacros'

src/rules/file/lineEndings.spec.ts

@@ -0,0 +1,139 @@
+import { LintConfig, Severity } from '../../types'
+import { LineEndings } from '../../types/LineEndings'
+import { lineEndings } from './lineEndings'
+
+describe('lineEndings', () => {
+  it('should return an empty array when the text contains the configured line endings', () => {
+    const text = "%put 'hello';\n%put 'world';\n"
+    const config = new LintConfig({ lineEndings: LineEndings.LF })
+    expect(lineEndings.test(text, config)).toEqual([])
+  })
+
+  it('should return an array with a single diagnostic when a line is terminated with a CRLF ending', () => {
+    const text = "%put 'hello';\n%put 'world';\r\n"
+    const config = new LintConfig({ lineEndings: LineEndings.LF })
+    expect(lineEndings.test(text, config)).toEqual([
+      {
+        message: 'Incorrect line ending - CRLF instead of LF',
+        lineNumber: 2,
+        startColumnNumber: 13,
+        endColumnNumber: 14,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostic when a line is terminated with an LF ending', () => {
+    const text = "%put 'hello';\n%put 'world';\r\n"
+    const config = new LintConfig({ lineEndings: LineEndings.CRLF })
+    expect(lineEndings.test(text, config)).toEqual([
+      {
+        message: 'Incorrect line ending - LF instead of CRLF',
+        lineNumber: 1,
+        startColumnNumber: 13,
+        endColumnNumber: 14,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a diagnostic for each line terminated with an LF ending', () => {
+    const text = "%put 'hello';\n%put 'test';\r\n%put 'world';\n"
+    const config = new LintConfig({ lineEndings: LineEndings.CRLF })
+    expect(lineEndings.test(text, config)).toContainEqual({
+      message: 'Incorrect line ending - LF instead of CRLF',
+      lineNumber: 1,
+      startColumnNumber: 13,
+      endColumnNumber: 14,
+      severity: Severity.Warning
+    })
+    expect(lineEndings.test(text, config)).toContainEqual({
+      message: 'Incorrect line ending - LF instead of CRLF',
+      lineNumber: 3,
+      startColumnNumber: 13,
+      endColumnNumber: 14,
+      severity: Severity.Warning
+    })
+  })
+
+  it('should return an array with a diagnostic for each line terminated with a CRLF ending', () => {
+    const text = "%put 'hello';\r\n%put 'test';\n%put 'world';\r\n"
+    const config = new LintConfig({ lineEndings: LineEndings.LF })
+    expect(lineEndings.test(text, config)).toContainEqual({
+      message: 'Incorrect line ending - CRLF instead of LF',
+      lineNumber: 1,
+      startColumnNumber: 13,
+      endColumnNumber: 14,
+      severity: Severity.Warning
+    })
+    expect(lineEndings.test(text, config)).toContainEqual({
+      message: 'Incorrect line ending - CRLF instead of LF',
+      lineNumber: 3,
+      startColumnNumber: 13,
+      endColumnNumber: 14,
+      severity: Severity.Warning
+    })
+  })
+
+  it('should return an array with a diagnostic for lines terminated with a CRLF ending', () => {
+    const text =
+      "%put 'hello';\r\n%put 'test';\r\n%put 'world';\n%put 'test2';\n%put 'world2';\r\n"
+    const config = new LintConfig({ lineEndings: LineEndings.LF })
+    expect(lineEndings.test(text, config)).toContainEqual({
+      message: 'Incorrect line ending - CRLF instead of LF',
+      lineNumber: 1,
+      startColumnNumber: 13,
+      endColumnNumber: 14,
+      severity: Severity.Warning
+    })
+    expect(lineEndings.test(text, config)).toContainEqual({
+      message: 'Incorrect line ending - CRLF instead of LF',
+      lineNumber: 2,
+      startColumnNumber: 12,
+      endColumnNumber: 13,
+      severity: Severity.Warning
+    })
+    expect(lineEndings.test(text, config)).toContainEqual({
+      message: 'Incorrect line ending - CRLF instead of LF',
+      lineNumber: 5,
+      startColumnNumber: 14,
+      endColumnNumber: 15,
+      severity: Severity.Warning
+    })
+  })
+
+  it('should transform line endings to LF', () => {
+    const text =
+      "%put 'hello';\r\n%put 'test';\r\n%put 'world';\n%put 'test2';\n%put 'world2';\r\n"
+    const config = new LintConfig({ lineEndings: LineEndings.LF })
+
+    const formattedText = lineEndings.fix!(text, config)
+
+    expect(formattedText).toEqual(
+      "%put 'hello';\n%put 'test';\n%put 'world';\n%put 'test2';\n%put 'world2';\n"
+    )
+  })
+
+  it('should transform line endings to CRLF', () => {
+    const text =
+      "%put 'hello';\r\n%put 'test';\r\n%put 'world';\n%put 'test2';\n%put 'world2';\r\n"
+    const config = new LintConfig({ lineEndings: LineEndings.CRLF })
+
+    const formattedText = lineEndings.fix!(text, config)
+
+    expect(formattedText).toEqual(
+      "%put 'hello';\r\n%put 'test';\r\n%put 'world';\r\n%put 'test2';\r\n%put 'world2';\r\n"
+    )
+  })
+
+  it('should use LF line endings by default', () => {
+    const text =
+      "%put 'hello';\r\n%put 'test';\r\n%put 'world';\n%put 'test2';\n%put 'world2';\r\n"
+
+    const formattedText = lineEndings.fix!(text)
+
+    expect(formattedText).toEqual(
+      "%put 'hello';\n%put 'test';\n%put 'world';\n%put 'test2';\n%put 'world2';\n"
+    )
+  })
+})

src/rules/file/lineEndings.ts

@@ -0,0 +1,83 @@
+import { Diagnostic, LintConfig } from '../../types'
+import { LineEndings } from '../../types/LineEndings'
+import { FileLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
+
+const name = 'lineEndings'
+const description = 'Ensures line endings conform to the configured type.'
+const message = 'Incorrect line ending - {actual} instead of {expected}'
+const test = (value: string, config?: LintConfig) => {
+  const lineEndingConfig = config?.lineEndings || LineEndings.LF
+  const expectedLineEnding =
+    lineEndingConfig === LineEndings.LF ? '{lf}' : '{crlf}'
+  const incorrectLineEnding = expectedLineEnding === '{lf}' ? '{crlf}' : '{lf}'
+
+  const lines = value
+    .replace(/\r\n/g, '{crlf}')
+    .replace(/\n/g, '{lf}')
+    .split(new RegExp(`(?<=${expectedLineEnding})`))
+  const diagnostics: Diagnostic[] = []
+
+  let indexOffset = 0
+  lines.forEach((line, index) => {
+    if (line.endsWith(incorrectLineEnding)) {
+      diagnostics.push({
+        message: message
+          .replace('{expected}', expectedLineEnding === '{lf}' ? 'LF' : 'CRLF')
+          .replace('{actual}', incorrectLineEnding === '{lf}' ? 'LF' : 'CRLF'),
+        lineNumber: index + 1 + indexOffset,
+        startColumnNumber: line.indexOf(incorrectLineEnding),
+        endColumnNumber: line.indexOf(incorrectLineEnding) + 1,
+        severity: Severity.Warning
+      })
+    } else {
+      const splitLine = line.split(new RegExp(`(?<=${incorrectLineEnding})`))
+      if (splitLine.length > 1) {
+        indexOffset += splitLine.length - 1
+      }
+      splitLine.forEach((l, i) => {
+        if (l.endsWith(incorrectLineEnding)) {
+          diagnostics.push({
+            message: message
+              .replace(
+                '{expected}',
+                expectedLineEnding === '{lf}' ? 'LF' : 'CRLF'
+              )
+              .replace(
+                '{actual}',
+                incorrectLineEnding === '{lf}' ? 'LF' : 'CRLF'
+              ),
+            lineNumber: index + i + 1,
+            startColumnNumber: l.indexOf(incorrectLineEnding),
+            endColumnNumber: l.indexOf(incorrectLineEnding) + 1,
+            severity: Severity.Warning
+          })
+        }
+      })
+    }
+  })
+  return diagnostics
+}
+
+const fix = (value: string, config?: LintConfig): string => {
+  const lineEndingConfig = config?.lineEndings || LineEndings.LF
+
+  return value
+    .replace(/\r\n/g, '{crlf}')
+    .replace(/\n/g, '{lf}')
+    .replace(/{crlf}/g, lineEndingConfig === LineEndings.LF ? '\n' : '\r\n')
+    .replace(/{lf}/g, lineEndingConfig === LineEndings.LF ? '\n' : '\r\n')
+}
+
+/**
+ * Lint rule that checks if line endings in a file match the configured type.
+ */
+export const lineEndings: FileLintRule = {
+  type: LintRuleType.File,
+  name,
+  description,
+  message,
+  test,
+  fix
+}

src/rules/file/noNestedMacros.spec.ts

@@ -29,13 +29,13 @@ describe('noNestedMacros', () => {
         message: "Macro definition for 'inner' present in macro 'outer'",
         lineNumber: 4,
         startColumnNumber: 7,
-        endColumnNumber: 20,
+        endColumnNumber: 21,
         severity: Severity.Warning
       }
     ])
   })
 
-  it('should return an array with a single diagnostic when nested macros are defined at 2 levels', () => {
+  it('should return an array with two diagnostics when nested macros are defined at 2 levels', () => {
     const content = `
     %macro outer();
       /* any amount of arbitrary code */
@@ -52,22 +52,20 @@ describe('noNestedMacros', () => {
 
     %outer()`
 
-    expect(noNestedMacros.test(content)).toEqual([
-      {
-        message: "Macro definition for 'inner' present in macro 'outer'",
-        lineNumber: 4,
-        startColumnNumber: 7,
-        endColumnNumber: 20,
-        severity: Severity.Warning
-      },
-      {
-        message: "Macro definition for 'inner2' present in macro 'inner'",
-        lineNumber: 7,
-        startColumnNumber: 17,
-        endColumnNumber: 31,
-        severity: Severity.Warning
-      }
-    ])
+    expect(noNestedMacros.test(content)).toContainEqual({
+      message: "Macro definition for 'inner' present in macro 'outer'",
+      lineNumber: 4,
+      startColumnNumber: 7,
+      endColumnNumber: 21,
+      severity: Severity.Warning
+    })
+    expect(noNestedMacros.test(content)).toContainEqual({
+      message: "Macro definition for 'inner2' present in macro 'inner'",
+      lineNumber: 7,
+      startColumnNumber: 17,
+      endColumnNumber: 32,
+      severity: Severity.Warning
+    })
   })
 
   it('should return an empty array when the file is undefined', () => {

src/rules/file/noNestedMacros.ts

@@ -2,57 +2,41 @@ import { Diagnostic } from '../../types/Diagnostic'
 import { FileLintRule } from '../../types/LintRule'
 import { LintRuleType } from '../../types/LintRuleType'
 import { Severity } from '../../types/Severity'
-import { trimComments } from '../../utils/trimComments'
 import { getColumnNumber } from '../../utils/getColumnNumber'
+import { parseMacros } from '../../utils/parseMacros'
+import { LintConfig } from '../../types'
+import { LineEndings } from '../../types/LineEndings'
 
 const name = 'noNestedMacros'
 const description = 'Enfoces the absence of nested macro definitions.'
 const message = `Macro definition for '{macro}' present in macro '{parent}'`
-const test = (value: string) => {
+const test = (value: string, config?: LintConfig) => {
+  const lineEnding = config?.lineEndings === LineEndings.CRLF ? '\r\n' : '\n'
+  const lines: string[] = value ? value.split(lineEnding) : []
   const diagnostics: Diagnostic[] = []
-  const declaredMacros: string[] = []
-
-  const lines: string[] = value ? value.split('\n') : []
-  let isCommentStarted = false
-  lines.forEach((line, lineIndex) => {
-    const { statement: trimmedLine, commentStarted } = trimComments(
-      line,
-      isCommentStarted
-    )
-    isCommentStarted = commentStarted
-    const statements: string[] = trimmedLine ? trimmedLine.split(';') : []
-
-    statements.forEach((statement) => {
-      const { statement: trimmedStatement, commentStarted } = trimComments(
-        statement,
-        isCommentStarted
-      )
-      isCommentStarted = commentStarted
-
-      if (trimmedStatement.startsWith('%macro ')) {
-        const macroName = trimmedStatement
-          .slice(7, trimmedStatement.length)
-          .trim()
-          .split('(')[0]
-        if (declaredMacros.length) {
-          const parentMacro = declaredMacros.slice(-1).pop()
-          diagnostics.push({
-            message: message
-              .replace('{macro}', macroName)
-              .replace('{parent}', parentMacro!),
-            lineNumber: lineIndex + 1,
-            startColumnNumber: getColumnNumber(line, '%macro'),
-            endColumnNumber:
-              getColumnNumber(line, '%macro') + trimmedStatement.length - 1,
-            severity: Severity.Warning
-          })
-        }
-        declaredMacros.push(macroName)
-      } else if (trimmedStatement.startsWith('%mend')) {
-        declaredMacros.pop()
-      }
+  const macros = parseMacros(value, config)
+  macros
+    .filter((m) => !!m.parentMacro)
+    .forEach((macro) => {
+      diagnostics.push({
+        message: message
+          .replace('{macro}', macro.name)
+          .replace('{parent}', macro.parentMacro),
+        lineNumber: macro.startLineNumber as number,
+        startColumnNumber: getColumnNumber(
+          lines[(macro.startLineNumber as number) - 1],
+          '%macro'
+        ),
+        endColumnNumber:
+          getColumnNumber(
+            lines[(macro.startLineNumber as number) - 1],
+            '%macro'
+          ) +
+          lines[(macro.startLineNumber as number) - 1].trim().length -
+          1,
+        severity: Severity.Warning
+      })
     })
-  })
   return diagnostics
 }
 

src/rules/line/noTrailingSpaces.ts

@@ -17,6 +17,7 @@ const test = (value: string, lineNumber: number) =>
           severity: Severity.Warning
         }
       ]
+const fix = (value: string) => value.trimEnd()
 
 /**
  * Lint rule that checks for the presence of trailing space(s) in a given line of text.
@@ -26,5 +27,6 @@ export const noTrailingSpaces: LineLintRule = {
   name,
   description,
   message,
-  test
+  test,
+  fix
 }