Merge pull request #27 from sasjs/issue-26

fix(hasMacroNameInMend): default sets to true

.sasjslint

@@ -2,5 +2,12 @@
     "noTrailingSpaces": true,
     "noEncodedPasswords": true,
     "hasDoxygenHeader": true,
-    "noSpacesInFileNames": true
+    "noSpacesInFileNames": true,
+    "maxLineLength": 80,
+    "lowerCaseFileNames": true,
+    "noTabIndentation": true,
+    "indentationMultiple": 2,
+    "hasMacroNameInMend": true,
+    "noNestedMacros": true,
+    "hasMacroParentheses": true
 }

PULL_REQUEST_TEMPLATE.md

@@ -16,5 +16,6 @@ What code changes have been made to achieve the intent.
 - [ ] Any new functionality has been unit tested.
 - [ ] All unit tests are passing (`npm test`).
 - [ ] All CI checks are green.
+- [ ] sasjslint-schema.json is updated with any new / changed functionality
 - [ ] JSDoc comments have been added or updated.
 - [ ] Reviewer is assigned.

README.md

@@ -1,2 +1,140 @@
-# lint
+# SAS Code linting and formatting
-Linting and formatting for SAS® code
+
+Our goal is to help SAS developers everywhere spend less time on code reviews, bug fixing and arguing about standards - and more time delivering extraordinary business value.
+
+## Linting
+@sasjs/lint is used by the following products:
+
+  * [@sasjs/vscode-extension](https://github.com/sasjs/vscode-extension) - just download SASjs in the VSCode marketplace, and select view/problems in the menu bar.
+  * [@sasjs/cli](https://cli.sasjs.io/lint) - run `sasjs lint` to get a list of all files with their problems, along with line and column indexes.
+
+Configuration is via a `.sasjslint` file with the following structure (these are also the defaults if no .sasjslint file is found):
+
+```json
+{
+    "noEncodedPasswords": true,
+    "hasDoxygenHeader": true,
+    "hasMacroNameInMend": false,
+    "hasMacroParentheses": true,
+    "indentationMultiple": 2,
+    "lowerCaseFileNames": true,
+    "maxLineLength": 80,
+    "noNestedMacros": true,
+    "noSpacesInFileNames": true,
+    "noTabIndentation": true,
+    "noTrailingSpaces": true
+}
+```
+
+### SAS Lint Settings
+
+#### noEncodedPasswords
+
+This will highlight any rows that contain a `{sas00X}` type password, or `{sasenc}`.  These passwords (especially 001 and 002) are NOT secure, and should NEVER be pushed to source control or saved to the filesystem without special permissions applied.
+
+* Default:  true
+* Severity: ERROR
+
+#### hasDoxygenHeader
+The SASjs framework recommends the use of Doxygen headers for describing all types of SAS program.  This check will identify files where a doxygen header does not begin in the first line.
+
+* Default:  true
+* Severity: WARNING
+
+#### hasMacroNameInMend
+The addition of the macro name in the `%mend` statement is optional, but can approve readability in large programs.  A discussion on this topic can be found [here](https://www.linkedin.com/posts/allanbowe_sas-sasapps-sasjs-activity-6783413360781266945-1-7m).  The default setting will be the result of a popular vote by around 300 people.
+
+* Default:  false (for now)
+* Severity: WARNING
+
+#### hasMacroParentheses
+As per the example [here](https://github.com/sasjs/lint/issues/20), macros defined without parentheses cause problems if that macro is ever extended (it's not possible to reliably extend that macro without potentially breaking some code that has used the macro).  It's better to always define parentheses, even if they are not used.  This check will also throw a warning if there are spaces between the macro name and the opening parenthesis.
+
+* Default:  true
+* Severity: WARNING
+
+#### indentationMultiple
+This will check each line to ensure that the count of leading spaces can be divided cleanly by this multiple.
+
+* Default:  2
+* Severity: WARNING
+
+#### lowerCaseFileNames
+On *nix systems, it is imperative that autocall macros are in lowercase.  When sharing code between windows and *nix systems, the difference in case sensitivity can also be a cause of lost developer time.  For this reason, we recommend that sas filenames are always lowercase.
+
+* Default: true
+* Severity: WARNING
+
+#### maxLineLength
+Code becomes far more readable when line lengths are short.  The most compelling reason for short line lengths is to avoid the need to scroll when performing a side-by-side 'compare' between two files (eg as part of a GIT feature branch review).  A longer discussion on optimal code line length can be found [here](https://stackoverflow.com/questions/578059/studies-on-optimal-code-width)
+
+In batch mode, long SAS code lines may also be truncated, causing hard-to-detect errors.  
+
+For this reason we strongly recommend a line length limit, and we set the bar at 80.  To turn this feature off, set the value to 0.
+
+* Default: 80
+* Severity: WARNING
+
+#### noNestedMacros
+Where macros are defined inside other macros, they are recompiled every time the outer maro is invoked.  Hence, it is widely considered inefficient, and bad practice, to nest macro definitions.  
+
+* Default:  true
+* Severity: WARNING
+
+#### noSpacesInFileNames
+The 'beef' we have with spaces in filenames is twofold:
+
+* Loss of the in-built ability to 'click' a filepath and have the file open automatically
+* The need to quote such filepaths in order to use them in CLI commands
+
+In addition, when such files are used in URLs, they are often padded with a messy "%20" type quotation.  And of course, for macros (where the macro should match the filename) then spaces are simply not valid.
+
+* Default:  true
+* Severity: WARNING
+
+#### noTabIndentation
+Whilst there are some arguments for using tabs to indent (such as the ability to set your own indentation width, and to save on characters) there are many, many, many developers who think otherwise.  We're in that camp.  Sorry (not sorry).
+
+* Default:  true
+* Severity: WARNING
+
+#### noTrailingSpaces
+This will highlight lines with trailing spaces.  Trailing spaces serve no useful purpose in a SAS program.
+
+* Default:  true
+* severity: WARNING
+
+### Upcoming Linting Rules:
+
+* `noTabs` -> does what it says on the tin 
+* `noGremlins` -> identifies all invisible characters, other than spaces / tabs / line endings.  If you really need that bell character, use a hex literal!
+* `lineEndings` -> set a standard line ending, such as LF or CRLF
+
+## SAS Formatter
+
+A formatter will automatically apply rules when you hit SAVE, which can save a LOT of time.
+
+We're looking to implement the following rules:
+
+* Remove trailing spaces
+* Change tabs to spaces 
+* Add the macro name to the %mend statement 
+* Add a doxygen header template if none exists 
+
+Later we will investigate some harder stuff, such as automatic indentation and code layout
+
+## Sponsorship & Contributions
+
+SASjs is an open source framework!  Contributions are welcomed.  If you would like to see a feature, because it would be useful in your project, but you don't have the requisite (Typescript) experience - then how about you engage us on a short project and we build it for you?
+
+Contact [Allan Bowe](https://www.linkedin.com/in/allanbowe/) for further details.
+
+## SAS 9 Health check
+
+The SASjs Linter (and formatter) is a great way to de-risk and accelerate the delivery of SAS code into production environments.  However, code is just one part of a SAS estate.  If you are running SAS 9, you may be interested to know what 'gremlins' are lurking in your system.  Maybe you are preparing for a migration.  Maybe you are preparing to hand over the control of your environment.  Either way, an assessment of your existing system would put minds at rest and pro-actively identify trouble spots.
+
+The SAS 9 Health Check is a 'plug & play' product, that uses the [SAS 9 REST API](https://sas9api.io) to run hundreds of metadata and system checks to identify common problems.  The checks are non-invasive, and becuase it is a client app, there is NOTHING TO INSTALL on your SAS server.  We offer this assessment for a low fixed fee, and if you engage our (competitively priced) services to address the issues we highlight, then the assessment is free.
+
+Contact [Allan Bowe](https://www.linkedin.com/in/allanbowe/) for further details.
+
+

package-lock.json

@@ -648,9 +648,9 @@
       }
     },
     "@sasjs/utils": {
-      "version": "2.9.0",
+      "version": "2.10.1",
-      "resolved": "https://registry.npmjs.org/@sasjs/utils/-/utils-2.9.0.tgz",
+      "resolved": "https://registry.npmjs.org/@sasjs/utils/-/utils-2.10.1.tgz",
-      "integrity": "sha512-j7ssEmb8OSZHUUL0PGVgoby0j0ClCcsLsydDCk/C4OAoWPAUPFI5HgGFPSEipz9+P8OlL/EBnglj4LGtlFHCpw==",
+      "integrity": "sha512-T54jx6NEMLu2+R/ux4qcb3dDJ7nFrKkPCkmPXEfZxPQBkbq4C0kmaZv6dC63RDH68wYhoXR2S5fION5fFh91iw==",
       "requires": {
         "@types/prompts": "^2.0.9",
         "consola": "^2.15.0",
@@ -778,9 +778,9 @@
       "dev": true
     },
     "@types/prompts": {
-      "version": "2.0.9",
+      "version": "2.0.10",
-      "resolved": "https://registry.npmjs.org/@types/prompts/-/prompts-2.0.9.tgz",
+      "resolved": "https://registry.npmjs.org/@types/prompts/-/prompts-2.0.10.tgz",
-      "integrity": "sha512-TORZP+FSjTYMWwKadftmqEn6bziN5RnfygehByGsjxoK5ydnClddtv6GikGWPvCm24oI+YBwck5WDxIIyNxUrA==",
+      "integrity": "sha512-W3PEl3l4vmxdgfY6LUG7ysh+mLJOTOFYmSpiLe6MCo1OdEm8b5s6ZJfuTQgEpYNwcMiiaRzJespPS5Py2tqLlQ==",
       "requires": {
         "@types/node": "*"
       }

package.json

@@ -44,6 +44,6 @@
     "typescript": "^4.2.3"
   },
   "dependencies": {
-    "@sasjs/utils": "^2.9.0"
+    "@sasjs/utils": "^2.10.1"
   }
 }

sasjslint-schema.json

@@ -5,28 +5,34 @@
   "title": "SASjs Lint Config File",
   "description": "The SASjs Lint Config file provides the settings for customising SAS code style in your project.",
   "default": {
-    "noTrailingSpaces": true,
     "noEncodedPasswords": true,
     "hasDoxygenHeader": true,
-    "noSpacesInFileNames": true
+    "hasMacroNameInMend": false,
+    "hasMacroParentheses": true,
+    "indentationMultiple": 2,
+    "lowerCaseFileNames": true,
+    "maxLineLength": 80,
+    "noNestedMacros": true,
+    "noSpacesInFileNames": true,
+    "noTabIndentation": true,
+    "noTrailingSpaces": true
   },
   "examples": [
     {
       "noTrailingSpaces": true,
       "noEncodedPasswords": true,
       "hasDoxygenHeader": true,
-      "noSpacesInFileNames": true
+      "noSpacesInFileNames": true,
+      "lowerCaseFileNames": true,
+      "maxLineLength": 80,
+      "noTabIndentation": true,
+      "indentationMultiple": 4,
+      "hasMacroNameInMend": true,
+      "noNestedMacros": true,
+      "hasMacroParentheses": true
     }
   ],
   "properties": {
-    "noTrailingSpaces": {
-      "$id": "#/properties/noTrailingSpaces",
-      "type": "boolean",
-      "title": "noTrailingSpaces",
-      "description": "Enforces no trailing spaces in lines of SAS code. Shows a warning when they are present.",
-      "default": true,
-      "examples": [true, false]
-    },
     "noEncodedPasswords": {
       "$id": "#/properties/noEncodedPasswords",
       "type": "boolean",
@@ -43,6 +49,54 @@
       "default": true,
       "examples": [true, false]
     },
+    "hasMacroNameInMend": {
+      "$id": "#/properties/hasMacroNameInMend",
+      "type": "boolean",
+      "title": "hasMacroNameInMend",
+      "description": "Enforces the presence of macro names in %mend statements. Shows a warning for %mend statements with missing or mismatched macro names.",
+      "default": false,
+      "examples": [true, false]
+    },
+    "hasMacroParentheses": {
+      "$id": "#/properties/hasMacroParentheses",
+      "type": "boolean",
+      "title": "hasMacroParentheses",
+      "description": "Enforces the presence of parentheses in macro definitions. Shows a warning for each macro defined without parentheses, or with spaces between the macro name and the opening parenthesis.",
+      "default": true,
+      "examples": [true, false]
+    },
+    "indentationMultiple": {
+      "$id": "#/properties/indentationMultiple",
+      "type": "number",
+      "title": "indentationMultiple",
+      "description": "Enforces a configurable multiple for the number of spaces for indentation. Shows a warning for lines that are not indented by a multiple of this number.",
+      "default": 2,
+      "examples": [2, 3, 4]
+    },
+    "lowerCaseFileNames": {
+      "$id": "#/properties/lowerCaseFileNames",
+      "type": "boolean",
+      "title": "lowerCaseFileNames",
+      "description": "Enforces no uppercase characters in file names. Shows a warning when they are present.",
+      "default": true,
+      "examples": [true, false]
+    },
+    "maxLineLength": {
+      "$id": "#/properties/maxLineLength",
+      "type": "number",
+      "title": "maxLineLength",
+      "description": "Enforces a configurable maximum line length. Shows a warning for lines exceeding this length.",
+      "default": 80,
+      "examples": [60, 80, 120]
+    },
+    "noNestedMacros": {
+      "$id": "#/properties/noNestedMacros",
+      "type": "boolean",
+      "title": "noNestedMacros",
+      "description": "Enforces the absence of nested macro definitions. Shows a warning for each nested macro definition.",
+      "default": true,
+      "examples": [true, false]
+    },
     "noSpacesInFileNames": {
       "$id": "#/properties/noSpacesInFileNames",
       "type": "boolean",
@@ -50,6 +104,22 @@
       "description": "Enforces no spaces in file names. Shows a warning when they are present.",
       "default": true,
       "examples": [true, false]
+    },
+    "noTabIndentation": {
+      "$id": "#/properties/noTabIndentation",
+      "type": "boolean",
+      "title": "noTabIndentation",
+      "description": "Enforces no indentation using tabs. Shows a warning when a line starts with a tab.",
+      "default": true,
+      "examples": [true, false]
+    },
+    "noTrailingSpaces": {
+      "$id": "#/properties/noTrailingSpaces",
+      "type": "boolean",
+      "title": "noTrailingSpaces",
+      "description": "Enforces no trailing spaces in lines of SAS code. Shows a warning when they are present.",
+      "default": true,
+      "examples": [true, false]
     }
   }
 }

src/Example File.sas

@@ -0,0 +1,18 @@
+  
+  
+%macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+  %local x libref;
+  %let x={SAS002};
+   %do x=0 %to &maxtries;
+	%if %sysfunc(libref(&prefix&x)) ne 0 %then %do;
+  %let libref=&prefix&x;
+    %let rc=%sysfunc(libname(&libref,%sysfunc(pathname(work))));
+    %if &rc %then %put %sysfunc(sysmsg());
+    &prefix&x
+    %*put &sysmacroname: Libref &libref assigned as WORK and returned;
+    %return;
+  %end;
+  %end;
+  %put unable to find available libref in range &prefix.0-&maxtries;
+  %mend;
+

src/example file.sas

@@ -1,17 +0,0 @@
-  
-  
- %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
-   %local x libref;
-   %let x={SAS002};
-   %do x=0 %to &maxtries;
-   %if %sysfunc(libref(&prefix&x)) ne 0 %then %do;
-     %let libref=&prefix&x;
-     %let rc=%sysfunc(libname(&libref,%sysfunc(pathname(work))));
-     %if &rc %then %put %sysfunc(sysmsg());
-     &prefix&x
-     %*put &sysmacroname: Libref &libref assigned as WORK and returned;
-     %return;
-   %end;
-   %end;
-   %put unable to find available libref in range &prefix.0-&maxtries;
- %mend;

src/example.ts

@@ -1,49 +1,58 @@
-import { lintText } from './lint'
+import { lintFile, lintText } from './lint'
+import path from 'path'
 
 /**
  * Example which tests a piece of text with all known violations.
  */
 
 const text = `/**
-   @file
+  @file
-   @brief Returns an unused libref
+  @brief Returns an unused libref
-   @details Use as follows:
+  @details Use as follows:
   
-     libname mclib0 (work);
+    libname mclib0 (work);
-     libname mclib1 (work);
+    libname mclib1 (work);
-     libname mclib2 (work);
+    libname mclib2 (work);
   
-     %let libref=%mf_getuniquelibref({SAS001});
+    %let libref=%mf_getuniquelibref({SAS001});
-     %put &=libref;
+    %put &=libref;
   
-   which returns:
+  which returns:
   
  > mclib3
   
-   @param prefix= first part of libref.  Remember that librefs can only be 8 characters,
+  @param prefix= first part of libref.  Remember that librefs can only be 8 characters,
-     so a 7 letter prefix would mean that maxtries should be 10.
+    so a 7 letter prefix would mean that maxtries should be 10.
-   @param maxtries= the last part of the libref.  Provide an integer value.
+  @param maxtries= the last part of the libref.  Provide an integer value.
   
-   @version 9.2
+  @version 9.2
-   @author Allan Bowe
+  @author Allan Bowe
  **/
   
   
- %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+%macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
-   %local x libref;
+  %local x libref;
-   %let x={SAS002};
+  %let x={SAS002};
    %do x=0 %to &maxtries;
-   %if %sysfunc(libref(&prefix&x)) ne 0 %then %do;
+	%if %sysfunc(libref(&prefix&x)) ne 0 %then %do;
-     %let libref=&prefix&x;
+  %let libref=&prefix&x;
-     %let rc=%sysfunc(libname(&libref,%sysfunc(pathname(work))));
+    %let rc=%sysfunc(libname(&libref,%sysfunc(pathname(work))));
-     %if &rc %then %put %sysfunc(sysmsg());
+    %if &rc %then %put %sysfunc(sysmsg());
-     &prefix&x
+    &prefix&x
-     %*put &sysmacroname: Libref &libref assigned as WORK and returned;
+    %*put &sysmacroname: Libref &libref assigned as WORK and returned;
-     %return;
+    %return;
-   %end;
+  %end;
-   %end;
+  %end;
-   %put unable to find available libref in range &prefix.0-&maxtries;
+  %put unable to find available libref in range &prefix.0-&maxtries;
- %mend;
+  %mend;
 `
 
-lintText(text).then((diagnostics) => console.table(diagnostics))
+lintText(text).then((diagnostics) => {
+  console.log('Text lint results:')
+  console.table(diagnostics)
+})
+
+lintFile(path.join(__dirname, 'Example File.sas')).then((diagnostics) => {
+  console.log('File lint results:')
+  console.table(diagnostics)
+})

src/index.ts

@@ -1,2 +1,3 @@
-export { lintText, lintFile } from './lint'
+export * from './lint'
 export * from './types'
+export * from './utils'

src/lint.spec.ts

@@ -1,137 +0,0 @@
-import { lintFile, lintText, splitText } from './lint'
-import { Severity } from './types/Severity'
-import path from 'path'
-
-describe('lintText', () => {
-  it('should identify trailing spaces', async () => {
-    const text = `/**
-      @file
-    **/
-    %put 'hello'; 
-        %put 'world';  `
-    const results = await lintText(text)
-
-    expect(results.length).toEqual(2)
-    expect(results[0]).toEqual({
-      message: 'Line contains trailing spaces',
-      lineNumber: 4,
-      startColumnNumber: 18,
-      endColumnNumber: 18,
-      severity: Severity.Warning
-    })
-    expect(results[1]).toEqual({
-      message: 'Line contains trailing spaces',
-      lineNumber: 5,
-      startColumnNumber: 22,
-      endColumnNumber: 23,
-      severity: Severity.Warning
-    })
-  })
-
-  it('should identify encoded passwords', async () => {
-    const text = `/**
-      @file
-    **/
-    %put '{SAS001}';`
-    const results = await lintText(text)
-
-    expect(results.length).toEqual(1)
-    expect(results[0]).toEqual({
-      message: 'Line contains encoded password',
-      lineNumber: 4,
-      startColumnNumber: 11,
-      endColumnNumber: 19,
-      severity: Severity.Error
-    })
-  })
-
-  it('should identify missing doxygen header', async () => {
-    const text = `%put 'hello';`
-    const results = await lintText(text)
-
-    expect(results.length).toEqual(1)
-    expect(results[0]).toEqual({
-      message: 'File missing Doxygen header',
-      lineNumber: 1,
-      startColumnNumber: 1,
-      endColumnNumber: 1,
-      severity: Severity.Warning
-    })
-  })
-
-  it('should return an empty list with an empty file', async () => {
-    const text = `/**
-      @file
-    **/`
-    const results = await lintText(text)
-
-    expect(results.length).toEqual(0)
-  })
-})
-
-describe('lintFile', () => {
-  it('should identify lint issues in a given file', async () => {
-    const results = await lintFile(path.join(__dirname, 'example file.sas'))
-
-    expect(results.length).toEqual(5)
-    expect(results).toContainEqual({
-      message: 'Line contains trailing spaces',
-      lineNumber: 1,
-      startColumnNumber: 1,
-      endColumnNumber: 2,
-      severity: Severity.Warning
-    })
-    expect(results).toContainEqual({
-      message: 'Line contains trailing spaces',
-      lineNumber: 2,
-      startColumnNumber: 1,
-      endColumnNumber: 2,
-      severity: Severity.Warning
-    })
-    expect(results).toContainEqual({
-      message: 'File name contains spaces',
-      lineNumber: 1,
-      startColumnNumber: 1,
-      endColumnNumber: 1,
-      severity: Severity.Warning
-    })
-    expect(results).toContainEqual({
-      message: 'File missing Doxygen header',
-      lineNumber: 1,
-      startColumnNumber: 1,
-      endColumnNumber: 1,
-      severity: Severity.Warning
-    })
-    expect(results).toContainEqual({
-      message: 'Line contains encoded password',
-      lineNumber: 5,
-      startColumnNumber: 11,
-      endColumnNumber: 19,
-      severity: Severity.Error
-    })
-  })
-})
-
-describe('splitText', () => {
-  it('should return an empty array when text is falsy', () => {
-    const lines = splitText('')
-
-    expect(lines.length).toEqual(0)
-  })
-
-  it('should return an array of lines from text', () => {
-    const lines = splitText(`line 1\nline 2`)
-
-    expect(lines.length).toEqual(2)
-    expect(lines[0]).toEqual('line 1')
-    expect(lines[1]).toEqual('line 2')
-  })
-
-  it('should work with CRLF line endings', () => {
-    const lines = splitText(`line 1\r\nline 2`)
-
-    expect(lines.length).toEqual(2)
-    expect(lines[0]).toEqual('line 1')
-    expect(lines[1]).toEqual('line 2')
-  })
-})

src/lint.ts

@@ -1,81 +0,0 @@
-import { readFile } from '@sasjs/utils/file'
-import { Diagnostic } from './types/Diagnostic'
-import { LintConfig } from './types/LintConfig'
-import { getLintConfig } from './utils/getLintConfig'
-
-/**
- * Analyses and produces a set of diagnostics for the given text content.
- * @param {string} text - the text content to be linted.
- * @returns {Diagnostic[]} array of diagnostic objects, each containing a warning, line number and column number.
- */
-export const lintText = async (text: string) => {
-  const config = await getLintConfig()
-  return processText(text, config)
-}
-
-/**
- * Analyses and produces a set of diagnostics for the file at the given path.
- * @param {string} filePath - the path to the file to be linted.
- * @returns {Diagnostic[]} array of diagnostic objects, each containing a warning, line number and column number.
- */
-export const lintFile = async (filePath: string) => {
-  const config = await getLintConfig()
-  const text = await readFile(filePath)
-
-  const fileDiagnostics = processFile(filePath, config)
-  const textDiagnostics = processText(text, config)
-
-  return [...fileDiagnostics, ...textDiagnostics]
-}
-
-/**
- * Splits the given content into a list of lines, regardless of CRLF or LF line endings.
- * @param {string} text - the text content to be split into lines.
- * @returns {string[]} an array of lines from the given text
- */
-export const splitText = (text: string): string[] => {
-  if (!text) return []
-  return text.replace(/\r\n/g, '\n').split('\n')
-}
-
-const processText = (text: string, config: LintConfig) => {
-  const lines = splitText(text)
-  const diagnostics: Diagnostic[] = []
-  diagnostics.push(...processContent(config, text))
-  lines.forEach((line, index) => {
-    diagnostics.push(...processLine(config, line, index + 1))
-  })
-
-  return diagnostics
-}
-
-const processContent = (config: LintConfig, content: string): Diagnostic[] => {
-  const diagnostics: Diagnostic[] = []
-  config.fileLintRules.forEach((rule) => {
-    diagnostics.push(...rule.test(content))
-  })
-
-  return diagnostics
-}
-
-const processLine = (
-  config: LintConfig,
-  line: string,
-  lineNumber: number
-): Diagnostic[] => {
-  const diagnostics: Diagnostic[] = []
-  config.lineLintRules.forEach((rule) => {
-    diagnostics.push(...rule.test(line, lineNumber))
-  })
-
-  return diagnostics
-}
-
-const processFile = (filePath: string, config: LintConfig): Diagnostic[] => {
-  const diagnostics: Diagnostic[] = []
-  config.pathLintRules.forEach((rule) => {
-    diagnostics.push(...rule.test(filePath))
-  })
-
-  return diagnostics
-}

src/lint/index.ts

@@ -0,0 +1,4 @@
+export * from './lintText'
+export * from './lintFile'
+export * from './lintFolder'
+export * from './lintProject'

src/lint/lintFile.spec.ts

@@ -0,0 +1,88 @@
+import { lintFile } from './lintFile'
+import { Severity } from '../types/Severity'
+import path from 'path'
+
+const expectedDiagnostics = [
+  {
+    message: 'Line contains trailing spaces',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line contains trailing spaces',
+    lineNumber: 2,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File name contains spaces',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File name contains uppercase characters',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File missing Doxygen header',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line contains encoded password',
+    lineNumber: 5,
+    startColumnNumber: 10,
+    endColumnNumber: 18,
+    severity: Severity.Error
+  },
+  {
+    message: 'Line is indented with a tab',
+    lineNumber: 7,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line has incorrect indentation - 3 spaces',
+    lineNumber: 6,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: '%mend statement is missing macro name - mf_getuniquelibref',
+    lineNumber: 17,
+    startColumnNumber: 3,
+    endColumnNumber: 9,
+    severity: Severity.Warning
+  }
+]
+
+describe('lintFile', () => {
+  it('should identify lint issues in a given file', async () => {
+    const results = await lintFile(
+      path.join(__dirname, '..', 'Example File.sas')
+    )
+
+    expect(results.length).toEqual(expectedDiagnostics.length)
+    expect(results).toContainEqual(expectedDiagnostics[0])
+    expect(results).toContainEqual(expectedDiagnostics[1])
+    expect(results).toContainEqual(expectedDiagnostics[2])
+    expect(results).toContainEqual(expectedDiagnostics[3])
+    expect(results).toContainEqual(expectedDiagnostics[4])
+    expect(results).toContainEqual(expectedDiagnostics[5])
+    expect(results).toContainEqual(expectedDiagnostics[6])
+    expect(results).toContainEqual(expectedDiagnostics[7])
+    expect(results).toContainEqual(expectedDiagnostics[8])
+  })
+})

src/lint/lintFile.ts

@@ -0,0 +1,23 @@
+import { readFile } from '@sasjs/utils/file'
+import { LintConfig } from '../types/LintConfig'
+import { getLintConfig } from '../utils/getLintConfig'
+import { processFile, processText } from './shared'
+
+/**
+ * Analyses and produces a set of diagnostics for the file at the given path.
+ * @param {string} filePath - the path to the file to be linted.
+ * @param {LintConfig} configuration - an optional configuration. When not passed in, this is read from the .sasjslint file.
+ * @returns {Diagnostic[]} array of diagnostic objects, each containing a warning, line number and column number.
+ */
+export const lintFile = async (
+  filePath: string,
+  configuration?: LintConfig
+) => {
+  const config = configuration || (await getLintConfig())
+  const text = await readFile(filePath)
+
+  const fileDiagnostics = processFile(filePath, config)
+  const textDiagnostics = processText(text, config)
+
+  return [...fileDiagnostics, ...textDiagnostics]
+}

src/lint/lintFolder.spec.ts

@@ -0,0 +1,91 @@
+import { lintFolder } from './lintFolder'
+import { Severity } from '../types/Severity'
+import path from 'path'
+
+const expectedFilesCount = 1
+const expectedDiagnostics = [
+  {
+    message: 'Line contains trailing spaces',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line contains trailing spaces',
+    lineNumber: 2,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File name contains spaces',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File name contains uppercase characters',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File missing Doxygen header',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line contains encoded password',
+    lineNumber: 5,
+    startColumnNumber: 10,
+    endColumnNumber: 18,
+    severity: Severity.Error
+  },
+  {
+    message: 'Line is indented with a tab',
+    lineNumber: 7,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line has incorrect indentation - 3 spaces',
+    lineNumber: 6,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: '%mend statement is missing macro name - mf_getuniquelibref',
+    lineNumber: 17,
+    startColumnNumber: 3,
+    endColumnNumber: 9,
+    severity: Severity.Warning
+  }
+]
+
+describe('lintFolder', () => {
+  it('should identify lint issues in a given folder', async () => {
+    const results = await lintFolder(path.join(__dirname, '..'))
+
+    expect(results.size).toEqual(expectedFilesCount)
+    const diagnostics = results.get(
+      path.join(__dirname, '..', 'Example File.sas')
+    )!
+    expect(diagnostics.length).toEqual(expectedDiagnostics.length)
+    expect(diagnostics).toContainEqual(expectedDiagnostics[0])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[1])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[2])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[3])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[4])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[5])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[6])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[7])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[8])
+  })
+})

src/lint/lintFolder.ts

@@ -0,0 +1,50 @@
+import { listSubFoldersInFolder } from '@sasjs/utils/file'
+import path from 'path'
+import { Diagnostic } from '../types/Diagnostic'
+import { LintConfig } from '../types/LintConfig'
+import { asyncForEach } from '../utils/asyncForEach'
+import { getLintConfig } from '../utils/getLintConfig'
+import { listSasFiles } from '../utils/listSasFiles'
+import { lintFile } from './lintFile'
+
+const excludeFolders = [
+  '.git',
+  '.github',
+  '.vscode',
+  'node_modules',
+  'sasjsbuild',
+  'sasjsresults'
+]
+
+/**
+ * Analyses and produces a set of diagnostics for the folder at the given path.
+ * @param {string} folderPath - the path to the folder to be linted.
+ * @param {LintConfig} configuration - an optional configuration. When not passed in, this is read from the .sasjslint file.
+ * @returns {Promise<Map<string, Diagnostic[]>>} Resolves with a map with array of diagnostic objects, each containing a warning, line number and column number, and grouped by file path.
+ */
+export const lintFolder = async (
+  folderPath: string,
+  configuration?: LintConfig
+) => {
+  const config = configuration || (await getLintConfig())
+  let diagnostics: Map<string, Diagnostic[]> = new Map<string, Diagnostic[]>()
+  const fileNames = await listSasFiles(folderPath)
+  await asyncForEach(fileNames, async (fileName) => {
+    const filePath = path.join(folderPath, fileName)
+    diagnostics.set(filePath, await lintFile(filePath, config))
+  })
+
+  const subFolders = (await listSubFoldersInFolder(folderPath)).filter(
+    (f: string) => !excludeFolders.includes(f)
+  )
+
+  await asyncForEach(subFolders, async (subFolder) => {
+    const subFolderDiagnostics = await lintFolder(
+      path.join(folderPath, subFolder),
+      config
+    )
+    diagnostics = new Map([...diagnostics, ...subFolderDiagnostics])
+  })
+
+  return diagnostics
+}

src/lint/lintProject.spec.ts

@@ -0,0 +1,106 @@
+import { lintProject } from './lintProject'
+import { Severity } from '../types/Severity'
+import * as utils from '../utils'
+import path from 'path'
+jest.mock('../utils')
+
+const expectedFilesCount = 1
+const expectedDiagnostics = [
+  {
+    message: 'Line contains trailing spaces',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line contains trailing spaces',
+    lineNumber: 2,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File name contains spaces',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File name contains uppercase characters',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File missing Doxygen header',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line contains encoded password',
+    lineNumber: 5,
+    startColumnNumber: 10,
+    endColumnNumber: 18,
+    severity: Severity.Error
+  },
+  {
+    message: 'Line is indented with a tab',
+    lineNumber: 7,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line has incorrect indentation - 3 spaces',
+    lineNumber: 6,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: '%mend statement is missing macro name - mf_getuniquelibref',
+    lineNumber: 17,
+    startColumnNumber: 3,
+    endColumnNumber: 9,
+    severity: Severity.Warning
+  }
+]
+
+describe('lintProject', () => {
+  it('should identify lint issues in a given project', async () => {
+    jest
+      .spyOn(utils, 'getProjectRoot')
+      .mockImplementationOnce(() => Promise.resolve(path.join(__dirname, '..')))
+    const results = await lintProject()
+
+    expect(results.size).toEqual(expectedFilesCount)
+    const diagnostics = results.get(
+      path.join(__dirname, '..', 'Example File.sas')
+    )!
+    expect(diagnostics.length).toEqual(expectedDiagnostics.length)
+    expect(diagnostics).toContainEqual(expectedDiagnostics[0])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[1])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[2])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[3])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[4])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[5])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[6])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[7])
+    expect(diagnostics).toContainEqual(expectedDiagnostics[8])
+  })
+
+  it('should throw an error when a project root is not found', async () => {
+    jest
+      .spyOn(utils, 'getProjectRoot')
+      .mockImplementationOnce(() => Promise.resolve(''))
+
+    await expect(lintProject()).rejects.toThrowError(
+      'SASjs Project Root was not found.'
+    )
+  })
+})

src/lint/lintProject.ts

@@ -0,0 +1,16 @@
+import { getProjectRoot } from '../utils'
+import { lintFolder } from './lintFolder'
+
+/**
+ * Analyses and produces a set of diagnostics for the current project.
+ * @returns {Promise<Map<string, Diagnostic[]>>} Resolves with a map with array of diagnostic objects, each containing a warning, line number and column number, and grouped by file path.
+ */
+export const lintProject = async () => {
+  const projectRoot =
+    (await getProjectRoot()) || process.projectDir || process.currentDir
+
+  if (!projectRoot) {
+    throw new Error('SASjs Project Root was not found.')
+  }
+  return await lintFolder(projectRoot)
+}

src/lint/lintText.spec.ts

@@ -0,0 +1,69 @@
+import { lintText } from './lintText'
+import { Severity } from '../types/Severity'
+
+describe('lintText', () => {
+  it('should identify trailing spaces', async () => {
+    const text = `/**
+      @file
+    **/
+    %put 'hello'; 
+        %put 'world';  `
+    const results = await lintText(text)
+
+    expect(results.length).toEqual(2)
+    expect(results[0]).toEqual({
+      message: 'Line contains trailing spaces',
+      lineNumber: 4,
+      startColumnNumber: 18,
+      endColumnNumber: 18,
+      severity: Severity.Warning
+    })
+    expect(results[1]).toEqual({
+      message: 'Line contains trailing spaces',
+      lineNumber: 5,
+      startColumnNumber: 22,
+      endColumnNumber: 23,
+      severity: Severity.Warning
+    })
+  })
+
+  it('should identify encoded passwords', async () => {
+    const text = `/**
+      @file
+    **/
+    %put '{SAS001}';`
+    const results = await lintText(text)
+
+    expect(results.length).toEqual(1)
+    expect(results[0]).toEqual({
+      message: 'Line contains encoded password',
+      lineNumber: 4,
+      startColumnNumber: 11,
+      endColumnNumber: 19,
+      severity: Severity.Error
+    })
+  })
+
+  it('should identify missing doxygen header', async () => {
+    const text = `%put 'hello';`
+    const results = await lintText(text)
+
+    expect(results.length).toEqual(1)
+    expect(results[0]).toEqual({
+      message: 'File missing Doxygen header',
+      lineNumber: 1,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    })
+  })
+
+  it('should return an empty list with an empty file', async () => {
+    const text = `/**
+      @file
+    **/`
+    const results = await lintText(text)
+
+    expect(results.length).toEqual(0)
+  })
+})

src/lint/lintText.ts

@@ -0,0 +1,12 @@
+import { getLintConfig } from '../utils/getLintConfig'
+import { processText } from './shared'
+
+/**
+ * Analyses and produces a set of diagnostics for the given text content.
+ * @param {string} text - the text content to be linted.
+ * @returns {Diagnostic[]} array of diagnostic objects, each containing a warning, line number and column number.
+ */
+export const lintText = async (text: string) => {
+  const config = await getLintConfig()
+  return processText(text, config)
+}

src/lint/shared.spec.ts

@@ -0,0 +1,25 @@
+import { splitText } from './shared'
+
+describe('splitText', () => {
+  it('should return an empty array when text is falsy', () => {
+    const lines = splitText('')
+
+    expect(lines.length).toEqual(0)
+  })
+
+  it('should return an array of lines from text', () => {
+    const lines = splitText(`line 1\nline 2`)
+
+    expect(lines.length).toEqual(2)
+    expect(lines[0]).toEqual('line 1')
+    expect(lines[1]).toEqual('line 2')
+  })
+
+  it('should work with CRLF line endings', () => {
+    const lines = splitText(`line 1\r\nline 2`)
+
+    expect(lines.length).toEqual(2)
+    expect(lines[0]).toEqual('line 1')
+    expect(lines[1]).toEqual('line 2')
+  })
+})

src/lint/shared.ts

@@ -0,0 +1,56 @@
+import { LintConfig, Diagnostic } from '../types'
+
+/**
+ * Splits the given content into a list of lines, regardless of CRLF or LF line endings.
+ * @param {string} text - the text content to be split into lines.
+ * @returns {string[]} an array of lines from the given text
+ */
+export const splitText = (text: string): string[] => {
+  if (!text) return []
+  return text.replace(/\r\n/g, '\n').split('\n')
+}
+
+export const processText = (text: string, config: LintConfig) => {
+  const lines = splitText(text)
+  const diagnostics: Diagnostic[] = []
+  diagnostics.push(...processContent(config, text))
+  lines.forEach((line, index) => {
+    diagnostics.push(...processLine(config, line, index + 1))
+  })
+
+  return diagnostics
+}
+
+export const processFile = (
+  filePath: string,
+  config: LintConfig
+): Diagnostic[] => {
+  const diagnostics: Diagnostic[] = []
+  config.pathLintRules.forEach((rule) => {
+    diagnostics.push(...rule.test(filePath))
+  })
+
+  return diagnostics
+}
+
+const processContent = (config: LintConfig, content: string): Diagnostic[] => {
+  const diagnostics: Diagnostic[] = []
+  config.fileLintRules.forEach((rule) => {
+    diagnostics.push(...rule.test(content))
+  })
+
+  return diagnostics
+}
+
+export const processLine = (
+  config: LintConfig,
+  line: string,
+  lineNumber: number
+): Diagnostic[] => {
+  const diagnostics: Diagnostic[] = []
+  config.lineLintRules.forEach((rule) => {
+    diagnostics.push(...rule.test(line, lineNumber, config))
+  })
+
+  return diagnostics
+}

src/rules/file/hasDoxygenHeader.spec.ts

@@ -1,4 +1,4 @@
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
 import { hasDoxygenHeader } from './hasDoxygenHeader'
 
 describe('hasDoxygenHeader', () => {
@@ -34,6 +34,27 @@ describe('hasDoxygenHeader', () => {
     ])
   })
 
+  it('should return an array with a single diagnostic when the file has comment blocks but no header', () => {
+    const content = `
+ %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+   %local x libref;
+   %let x={SAS002};
+  /** Comment Line 1
+   * Comment Line 2
+   */
+   %do x=0 %to &maxtries;`
+
+    expect(hasDoxygenHeader.test(content)).toEqual([
+      {
+        message: 'File missing Doxygen header',
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
   it('should return an array with a single diagnostic when the file is undefined', () => {
     const content = undefined
 

src/rules/file/hasDoxygenHeader.ts

@@ -1,6 +1,6 @@
-import { FileLintRule } from '../types/LintRule'
+import { FileLintRule } from '../../types/LintRule'
-import { LintRuleType } from '../types/LintRuleType'
+import { LintRuleType } from '../../types/LintRuleType'
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
 
 const name = 'hasDoxygenHeader'
 const description =
@@ -8,7 +8,7 @@ const description =
 const message = 'File missing Doxygen header'
 const test = (value: string) => {
   try {
-    const hasFileHeader = value.split('/**')[0] !== value
+    const hasFileHeader = value.trimStart().startsWith('/*')
     if (hasFileHeader) return []
     return [
       {

src/rules/file/hasMacroNameInMend.spec.ts

@@ -0,0 +1,322 @@
+import { Severity } from '../../types/Severity'
+import { hasMacroNameInMend } from './hasMacroNameInMend'
+
+describe('hasMacroNameInMend', () => {
+  it('should return an empty array when %mend has correct macro name', () => {
+    const content = `
+  %macro somemacro();
+    %put &sysmacroname;
+  %mend somemacro;`
+
+    expect(hasMacroNameInMend.test(content)).toEqual([])
+  })
+
+  it('should return an empty array when %mend has correct macro name without parentheses', () => {
+    const content = `
+  %macro somemacro;
+    %put &sysmacroname;
+  %mend somemacro;`
+
+    expect(hasMacroNameInMend.test(content)).toEqual([])
+  })
+
+  it('should return an array with a single diagnostic when %mend has no macro name', () => {
+    const content = `
+  %macro somemacro;
+    %put &sysmacroname;
+  %mend;`
+
+    expect(hasMacroNameInMend.test(content)).toEqual([
+      {
+        message: '%mend statement is missing macro name - somemacro',
+        lineNumber: 4,
+        startColumnNumber: 3,
+        endColumnNumber: 9,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostic when a macro is missing an %mend statement', () => {
+    const content = `%macro somemacro;
+    %put &sysmacroname;`
+
+    expect(hasMacroNameInMend.test(content)).toEqual([
+      {
+        message: 'Missing %mend statement for macro - somemacro',
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a diagnostic for each macro missing an %mend statement', () => {
+    const content = `%macro somemacro;
+    %put &sysmacroname;
+    %macro othermacro`
+
+    expect(hasMacroNameInMend.test(content)).toEqual([
+      {
+        message: 'Missing %mend statement for macro - somemacro',
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      },
+      {
+        message: 'Missing %mend statement for macro - othermacro',
+        lineNumber: 3,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostic when %mend has incorrect macro name', () => {
+    const content = `
+  %macro somemacro;
+    %put &sysmacroname;
+  %mend someanothermacro;`
+
+    expect(hasMacroNameInMend.test(content)).toEqual([
+      {
+        message: `%mend statement has mismatched macro name, it should be 'somemacro'`,
+        lineNumber: 4,
+        startColumnNumber: 9,
+        endColumnNumber: 24,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostic when extra %mend statement is present', () => {
+    const content = `
+  %macro somemacro;
+    %put &sysmacroname;
+  %mend somemacro;
+  %mend something;`
+
+    expect(hasMacroNameInMend.test(content)).toEqual([
+      {
+        message: '%mend statement is redundant',
+        lineNumber: 5,
+        startColumnNumber: 3,
+        endColumnNumber: 18,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an empty array when the file is undefined', () => {
+    const content = undefined
+
+    expect(hasMacroNameInMend.test((content as unknown) as string)).toEqual([])
+  })
+
+  describe('nestedMacros', () => {
+    it('should return an empty array when %mend has correct macro name', () => {
+      const content = `
+  %macro outer();
+
+    %macro inner();
+      %put inner;
+    %mend inner;
+    %inner()
+    %put outer;
+  %mend outer;`
+
+      expect(hasMacroNameInMend.test(content)).toEqual([])
+    })
+
+    it('should return an array with a single diagnostic when %mend has no macro name(inner)', () => {
+      const content = `
+  %macro outer();
+
+    %macro inner();
+      %put inner;
+    %mend;
+    %inner()
+    %put outer;
+  %mend outer;`
+
+      expect(hasMacroNameInMend.test(content)).toEqual([
+        {
+          message: '%mend statement is missing macro name - inner',
+          lineNumber: 6,
+          startColumnNumber: 5,
+          endColumnNumber: 11,
+          severity: Severity.Warning
+        }
+      ])
+    })
+
+    it('should return an array with a single diagnostic when %mend has no macro name(outer)', () => {
+      const content = `
+  %macro outer();
+
+    %macro inner();
+      %put inner;
+    %mend inner;
+    %inner()
+    %put outer;
+  %mend;`
+
+      expect(hasMacroNameInMend.test(content)).toEqual([
+        {
+          message: '%mend statement is missing macro name - outer',
+          lineNumber: 9,
+          startColumnNumber: 3,
+          endColumnNumber: 9,
+          severity: Severity.Warning
+        }
+      ])
+    })
+
+    it('should return an array with two diagnostics when %mend has no macro name(none)', () => {
+      const content = `
+  %macro outer();
+
+    %macro inner();
+      %put inner;
+    %mend;
+    %inner()
+    %put outer;
+  %mend;`
+
+      expect(hasMacroNameInMend.test(content)).toEqual([
+        {
+          message: '%mend statement is missing macro name - inner',
+          lineNumber: 6,
+          startColumnNumber: 5,
+          endColumnNumber: 11,
+          severity: Severity.Warning
+        },
+        {
+          message: '%mend statement is missing macro name - outer',
+          lineNumber: 9,
+          startColumnNumber: 3,
+          endColumnNumber: 9,
+          severity: Severity.Warning
+        }
+      ])
+    })
+  })
+
+  describe('with extra spaces and comments', () => {
+    it('should return an empty array when %mend has correct macro name', () => {
+      const content = `
+      /* 1st comment */
+     %macro  somemacro ;
+
+      %put &sysmacroname;
+
+     /* 2nd 
+     comment */
+      /* 3rd comment */ %mend  somemacro ;`
+
+      expect(hasMacroNameInMend.test(content)).toEqual([])
+    })
+
+    it('should return an array with a single diagnostic when %mend has correct macro name having code in comments', () => {
+      const content = `/**
+      @file examplemacro.sas
+      @brief an example of a macro to be used in a service
+      @details  This macro is great. Yadda yadda yadda.  Usage:
+
+        * code formatting applies when indented by 4 spaces; code formatting applies when indented by 4 spaces; code formatting applies when indented by 4 spaces; code formatting applies when indented by 4 spaces; code formatting applies when indented by 4 spaces;
+
+        some code
+        %macro examplemacro123();      
+        
+        %examplemacro()
+
+      <h4> SAS Macros </h4>
+      @li doesnothing.sas
+
+      @author Allan Bowe
+    **/
+
+    %macro examplemacro();
+
+    proc sql;
+    create table areas
+      as select area
+      
+    from sashelp.springs;
+
+    %doesnothing();
+
+    %mend;`
+
+      expect(hasMacroNameInMend.test(content)).toEqual([
+        {
+          message: '%mend statement is missing macro name - examplemacro',
+          lineNumber: 29,
+          startColumnNumber: 5,
+          endColumnNumber: 11,
+          severity: Severity.Warning
+        }
+      ])
+    })
+
+    it('should return an array with a single diagnostic when %mend has incorrect macro name', () => {
+      const content = `
+    %macro  somemacro;
+/* some comments */
+      %put  &sysmacroname;
+/* some comments */
+    %mend    someanothermacro   ;`
+
+      expect(hasMacroNameInMend.test(content)).toEqual([
+        {
+          message: `%mend statement has mismatched macro name, it should be 'somemacro'`,
+          lineNumber: 6,
+          startColumnNumber: 14,
+          endColumnNumber: 29,
+          severity: Severity.Warning
+        }
+      ])
+    })
+
+    it('should return an array with a single diagnostic when %mend has no macro name', () => {
+      const content = `
+     %macro   somemacro ;
+      /* some comments */%put &sysmacroname;
+    %mend         ;`
+
+      expect(hasMacroNameInMend.test(content)).toEqual([
+        {
+          message: '%mend statement is missing macro name - somemacro',
+          lineNumber: 4,
+          startColumnNumber: 5,
+          endColumnNumber: 11,
+          severity: Severity.Warning
+        }
+      ])
+    })
+
+    describe('nestedMacros', () => {
+      it('should return an empty array when %mend has correct macro name', () => {
+        const content = `
+  %macro outer( ) ;
+
+
+    %macro inner();
+
+      %put inner;
+
+       %mend inner;
+
+      %inner()
+
+         %put outer;
+  %mend outer;`
+
+        expect(hasMacroNameInMend.test(content)).toEqual([])
+      })
+    })
+  })
+})

src/rules/file/hasMacroNameInMend.ts

@@ -0,0 +1,107 @@
+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'
+
+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 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
+    })
+  })
+
+  return diagnostics
+}
+
+/**
+ * Lint rule that checks for the presence of macro name in %mend statement.
+ */
+export const hasMacroNameInMend: FileLintRule = {
+  type: LintRuleType.File,
+  name,
+  description,
+  message,
+  test
+}

src/rules/file/hasMacroParentheses.spec.ts

@@ -0,0 +1,142 @@
+import { Severity } from '../../types/Severity'
+import { hasMacroParentheses } from './hasMacroParentheses'
+
+describe('hasMacroParentheses', () => {
+  it('should return an empty array when macro defined correctly', () => {
+    const content = `
+  %macro somemacro();
+    %put &sysmacroname;
+  %mend somemacro;`
+
+    expect(hasMacroParentheses.test(content)).toEqual([])
+  })
+
+  it('should return an array with a single diagnostics when macro defined without parentheses', () => {
+    const content = `
+  %macro somemacro;
+    %put &sysmacroname;
+  %mend somemacro;`
+
+    expect(hasMacroParentheses.test(content)).toEqual([
+      {
+        message: 'Macro definition missing parentheses',
+        lineNumber: 2,
+        startColumnNumber: 10,
+        endColumnNumber: 18,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostics when macro defined without name', () => {
+    const content = `
+  %macro ();
+    %put &sysmacroname;
+  %mend;`
+
+    expect(hasMacroParentheses.test(content)).toEqual([
+      {
+        message: 'Macro definition missing name',
+        lineNumber: 2,
+        startColumnNumber: 3,
+        endColumnNumber: 12,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostics when macro defined without name and parentheses', () => {
+    const content = `
+  %macro ;
+    %put &sysmacroname;
+  %mend;`
+
+    expect(hasMacroParentheses.test(content)).toEqual([
+      {
+        message: 'Macro definition missing name',
+        lineNumber: 2,
+        startColumnNumber: 3,
+        endColumnNumber: 9,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an empty array when the file is undefined', () => {
+    const content = undefined
+
+    expect(hasMacroParentheses.test((content as unknown) as string)).toEqual([])
+  })
+
+  describe('with extra spaces and comments', () => {
+    it('should return an empty array when %mend has correct macro name', () => {
+      const content = `
+      /* 1st comment */
+     %macro  somemacro();
+
+      %put &sysmacroname;
+
+     /* 2nd 
+     comment */
+      /* 3rd comment */ %mend  somemacro ;`
+
+      expect(hasMacroParentheses.test(content)).toEqual([])
+    })
+
+    it('should return an array with a single diagnostic when macro defined without parentheses having code in comments', () => {
+      const content = `/**
+      @file examplemacro.sas
+      @brief an example of a macro to be used in a service
+      @details  This macro is great. Yadda yadda yadda.  Usage:
+
+        * code formatting applies when indented by 4 spaces; code formatting applies when indented by 4 spaces; code formatting applies when indented by 4 spaces; code formatting applies when indented by 4 spaces; code formatting applies when indented by 4 spaces;
+
+        some code
+        %macro examplemacro123();      
+        
+        %examplemacro()
+
+      <h4> SAS Macros </h4>
+      @li doesnothing.sas
+
+      @author Allan Bowe
+    **/
+
+    %macro examplemacro;
+
+    proc sql;
+    create table areas
+      as select area
+      
+    from sashelp.springs;
+
+    %doesnothing();
+
+    %mend;`
+
+      expect(hasMacroParentheses.test(content)).toEqual([
+        {
+          message: 'Macro definition missing parentheses',
+          lineNumber: 19,
+          startColumnNumber: 12,
+          endColumnNumber: 23,
+          severity: Severity.Warning
+        }
+      ])
+    })
+  })
+
+  it('should return an array with a single diagnostic when a macro definition contains a space', () => {
+    const content = `%macro test ()`
+
+    expect(hasMacroParentheses.test(content)).toEqual([
+      {
+        message: 'Macro definition contains space(s)',
+        lineNumber: 1,
+        startColumnNumber: 8,
+        endColumnNumber: 14,
+        severity: Severity.Warning
+      }
+    ])
+  })
+})

src/rules/file/hasMacroParentheses.ts

@@ -0,0 +1,85 @@
+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'
+
+const name = 'hasMacroParentheses'
+const description = 'Enforces the presence of parentheses in macro definitions.'
+const message = 'Macro definition missing parentheses'
+const test = (value: string) => {
+  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
+          })
+      }
+    })
+  })
+  return diagnostics
+}
+
+/**
+ * Lint rule that enforces the presence of parentheses in macro definitions..
+ */
+export const hasMacroParentheses: FileLintRule = {
+  type: LintRuleType.File,
+  name,
+  description,
+  message,
+  test
+}

src/rules/file/index.ts

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

src/rules/file/noNestedMacros.spec.ts

@@ -0,0 +1,78 @@
+import { Severity } from '../../types/Severity'
+import { noNestedMacros } from './noNestedMacros'
+
+describe('noNestedMacros', () => {
+  it('should return an empty array when no nested macro', () => {
+    const content = `
+  %macro somemacro();
+    %put &sysmacroname;
+  %mend somemacro;`
+
+    expect(noNestedMacros.test(content)).toEqual([])
+  })
+
+  it('should return an array with a single diagnostic when a macro contains a nested macro definition', () => {
+    const content = `
+    %macro outer();
+      /* any amount of arbitrary code */
+      %macro inner();
+        %put inner;
+      %mend;
+      %inner()
+      %put outer;
+    %mend;
+
+    %outer()`
+
+    expect(noNestedMacros.test(content)).toEqual([
+      {
+        message: "Macro definition for 'inner' present in macro 'outer'",
+        lineNumber: 4,
+        startColumnNumber: 7,
+        endColumnNumber: 20,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostic when nested macros are defined at 2 levels', () => {
+    const content = `
+    %macro outer();
+      /* any amount of arbitrary code */
+      %macro inner();
+        %put inner;
+
+                %macro inner2();
+                  %put inner2;
+                %mend;
+      %mend;
+      %inner()
+      %put outer;
+    %mend;
+
+    %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
+      }
+    ])
+  })
+
+  it('should return an empty array when the file is undefined', () => {
+    const content = undefined
+
+    expect(noNestedMacros.test((content as unknown) as string)).toEqual([])
+  })
+})

src/rules/file/noNestedMacros.ts

@@ -0,0 +1,68 @@
+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'
+
+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 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()
+      }
+    })
+  })
+  return diagnostics
+}
+
+/**
+ * Lint rule that checks for the absence of nested macro definitions.
+ */
+export const noNestedMacros: FileLintRule = {
+  type: LintRuleType.File,
+  name,
+  description,
+  message,
+  test
+}

src/rules/line/indentationMultiple.spec.ts

@@ -0,0 +1,74 @@
+import { LintConfig, Severity } from '../../types'
+import { indentationMultiple } from './indentationMultiple'
+
+describe('indentationMultiple', () => {
+  it('should return an empty array when the line is indented by two spaces', () => {
+    const line = "  %put 'hello';"
+    const config = new LintConfig({ indentationMultiple: 2 })
+    expect(indentationMultiple.test(line, 1, config)).toEqual([])
+  })
+
+  it('should return an empty array when the line is indented by a multiple of 2 spaces', () => {
+    const line = "      %put 'hello';"
+    const config = new LintConfig({ indentationMultiple: 2 })
+    expect(indentationMultiple.test(line, 1, config)).toEqual([])
+  })
+
+  it('should ignore indentation when the multiple is set to 0', () => {
+    const line = " %put 'hello';"
+    const config = new LintConfig({ indentationMultiple: 0 })
+    expect(indentationMultiple.test(line, 1, config)).toEqual([])
+  })
+
+  it('should return an empty array when the line is not indented', () => {
+    const line = "%put 'hello';"
+    const config = new LintConfig({ indentationMultiple: 2 })
+    expect(indentationMultiple.test(line, 1, config)).toEqual([])
+  })
+
+  it('should return an array with a single diagnostic when the line is indented incorrectly', () => {
+    const line = "   %put 'hello';"
+    const config = new LintConfig({ indentationMultiple: 2 })
+    expect(indentationMultiple.test(line, 1, config)).toEqual([
+      {
+        message: `Line has incorrect indentation - 3 spaces`,
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostic when the line is indented incorrectly', () => {
+    const line = "  %put 'hello';"
+    const config = new LintConfig({ indentationMultiple: 3 })
+    expect(indentationMultiple.test(line, 1, config)).toEqual([
+      {
+        message: `Line has incorrect indentation - 2 spaces`,
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should fall back to a default of 2 spaces', () => {
+    const line = " %put 'hello';"
+    expect(indentationMultiple.test(line, 1)).toEqual([
+      {
+        message: `Line has incorrect indentation - 1 space`,
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an empty array for lines within the default indentation', () => {
+    const line = "  %put 'hello';"
+    expect(indentationMultiple.test(line, 1)).toEqual([])
+  })
+})

src/rules/line/indentationMultiple.ts

@@ -0,0 +1,41 @@
+import { LintConfig } from '../../types'
+import { LineLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
+
+const name = 'indentationMultiple'
+const description = 'Ensure indentation by a multiple of the configured number.'
+const message = 'Line has incorrect indentation'
+const test = (value: string, lineNumber: number, config?: LintConfig) => {
+  if (!value.startsWith(' ')) return []
+
+  const indentationMultiple = isNaN(config?.indentationMultiple as number)
+    ? 2
+    : config!.indentationMultiple
+
+  if (indentationMultiple === 0) return []
+  const numberOfSpaces = value.search(/\S|$/)
+  if (numberOfSpaces % indentationMultiple! === 0) return []
+  return [
+    {
+      message: `${message} - ${numberOfSpaces} ${
+        numberOfSpaces === 1 ? 'space' : 'spaces'
+      }`,
+      lineNumber,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    }
+  ]
+}
+
+/**
+ * Lint rule that checks if a line is indented by a multiple of the configured indentation multiple.
+ */
+export const indentationMultiple: LineLintRule = {
+  type: LintRuleType.Line,
+  name,
+  description,
+  message,
+  test
+}

src/rules/line/index.ts

@@ -0,0 +1,5 @@
+export { indentationMultiple } from './indentationMultiple'
+export { maxLineLength } from './maxLineLength'
+export { noEncodedPasswords } from './noEncodedPasswords'
+export { noTabIndentation } from './noTabIndentation'
+export { noTrailingSpaces } from './noTrailingSpaces'

src/rules/line/maxLineLength.spec.ts

@@ -0,0 +1,44 @@
+import { LintConfig, Severity } from '../../types'
+import { maxLineLength } from './maxLineLength'
+
+describe('maxLineLength', () => {
+  it('should return an empty array when the line is within the specified length', () => {
+    const line = "%put 'hello';"
+    const config = new LintConfig({ maxLineLength: 60 })
+    expect(maxLineLength.test(line, 1, config)).toEqual([])
+  })
+
+  it('should return an array with a single diagnostic when the line exceeds the specified length', () => {
+    const line = "%put 'hello';"
+    const config = new LintConfig({ maxLineLength: 10 })
+    expect(maxLineLength.test(line, 1, config)).toEqual([
+      {
+        message: `Line exceeds maximum length by 3 characters`,
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should fall back to a default of 80 characters', () => {
+    const line =
+      'Prow scuttle parrel provost Sail ho shrouds spirits boom mizzenmast yardarm. Pinnace holystone.'
+    expect(maxLineLength.test(line, 1)).toEqual([
+      {
+        message: `Line exceeds maximum length by 15 characters`,
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an empty array for lines within the default length', () => {
+    const line =
+      'Prow scuttle parrel provost Sail ho shrouds spirits boom mizzenmast yard'
+    expect(maxLineLength.test(line, 1)).toEqual([])
+  })
+})

src/rules/line/maxLineLength.ts

@@ -0,0 +1,32 @@
+import { LintConfig } from '../../types'
+import { LineLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
+
+const name = 'maxLineLength'
+const description = 'Restrict lines to the specified length.'
+const message = 'Line exceeds maximum length'
+const test = (value: string, lineNumber: number, config?: LintConfig) => {
+  const maxLineLength = config?.maxLineLength || 80
+  if (value.length <= maxLineLength) return []
+  return [
+    {
+      message: `${message} by ${value.length - maxLineLength} characters`,
+      lineNumber,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    }
+  ]
+}
+
+/**
+ * Lint rule that checks if a line has exceeded the configured maximum length.
+ */
+export const maxLineLength: LineLintRule = {
+  type: LintRuleType.Line,
+  name,
+  description,
+  message,
+  test
+}

src/rules/line/noEncodedPasswords.spec.ts

@@ -1,4 +1,4 @@
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
 import { noEncodedPasswords } from './noEncodedPasswords'
 
 describe('noEncodedPasswords', () => {

src/rules/line/noEncodedPasswords.ts

@@ -1,6 +1,6 @@
-import { LineLintRule } from '../types/LintRule'
+import { LineLintRule } from '../../types/LintRule'
-import { LintRuleType } from '../types/LintRuleType'
+import { LintRuleType } from '../../types/LintRuleType'
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
 
 const name = 'noEncodedPasswords'
 const description = 'Disallow encoded passwords in SAS code.'

src/rules/line/noTabIndentation.spec.ts

@@ -0,0 +1,22 @@
+import { Severity } from '../../types/Severity'
+import { noTabIndentation } from './noTabIndentation'
+
+describe('noTabs', () => {
+  it('should return an empty array when the line is not indented with a tab', () => {
+    const line = "%put 'hello';"
+    expect(noTabIndentation.test(line, 1)).toEqual([])
+  })
+
+  it('should return an array with a single diagnostic when the line is indented with a tab', () => {
+    const line = "\t%put 'hello';"
+    expect(noTabIndentation.test(line, 1)).toEqual([
+      {
+        message: 'Line is indented with a tab',
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+})

src/rules/line/noTabIndentation.ts

@@ -0,0 +1,30 @@
+import { LineLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
+
+const name = 'noTabs'
+const description = 'Disallow indenting with tabs.'
+const message = 'Line is indented with a tab'
+const test = (value: string, lineNumber: number) => {
+  if (!value.startsWith('\t')) return []
+  return [
+    {
+      message,
+      lineNumber,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    }
+  ]
+}
+
+/**
+ * Lint rule that checks if a given line of text is indented with a tab.
+ */
+export const noTabIndentation: LineLintRule = {
+  type: LintRuleType.Line,
+  name,
+  description,
+  message,
+  test
+}

src/rules/line/noTrailingSpaces.spec.ts

@@ -1,4 +1,4 @@
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
 import { noTrailingSpaces } from './noTrailingSpaces'
 
 describe('noTrailingSpaces', () => {

src/rules/line/noTrailingSpaces.ts

@@ -1,6 +1,6 @@
-import { LineLintRule } from '../types/LintRule'
+import { LineLintRule } from '../../types/LintRule'
-import { LintRuleType } from '../types/LintRuleType'
+import { LintRuleType } from '../../types/LintRuleType'
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
 
 const name = 'noTrailingSpaces'
 const description = 'Disallow trailing spaces on lines.'

src/rules/path/index.ts

@@ -0,0 +1,2 @@
+export { lowerCaseFileNames } from './lowerCaseFileNames'
+export { noSpacesInFileNames } from './noSpacesInFileNames'

src/rules/path/lowerCaseFileNames.spec.ts

@@ -0,0 +1,27 @@
+import { Severity } from '../../types/Severity'
+import { lowerCaseFileNames } from './lowerCaseFileNames'
+
+describe('lowerCaseFileNames', () => {
+  it('should return an empty array when the file name has no uppercase characters', () => {
+    const filePath = '/code/sas/my_sas_file.sas'
+    expect(lowerCaseFileNames.test(filePath)).toEqual([])
+  })
+
+  it('should return an empty array when the file name has no uppercase characters, even if the containing folder has uppercase characters', () => {
+    const filePath = '/code/SAS Projects/my_sas_file.sas'
+    expect(lowerCaseFileNames.test(filePath)).toEqual([])
+  })
+
+  it('should return an array with a single diagnostic when the file name has uppercase characters', () => {
+    const filePath = '/code/sas/my SAS file.sas'
+    expect(lowerCaseFileNames.test(filePath)).toEqual([
+      {
+        message: 'File name contains uppercase characters',
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+})

src/rules/path/lowerCaseFileNames.ts

@@ -0,0 +1,32 @@
+import { PathLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
+import path from 'path'
+
+const name = 'lowerCaseFileNames'
+const description = 'Enforce the use of lower case file names.'
+const message = 'File name contains uppercase characters'
+const test = (value: string) => {
+  const fileName = path.basename(value)
+  if (fileName.toLocaleLowerCase() === fileName) return []
+  return [
+    {
+      message,
+      lineNumber: 1,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    }
+  ]
+}
+
+/**
+ * Lint rule that checks for the absence of uppercase characters in a given file name.
+ */
+export const lowerCaseFileNames: PathLintRule = {
+  type: LintRuleType.Path,
+  name,
+  description,
+  message,
+  test
+}

src/rules/path/noSpacesInFileNames.spec.ts

@@ -1,4 +1,4 @@
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
 import { noSpacesInFileNames } from './noSpacesInFileNames'
 
 describe('noSpacesInFileNames', () => {

src/rules/path/noSpacesInFileNames.ts

@@ -1,7 +1,7 @@
-import { PathLintRule } from '../types/LintRule'
+import { PathLintRule } from '../../types/LintRule'
-import { LintRuleType } from '../types/LintRuleType'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
 import path from 'path'
-import { Severity } from '../types/Severity'
 
 const name = 'noSpacesInFileNames'
 const description = 'Enforce the absence of spaces within file names.'

src/types/LintConfig.spec.ts

@@ -40,22 +40,116 @@ describe('LintConfig', () => {
     expect(config.fileLintRules[0].type).toEqual(LintRuleType.File)
   })
 
+  it('should create an instance with the hasMacroNameInMend flag set', () => {
+    const config = new LintConfig({ hasMacroNameInMend: true })
+
+    expect(config).toBeTruthy()
+    expect(config.lineLintRules.length).toEqual(0)
+    expect(config.fileLintRules.length).toEqual(1)
+    expect(config.fileLintRules[0].name).toEqual('hasMacroNameInMend')
+    expect(config.fileLintRules[0].type).toEqual(LintRuleType.File)
+  })
+
+  it('should create an instance with the hasMacroNameInMend flag off', () => {
+    const config = new LintConfig({ hasMacroNameInMend: false })
+
+    expect(config).toBeTruthy()
+    expect(config.lineLintRules.length).toEqual(0)
+    expect(config.fileLintRules.length).toEqual(0)
+  })
+
+  it('should create an instance with the noNestedMacros flag set', () => {
+    const config = new LintConfig({ noNestedMacros: true })
+
+    expect(config).toBeTruthy()
+    expect(config.lineLintRules.length).toEqual(0)
+    expect(config.fileLintRules.length).toEqual(1)
+    expect(config.fileLintRules[0].name).toEqual('noNestedMacros')
+    expect(config.fileLintRules[0].type).toEqual(LintRuleType.File)
+  })
+
+  it('should create an instance with the noNestedMacros flag off', () => {
+    const config = new LintConfig({ noNestedMacros: false })
+
+    expect(config).toBeTruthy()
+    expect(config.lineLintRules.length).toEqual(0)
+    expect(config.fileLintRules.length).toEqual(0)
+  })
+
+  it('should create an instance with the hasMacroParentheses flag set', () => {
+    const config = new LintConfig({ hasMacroParentheses: true })
+
+    expect(config).toBeTruthy()
+    expect(config.lineLintRules.length).toEqual(0)
+    expect(config.fileLintRules.length).toEqual(1)
+    expect(config.fileLintRules[0].name).toEqual('hasMacroParentheses')
+    expect(config.fileLintRules[0].type).toEqual(LintRuleType.File)
+  })
+
+  it('should create an instance with the hasMacroParentheses flag off', () => {
+    const config = new LintConfig({ hasMacroParentheses: false })
+
+    expect(config).toBeTruthy()
+    expect(config.lineLintRules.length).toEqual(0)
+    expect(config.fileLintRules.length).toEqual(0)
+  })
+
+  it('should create an instance with the indentation multiple set', () => {
+    const config = new LintConfig({ indentationMultiple: 5 })
+
+    expect(config).toBeTruthy()
+    expect(config.indentationMultiple).toEqual(5)
+  })
+
+  it('should create an instance with the indentation multiple turned off', () => {
+    const config = new LintConfig({ indentationMultiple: 0 })
+
+    expect(config).toBeTruthy()
+    expect(config.indentationMultiple).toEqual(0)
+  })
+
   it('should create an instance with all flags set', () => {
     const config = new LintConfig({
       noTrailingSpaces: true,
       noEncodedPasswords: true,
-      hasDoxygenHeader: true
+      hasDoxygenHeader: true,
+      noSpacesInFileNames: true,
+      lowerCaseFileNames: true,
+      maxLineLength: 80,
+      noTabIndentation: true,
+      indentationMultiple: 2,
+      hasMacroNameInMend: true,
+      noNestedMacros: true,
+      hasMacroParentheses: true
     })
 
     expect(config).toBeTruthy()
-    expect(config.lineLintRules.length).toEqual(2)
+    expect(config.lineLintRules.length).toEqual(5)
     expect(config.lineLintRules[0].name).toEqual('noTrailingSpaces')
     expect(config.lineLintRules[0].type).toEqual(LintRuleType.Line)
     expect(config.lineLintRules[1].name).toEqual('noEncodedPasswords')
     expect(config.lineLintRules[1].type).toEqual(LintRuleType.Line)
+    expect(config.lineLintRules[2].name).toEqual('noTabs')
+    expect(config.lineLintRules[2].type).toEqual(LintRuleType.Line)
+    expect(config.lineLintRules[3].name).toEqual('maxLineLength')
+    expect(config.lineLintRules[3].type).toEqual(LintRuleType.Line)
+    expect(config.lineLintRules[4].name).toEqual('indentationMultiple')
+    expect(config.lineLintRules[4].type).toEqual(LintRuleType.Line)
 
-    expect(config.fileLintRules.length).toEqual(1)
+    expect(config.fileLintRules.length).toEqual(4)
     expect(config.fileLintRules[0].name).toEqual('hasDoxygenHeader')
     expect(config.fileLintRules[0].type).toEqual(LintRuleType.File)
+    expect(config.fileLintRules[1].name).toEqual('hasMacroNameInMend')
+    expect(config.fileLintRules[1].type).toEqual(LintRuleType.File)
+    expect(config.fileLintRules[2].name).toEqual('noNestedMacros')
+    expect(config.fileLintRules[2].type).toEqual(LintRuleType.File)
+    expect(config.fileLintRules[3].name).toEqual('hasMacroParentheses')
+    expect(config.fileLintRules[3].type).toEqual(LintRuleType.File)
+
+    expect(config.pathLintRules.length).toEqual(2)
+    expect(config.pathLintRules[0].name).toEqual('noSpacesInFileNames')
+    expect(config.pathLintRules[0].type).toEqual(LintRuleType.Path)
+    expect(config.pathLintRules[1].name).toEqual('lowerCaseFileNames')
+    expect(config.pathLintRules[1].type).toEqual(LintRuleType.Path)
   })
 })

src/types/LintConfig.ts

@@ -1,7 +1,17 @@
-import { hasDoxygenHeader } from '../rules/hasDoxygenHeader'
+import {
-import { noEncodedPasswords } from '../rules/noEncodedPasswords'
+  hasDoxygenHeader,
-import { noSpacesInFileNames } from '../rules/noSpacesInFileNames'
+  hasMacroNameInMend,
-import { noTrailingSpaces } from '../rules/noTrailingSpaces'
+  noNestedMacros,
+  hasMacroParentheses
+} from '../rules/file'
+import {
+  indentationMultiple,
+  maxLineLength,
+  noEncodedPasswords,
+  noTabIndentation,
+  noTrailingSpaces
+} from '../rules/line'
+import { lowerCaseFileNames, noSpacesInFileNames } from '../rules/path'
 import { FileLintRule, LineLintRule, PathLintRule } from './LintRule'
 
 /**
@@ -15,6 +25,8 @@ export class LintConfig {
   readonly lineLintRules: LineLintRule[] = []
   readonly fileLintRules: FileLintRule[] = []
   readonly pathLintRules: PathLintRule[] = []
+  readonly maxLineLength: number = 80
+  readonly indentationMultiple: number = 2
 
   constructor(json?: any) {
     if (json?.noTrailingSpaces) {
@@ -25,6 +37,20 @@ export class LintConfig {
       this.lineLintRules.push(noEncodedPasswords)
     }
 
+    if (json?.noTabIndentation) {
+      this.lineLintRules.push(noTabIndentation)
+    }
+
+    if (json?.maxLineLength) {
+      this.maxLineLength = json.maxLineLength
+      this.lineLintRules.push(maxLineLength)
+    }
+
+    if (!isNaN(json?.indentationMultiple)) {
+      this.indentationMultiple = json.indentationMultiple as number
+      this.lineLintRules.push(indentationMultiple)
+    }
+
     if (json?.hasDoxygenHeader) {
       this.fileLintRules.push(hasDoxygenHeader)
     }
@@ -32,5 +58,21 @@ export class LintConfig {
     if (json?.noSpacesInFileNames) {
       this.pathLintRules.push(noSpacesInFileNames)
     }
+
+    if (json?.lowerCaseFileNames) {
+      this.pathLintRules.push(lowerCaseFileNames)
+    }
+
+    if (json?.hasMacroNameInMend) {
+      this.fileLintRules.push(hasMacroNameInMend)
+    }
+
+    if (json?.noNestedMacros) {
+      this.fileLintRules.push(noNestedMacros)
+    }
+
+    if (json?.hasMacroParentheses) {
+      this.fileLintRules.push(hasMacroParentheses)
+    }
   }
 }

src/types/LintRule.ts

@@ -1,4 +1,5 @@
 import { Diagnostic } from './Diagnostic'
+import { LintConfig } from './LintConfig'
 import { LintRuleType } from './LintRuleType'
 
 /**
@@ -17,7 +18,7 @@ export interface LintRule {
  */
 export interface LineLintRule extends LintRule {
   type: LintRuleType.Line
-  test: (value: string, lineNumber: number) => Diagnostic[]
+  test: (value: string, lineNumber: number, config?: LintConfig) => Diagnostic[]
 }
 
 /**

src/types/Process.d.ts

@@ -0,0 +1,6 @@
+declare namespace NodeJS {
+  export interface Process {
+    projectDir: string
+    currentDir: string
+  }
+}

src/utils/asyncForEach.spec.ts

@@ -0,0 +1,15 @@
+import { asyncForEach } from './asyncForEach'
+
+describe('asyncForEach', () => {
+  it('should execute the async callback for each item in the given array', async () => {
+    const callback = jest.fn().mockImplementation(() => Promise.resolve())
+    const array = [1, 2, 3]
+
+    await asyncForEach(array, callback)
+
+    expect(callback.mock.calls.length).toEqual(3)
+    expect(callback.mock.calls[0]).toEqual([1, 0, array])
+    expect(callback.mock.calls[1]).toEqual([2, 1, array])
+    expect(callback.mock.calls[2]).toEqual([3, 2, array])
+  })
+})

src/utils/asyncForEach.ts

@@ -0,0 +1,11 @@
+/**
+ * Executes an async callback for each item in the given array.
+ */
+export async function asyncForEach(
+  array: any[],
+  callback: (item: any, index: number, originalArray: any[]) => any
+) {
+  for (let index = 0; index < array.length; index++) {
+    await callback(array[index], index, array)
+  }
+}

src/utils/getColumnNumber.spec.ts

@@ -0,0 +1,13 @@
+import { getColumnNumber } from './getColumnNumber'
+
+describe('getColumnNumber', () => {
+  it('should return the column number of the specified string within a line of text', () => {
+    expect(getColumnNumber('foo bar', 'bar')).toEqual(5)
+  })
+
+  it('should throw an error when the specified string is not found within the text', () => {
+    expect(() => getColumnNumber('foo bar', 'baz')).toThrowError(
+      "String 'baz' was not found in line 'foo bar'"
+    )
+  })
+})

src/utils/getColumnNumber.ts

@@ -0,0 +1,7 @@
+export const getColumnNumber = (line: string, text: string): number => {
+  const index = (line.split('\n').pop() as string).indexOf(text)
+  if (index < 0) {
+    throw new Error(`String '${text}' was not found in line '${line}'`)
+  }
+  return (line.split('\n').pop() as string).indexOf(text) + 1
+}

src/utils/getLintConfig.spec.ts

@@ -2,6 +2,10 @@ import * as fileModule from '@sasjs/utils/file'
 import { LintConfig } from '../types/LintConfig'
 import { getLintConfig } from './getLintConfig'
 
+const expectedFileLintRulesCount = 4
+const expectedLineLintRulesCount = 5
+const expectedPathLintRulesCount = 2
+
 describe('getLintConfig', () => {
   it('should get the lint config', async () => {
     const config = await getLintConfig()
@@ -17,7 +21,8 @@ describe('getLintConfig', () => {
     const config = await getLintConfig()
 
     expect(config).toBeInstanceOf(LintConfig)
-    expect(config.fileLintRules.length).toEqual(1)
+    expect(config.fileLintRules.length).toEqual(expectedFileLintRulesCount)
-    expect(config.lineLintRules.length).toEqual(2)
+    expect(config.lineLintRules.length).toEqual(expectedLineLintRulesCount)
+    expect(config.pathLintRules.length).toEqual(expectedPathLintRulesCount)
   })
 })

src/utils/getLintConfig.ts

@@ -3,11 +3,23 @@ import { LintConfig } from '../types/LintConfig'
 import { readFile } from '@sasjs/utils/file'
 import { getProjectRoot } from './getProjectRoot'
 
-const defaultConfiguration = {
+/**
+ * Default configuration that is used when a .sasjslint file is not found
+ */
+export const DefaultLintConfiguration = {
   noTrailingSpaces: true,
   noEncodedPasswords: true,
-  hasDoxygenHeader: true
+  hasDoxygenHeader: true,
+  noSpacesInFileNames: true,
+  lowerCaseFileNames: true,
+  maxLineLength: 80,
+  noTabIndentation: true,
+  indentationMultiple: 2,
+  hasMacroNameInMend: true,
+  noNestedMacros: true,
+  hasMacroParentheses: true
 }
+
 /**
  * Fetches the config from the .sasjslint file and creates a LintConfig object.
  * Returns the default configuration when a .sasjslint file is unavailable.
@@ -18,8 +30,7 @@ export async function getLintConfig(): Promise<LintConfig> {
   const configuration = await readFile(
     path.join(projectRoot, '.sasjslint')
   ).catch((_) => {
-    console.warn('Unable to load .sasjslint file. Using default configuration.')
+    return JSON.stringify(DefaultLintConfiguration)
-    return JSON.stringify(defaultConfiguration)
   })
   return new LintConfig(JSON.parse(configuration))
 }

src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './getLintConfig'
+export * from './getProjectRoot'
+export * from './listSasFiles'

src/utils/listSasFiles.ts

@@ -0,0 +1,10 @@
+import { listFilesInFolder } from '@sasjs/utils/file'
+
+/**
+ * Fetches a list of .sas files in the given path.
+ * @returns {Promise<string[]>} resolves with an array of file names.
+ */
+export const listSasFiles = async (folderPath: string): Promise<string[]> => {
+  const files = await listFilesInFolder(folderPath)
+  return files.filter((f) => f.endsWith('.sas'))
+}

src/utils/trimComments.spec.ts

@@ -0,0 +1,74 @@
+import { trimComments } from './trimComments'
+
+describe('trimComments', () => {
+  it('should return statment', () => {
+    expect(
+      trimComments(`
+      /* some comment */ some code;
+      `)
+    ).toEqual({ statement: 'some code;', commentStarted: false })
+  })
+
+  it('should return statment, having multi-line comment', () => {
+    expect(
+      trimComments(`
+        /* some 
+        comment */
+      some code;
+      `)
+    ).toEqual({ statement: 'some code;', commentStarted: false })
+  })
+
+  it('should return statment, having multi-line comment and some code present in comment', () => {
+    expect(
+      trimComments(`
+        /* some 
+      some code;
+        comment */
+      some other code;
+      `)
+    ).toEqual({ statement: 'some other code;', commentStarted: false })
+  })
+
+  it('should return empty statment, having only comment', () => {
+    expect(
+      trimComments(`
+        /* some 
+      some code;
+        comment */
+      `)
+    ).toEqual({ statement: '', commentStarted: false })
+  })
+
+  it('should return empty statment, having continuity in comment', () => {
+    expect(
+      trimComments(`
+        /* some 
+      some code;
+      `)
+    ).toEqual({ statement: '', commentStarted: true })
+  })
+
+  it('should return statment, having already started comment and ends', () => {
+    expect(
+      trimComments(
+        `
+        comment */
+      some code;
+      `,
+        true
+      )
+    ).toEqual({ statement: 'some code;', commentStarted: false })
+  })
+
+  it('should return empty statment, having already started comment and continuity in comment', () => {
+    expect(
+      trimComments(
+        `
+      some code;
+      `,
+        true
+      )
+    ).toEqual({ statement: '', commentStarted: true })
+  })
+})

src/utils/trimComments.ts

@@ -0,0 +1,19 @@
+export const trimComments = (
+  statement: string,
+  commentStarted: boolean = false
+): { statement: string; commentStarted: boolean } => {
+  let trimmed = (statement || '').trim()
+
+  if (commentStarted || trimmed.startsWith('/*')) {
+    const parts = trimmed.split('*/')
+    if (parts.length > 1) {
+      return {
+        statement: (parts.pop() as string).trim(),
+        commentStarted: false
+      }
+    } else {
+      return { statement: '', commentStarted: true }
+    }
+  }
+  return { statement: trimmed, commentStarted: false }
+}

tsconfig.json

@@ -7,6 +7,7 @@
       ],
       "target": "es5",
       "module": "commonjs",
+      "downlevelIteration": true,
       "moduleResolution": "node",
       "esModuleInterop": true,
       "declaration": true,