Merge pull request #21 from sasjs/issue-12

feat: new rule hasMacroNameInMend

.sasjslint

@@ -1,5 +1,11 @@
 {
     "noTrailingSpaces": true,
     "noEncodedPasswords": true,
-    "hasDoxygenHeader": true
+    "hasDoxygenHeader": true,
+    "noSpacesInFileNames": true,
+    "maxLineLength": 80,
+    "lowerCaseFileNames": true,
+    "noTabIndentation": true,
+    "indentationMultiple": 2,
+    "hasMacroNameInMend": false
 }

README.md

@@ -1,2 +1,112 @@
-# lint
-Linting and formatting for SAS® code
+# SAS Code linting and formatting
+
+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,
+    "indentationMultiple": 2,
+    "lowerCaseFileNames": true,
+    "maxLineLength": 80,
+    "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.
+
+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.
+
+Severity: WARNING
+
+#### indentationMultiple
+This will check each line to ensure that the count of leading spaces can be divided cleanly by this multiple.
+
+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.
+
+Severity: WARNING
+
+#### maxLineLength
+Whilst some developers are quite happy with their 4k UHD widescreen monitors, others are not so fortunate!  In addition, 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).  
+In batch mode, long code lines may be truncated, causing very hard-to-detect errors.
+
+For this reason we strongly recommend a line length limit, and we set the bar at 80.
+
+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.
+
+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).
+
+Severity: WARNING
+
+#### noTrailingSpaces
+This will highlight lines with trailing spaces.  Trailing spaces serve no useful purpose in a SAS program.
+
+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!
+* `hasMendName` -> show the macro name in the %mend statement
+* `noNestedMacros` -> highlight where macros are defined inside other macros 
+* `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",
-      "resolved": "https://registry.npmjs.org/@sasjs/utils/-/utils-2.9.0.tgz",
-      "integrity": "sha512-j7ssEmb8OSZHUUL0PGVgoby0j0ClCcsLsydDCk/C4OAoWPAUPFI5HgGFPSEipz9+P8OlL/EBnglj4LGtlFHCpw==",
+      "version": "2.10.1",
+      "resolved": "https://registry.npmjs.org/@sasjs/utils/-/utils-2.10.1.tgz",
+      "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",
-      "resolved": "https://registry.npmjs.org/@types/prompts/-/prompts-2.0.9.tgz",
-      "integrity": "sha512-TORZP+FSjTYMWwKadftmqEn6bziN5RnfygehByGsjxoK5ydnClddtv6GikGWPvCm24oI+YBwck5WDxIIyNxUrA==",
+      "version": "2.0.10",
+      "resolved": "https://registry.npmjs.org/@types/prompts/-/prompts-2.0.10.tgz",
+      "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

@@ -0,0 +1,95 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/sasjs/lint/blob/main/sasjslint-schema.json",
+  "type": "object",
+  "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,
+    "lowerCaseFileNames": true,
+    "maxLineLength": 80,
+    "noTabIndentation": true,
+    "indentationMultiple": 2
+  },
+  "examples": [
+    {
+      "noTrailingSpaces": true,
+      "noEncodedPasswords": true,
+      "hasDoxygenHeader": true,
+      "noSpacesInFileNames": true,
+      "lowerCaseFileNames": true,
+      "maxLineLength": 80,
+      "noTabIndentation": true,
+      "indentationMultiple": 4
+    }
+  ],
+  "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",
+      "title": "noEncodedPasswords",
+      "description": "Enforces no encoded passwords such as {SAS001} or {SASENC} in lines of SAS code. Shows an error when they are present.",
+      "default": true,
+      "examples": [true, false]
+    },
+    "hasDoxygenHeader": {
+      "$id": "#/properties/hasDoxygenHeader",
+      "type": "boolean",
+      "title": "hasDoxygenHeader",
+      "description": "Enforces the presence of a Doxygen header in the form of a comment block at the start of each SAS file. Shows a warning when one is absent.",
+      "default": true,
+      "examples": [true, false]
+    },
+    "noSpacesInFileNames": {
+      "$id": "#/properties/noSpacesInFileNames",
+      "type": "boolean",
+      "title": "noSpacesInFileNames",
+      "description": "Enforces no spaces in file names. Shows a warning when they are present.",
+      "default": true,
+      "examples": [true, false]
+    },
+    "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]
+    },
+    "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]
+    },
+    "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]
+    }
+  }
+}

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.ts

@@ -1,49 +1,58 @@
-import { lint } 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
-   @brief Returns an unused libref
-   @details Use as follows:
+  @file
+  @brief Returns an unused libref
+  @details Use as follows:
   
-     libname mclib0 (work);
-     libname mclib1 (work);
-     libname mclib2 (work);
+    libname mclib0 (work);
+    libname mclib1 (work);
+    libname mclib2 (work);
   
-     %let libref=%mf_getuniquelibref({SAS001});
-     %put &=libref;
+    %let libref=%mf_getuniquelibref({SAS001});
+    %put &=libref;
   
-   which returns:
+  which returns:
   
  > mclib3
   
-   @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.
-   @param maxtries= the last part of the libref.  Provide an integer value.
+  @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.
+  @param maxtries= the last part of the libref.  Provide an integer value.
   
-   @version 9.2
-   @author Allan Bowe
+  @version 9.2
+  @author Allan Bowe
  **/
   
   
- %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
-   %local x libref;
-   %let x={SAS002};
+%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;
+	%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;
 `
 
-lint(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 +1,3 @@
-export { lint } from './lint'
+export * from './lint'
+export * from './types'
+export * from './utils'

src/lint.spec.ts

@@ -1,84 +0,0 @@
-import { lint, splitText } from './lint'
-
-describe('lint', () => {
-  it('should identify trailing spaces', async () => {
-    const text = `/**
-      @file
-    **/
-    %put 'hello'; 
-        %put 'world';  `
-    const results = await lint(text)
-
-    expect(results.length).toEqual(2)
-    expect(results[0]).toEqual({
-      warning: 'Line contains trailing spaces',
-      lineNumber: 4,
-      columnNumber: 18
-    })
-    expect(results[1]).toEqual({
-      warning: 'Line contains trailing spaces',
-      lineNumber: 5,
-      columnNumber: 22
-    })
-  })
-
-  it('should identify encoded passwords', async () => {
-    const text = `/**
-      @file
-    **/
-    %put '{SAS001}';`
-    const results = await lint(text)
-
-    expect(results.length).toEqual(1)
-    expect(results[0]).toEqual({
-      warning: 'Line contains encoded password',
-      lineNumber: 4,
-      columnNumber: 11
-    })
-  })
-
-  it('should identify missing doxygen header', async () => {
-    const text = `%put 'hello';`
-    const results = await lint(text)
-
-    expect(results.length).toEqual(1)
-    expect(results[0]).toEqual({
-      warning: 'File missing Doxygen header',
-      lineNumber: 1,
-      columnNumber: 1
-    })
-  })
-
-  it('should return an empty list with an empty file', async () => {
-    const text = `/**
-      @file
-    **/`
-    const results = await lint(text)
-
-    expect(results.length).toEqual(0)
-  })
-})
-
-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/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,69 @@
+import { lintFile } from './lintFile'
+import { Severity } from '../types/Severity'
+import path from 'path'
+
+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(8)
+    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 name contains uppercase characters',
+      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: 10,
+      endColumnNumber: 18,
+      severity: Severity.Error
+    })
+    expect(results).toContainEqual({
+      message: 'Line is indented with a tab',
+      lineNumber: 7,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    })
+    expect(results).toContainEqual({
+      message: 'Line has incorrect indentation - 3 spaces',
+      lineNumber: 6,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    })
+  })
+})

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

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,86 @@
+import { lintProject } from './lintProject'
+import { Severity } from '../types/Severity'
+import * as utils from '../utils'
+import path from 'path'
+jest.mock('../utils')
+
+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(1)
+    const diagnostics = results.get(
+      path.join(__dirname, '..', 'Example File.sas')
+    )!
+    expect(diagnostics.length).toEqual(8)
+    expect(diagnostics).toContainEqual({
+      message: 'Line contains trailing spaces',
+      lineNumber: 1,
+      startColumnNumber: 1,
+      endColumnNumber: 2,
+      severity: Severity.Warning
+    })
+    expect(diagnostics).toContainEqual({
+      message: 'Line contains trailing spaces',
+      lineNumber: 2,
+      startColumnNumber: 1,
+      endColumnNumber: 2,
+      severity: Severity.Warning
+    })
+    expect(diagnostics).toContainEqual({
+      message: 'File name contains spaces',
+      lineNumber: 1,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    })
+    expect(diagnostics).toContainEqual({
+      message: 'File name contains uppercase characters',
+      lineNumber: 1,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    })
+    expect(diagnostics).toContainEqual({
+      message: 'File missing Doxygen header',
+      lineNumber: 1,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    })
+    expect(diagnostics).toContainEqual({
+      message: 'Line contains encoded password',
+      lineNumber: 5,
+      startColumnNumber: 10,
+      endColumnNumber: 18,
+      severity: Severity.Error
+    })
+    expect(diagnostics).toContainEqual({
+      message: 'Line is indented with a tab',
+      lineNumber: 7,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    })
+    expect(diagnostics).toContainEqual({
+      message: 'Line has incorrect indentation - 3 spaces',
+      lineNumber: 6,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    })
+  })
+
+  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

@@ -1,16 +1,4 @@
-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 lint = async (text: string) => {
-  const config = await getLintConfig()
-  return processText(text, config)
-}
+import { LintConfig, Diagnostic } from '../types'
 
 /**
  * Splits the given content into a list of lines, regardless of CRLF or LF line endings.
@@ -22,10 +10,10 @@ export const splitText = (text: string): string[] => {
   return text.replace(/\r\n/g, '\n').split('\n')
 }
 
-const processText = (text: string, config: LintConfig) => {
+export const processText = (text: string, config: LintConfig) => {
   const lines = splitText(text)
   const diagnostics: Diagnostic[] = []
-  diagnostics.push(...processFile(config, text))
+  diagnostics.push(...processContent(config, text))
   lines.forEach((line, index) => {
     diagnostics.push(...processLine(config, line, index + 1))
   })
@@ -33,23 +21,35 @@ const processText = (text: string, config: LintConfig) => {
   return diagnostics
 }
 
-const processFile = (config: LintConfig, fileContent: string): Diagnostic[] => {
+export const processFile = (
+  filePath: string,
+  config: LintConfig
+): Diagnostic[] => {
   const diagnostics: Diagnostic[] = []
-  config.fileLintRules.forEach((rule) => {
-    diagnostics.push(...rule.test(fileContent))
+  config.pathLintRules.forEach((rule) => {
+    diagnostics.push(...rule.test(filePath))
   })
 
   return diagnostics
 }
 
-const processLine = (
+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))
+    diagnostics.push(...rule.test(line, lineNumber, config))
   })
 
   return diagnostics

src/rules/hasDoxygenHeader.spec.ts

@@ -1,3 +1,4 @@
+import { Severity } from '../types/Severity'
 import { hasDoxygenHeader } from './hasDoxygenHeader'
 
 describe('hasDoxygenHeader', () => {
@@ -23,7 +24,34 @@ describe('hasDoxygenHeader', () => {
    %do x=0 %to &maxtries;`
 
     expect(hasDoxygenHeader.test(content)).toEqual([
-      { warning: 'File missing Doxygen header', lineNumber: 1, columnNumber: 1 }
+      {
+        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 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
+      }
     ])
   })
 
@@ -31,7 +59,13 @@ describe('hasDoxygenHeader', () => {
     const content = undefined
 
     expect(hasDoxygenHeader.test((content as unknown) as string)).toEqual([
-      { warning: 'File missing Doxygen header', lineNumber: 1, columnNumber: 1 }
+      {
+        message: 'File missing Doxygen header',
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
     ])
   })
 })

src/rules/hasDoxygenHeader.ts

@@ -1,17 +1,34 @@
 import { FileLintRule } from '../types/LintRule'
 import { LintRuleType } from '../types/LintRuleType'
+import { Severity } from '../types/Severity'
 
 const name = 'hasDoxygenHeader'
 const description =
   'Enforce the presence of a Doxygen header at the start of each file.'
-const warning = 'File missing Doxygen header'
+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 [{ warning, lineNumber: 1, columnNumber: 1 }]
+    return [
+      {
+        message,
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ]
   } catch (e) {
-    return [{ warning, lineNumber: 1, columnNumber: 1 }]
+    return [
+      {
+        message,
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ]
   }
 }
 
@@ -22,6 +39,6 @@ export const hasDoxygenHeader: FileLintRule = {
   type: LintRuleType.File,
   name,
   description,
-  warning,
+  message,
   test
 }

src/rules/hasMacroNameInMend.spec.ts

@@ -0,0 +1,266 @@
+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 missing macro name',
+        lineNumber: 4,
+        startColumnNumber: 3,
+        endColumnNumber: 9,
+        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: 'mismatch macro name in %mend statement',
+        lineNumber: 4,
+        startColumnNumber: 9,
+        endColumnNumber: 25,
+        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 missing macro name',
+          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 missing macro name',
+          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 missing macro name',
+          lineNumber: 6,
+          startColumnNumber: 5,
+          endColumnNumber: 11,
+          severity: Severity.Warning
+        },
+        {
+          message: '%mend missing macro name',
+          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 missing macro name',
+          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: 'mismatch macro name in %mend statement',
+          lineNumber: 6,
+          startColumnNumber: 14,
+          endColumnNumber: 30,
+          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 missing macro name',
+          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/hasMacroNameInMend.ts

@@ -0,0 +1,106 @@
+import { Diagnostic } from '../types/Diagnostic'
+import { FileLintRule } from '../types/LintRule'
+import { LintRuleType } from '../types/LintRuleType'
+import { Severity } from '../types/Severity'
+
+const name = 'hasMacroNameInMend'
+const description = 'The %mend statement should contain the macro name'
+const message = '$mend statement missing or incorrect'
+const test = (value: string) => {
+  const diagnostics: Diagnostic[] = []
+
+  const statements: string[] = value ? value.split(';') : []
+
+  const stack: string[] = []
+  let trimmedStatement = '',
+    commentStarted = false
+  statements.forEach((statement, index) => {
+    ;({ statement: trimmedStatement, commentStarted } = trimComments(
+      statement,
+      commentStarted
+    ))
+
+    if (trimmedStatement.startsWith('%macro ')) {
+      const macroName = trimmedStatement
+        .split(' ')
+        .filter((s: string) => !!s)[1]
+        .split('(')[0]
+      stack.push(macroName)
+    } else if (trimmedStatement.startsWith('%mend')) {
+      const macroStarted = stack.pop()
+      const macroName = trimmedStatement
+        .split(' ')
+        .filter((s: string) => !!s)[1]
+
+      if (!macroName) {
+        diagnostics.push({
+          message: '%mend missing macro name',
+          lineNumber: getLineNumber(statements, index + 1),
+          startColumnNumber: getColNumber(statement, '%mend'),
+          endColumnNumber: getColNumber(statement, '%mend') + 6,
+          severity: Severity.Warning
+        })
+      } else if (macroName !== macroStarted) {
+        diagnostics.push({
+          message: 'mismatch macro name in %mend statement',
+          lineNumber: getLineNumber(statements, index + 1),
+          startColumnNumber: getColNumber(statement, macroName),
+          endColumnNumber:
+            getColNumber(statement, macroName) + macroName.length,
+          severity: Severity.Warning
+        })
+      }
+    }
+  })
+  if (stack.length) {
+    diagnostics.push({
+      message: 'missing %mend statement for macro(s)',
+      lineNumber: statements.length + 1,
+      startColumnNumber: 1,
+      endColumnNumber: 1,
+      severity: Severity.Warning
+    })
+  }
+  return diagnostics
+}
+
+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 }
+}
+
+const getLineNumber = (statements: string[], index: number): number => {
+  const combinedCode = statements.slice(0, index).join(';')
+  const lines = (combinedCode.match(/\n/g) || []).length + 1
+  return lines
+}
+
+const getColNumber = (statement: string, text: string): number => {
+  return (statement.split('\n').pop() as string).indexOf(text) + 1
+}
+
+/**
+ * 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/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/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/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/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/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/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/noEncodedPasswords.spec.ts

@@ -1,3 +1,4 @@
+import { Severity } from '../types/Severity'
 import { noEncodedPasswords } from './noEncodedPasswords'
 
 describe('noEncodedPasswords', () => {
@@ -10,9 +11,11 @@ describe('noEncodedPasswords', () => {
     const line = "%put '{SASENC}';  "
     expect(noEncodedPasswords.test(line, 1)).toEqual([
       {
-        warning: 'Line contains encoded password',
+        message: 'Line contains encoded password',
         lineNumber: 1,
-        columnNumber: 7
+        startColumnNumber: 7,
+        endColumnNumber: 15,
+        severity: Severity.Error
       }
     ])
   })
@@ -21,9 +24,11 @@ describe('noEncodedPasswords', () => {
     const line = "%put '{SAS001}';  "
     expect(noEncodedPasswords.test(line, 1)).toEqual([
       {
-        warning: 'Line contains encoded password',
+        message: 'Line contains encoded password',
         lineNumber: 1,
-        columnNumber: 7
+        startColumnNumber: 7,
+        endColumnNumber: 15,
+        severity: Severity.Error
       }
     ])
   })
@@ -32,14 +37,18 @@ describe('noEncodedPasswords', () => {
     const line = "%put '{SAS001} {SAS002}';  "
     expect(noEncodedPasswords.test(line, 1)).toEqual([
       {
-        warning: 'Line contains encoded password',
+        message: 'Line contains encoded password',
         lineNumber: 1,
-        columnNumber: 7
+        startColumnNumber: 7,
+        endColumnNumber: 15,
+        severity: Severity.Error
       },
       {
-        warning: 'Line contains encoded password',
+        message: 'Line contains encoded password',
         lineNumber: 1,
-        columnNumber: 16
+        startColumnNumber: 16,
+        endColumnNumber: 24,
+        severity: Severity.Error
       }
     ])
   })

src/rules/noEncodedPasswords.ts

@@ -1,17 +1,20 @@
 import { LineLintRule } from '../types/LintRule'
 import { LintRuleType } from '../types/LintRuleType'
+import { Severity } from '../types/Severity'
 
 const name = 'noEncodedPasswords'
 const description = 'Disallow encoded passwords in SAS code.'
-const warning = 'Line contains encoded password'
+const message = 'Line contains encoded password'
 const test = (value: string, lineNumber: number) => {
   const regex = new RegExp(/{sas(\d{2,4}|enc)}[^;"'\s]*/, 'gi')
   const matches = value.match(regex)
   if (!matches || !matches.length) return []
   return matches.map((match) => ({
-    warning,
+    message,
     lineNumber,
-    columnNumber: value.indexOf(match) + 1
+    startColumnNumber: value.indexOf(match) + 1,
+    endColumnNumber: value.indexOf(match) + match.length + 1,
+    severity: Severity.Error
   }))
 }
 
@@ -22,6 +25,6 @@ export const noEncodedPasswords: LineLintRule = {
   type: LintRuleType.Line,
   name,
   description,
-  warning,
+  message,
   test
 }

src/rules/noSpacesInFileNames.spec.ts

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

src/rules/noSpacesInFileNames.ts

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

src/rules/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/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/noTrailingSpaces.spec.ts

@@ -1,3 +1,4 @@
+import { Severity } from '../types/Severity'
 import { noTrailingSpaces } from './noTrailingSpaces'
 
 describe('noTrailingSpaces', () => {
@@ -10,9 +11,11 @@ describe('noTrailingSpaces', () => {
     const line = "%put 'hello';  "
     expect(noTrailingSpaces.test(line, 1)).toEqual([
       {
-        warning: 'Line contains trailing spaces',
+        message: 'Line contains trailing spaces',
         lineNumber: 1,
-        columnNumber: 14
+        startColumnNumber: 14,
+        endColumnNumber: 15,
+        severity: Severity.Warning
       }
     ])
   })

src/rules/noTrailingSpaces.ts

@@ -1,13 +1,22 @@
 import { LineLintRule } from '../types/LintRule'
 import { LintRuleType } from '../types/LintRuleType'
+import { Severity } from '../types/Severity'
 
 const name = 'noTrailingSpaces'
 const description = 'Disallow trailing spaces on lines.'
-const warning = 'Line contains trailing spaces'
+const message = 'Line contains trailing spaces'
 const test = (value: string, lineNumber: number) =>
   value.trimEnd() === value
     ? []
-    : [{ warning, lineNumber, columnNumber: value.trimEnd().length + 1 }]
+    : [
+        {
+          message,
+          lineNumber,
+          startColumnNumber: value.trimEnd().length + 1,
+          endColumnNumber: value.length,
+          severity: Severity.Warning
+        }
+      ]
 
 /**
  * Lint rule that checks for the presence of trailing space(s) in a given line of text.
@@ -16,6 +25,6 @@ export const noTrailingSpaces: LineLintRule = {
   type: LintRuleType.Line,
   name,
   description,
-  warning,
+  message,
   test
 }

src/types/Diagnostic.ts

@@ -1,8 +1,12 @@
+import { Severity } from './Severity'
+
 /**
  * A diagnostic is produced by the execution of a lint rule against a file or line of text.
  */
 export interface Diagnostic {
   lineNumber: number
-  columnNumber: number
-  warning: string
+  startColumnNumber: number
+  endColumnNumber: number
+  message: string
+  severity: Severity
 }

src/types/LintConfig.spec.ts

@@ -40,22 +40,74 @@ 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 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
     })
 
     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(2)
     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.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,13 @@
 import { hasDoxygenHeader } from '../rules/hasDoxygenHeader'
+import { indentationMultiple } from '../rules/indentationMultiple'
+import { lowerCaseFileNames } from '../rules/lowerCaseFileNames'
+import { maxLineLength } from '../rules/maxLineLength'
 import { noEncodedPasswords } from '../rules/noEncodedPasswords'
+import { noSpacesInFileNames } from '../rules/noSpacesInFileNames'
+import { noTabIndentation } from '../rules/noTabIndentation'
 import { noTrailingSpaces } from '../rules/noTrailingSpaces'
-import { FileLintRule, LineLintRule } from './LintRule'
+import { hasMacroNameInMend } from '../rules/hasMacroNameInMend'
+import { FileLintRule, LineLintRule, PathLintRule } from './LintRule'
 
 /**
  * LintConfig is the logical representation of the .sasjslint file.
@@ -13,6 +19,9 @@ import { FileLintRule, LineLintRule } from './LintRule'
 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) {
@@ -23,8 +32,34 @@ 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)
     }
+
+    if (json?.noSpacesInFileNames) {
+      this.pathLintRules.push(noSpacesInFileNames)
+    }
+
+    if (json?.lowerCaseFileNames) {
+      this.pathLintRules.push(lowerCaseFileNames)
+    }
+
+    if (json?.hasMacroNameInMend) {
+      this.fileLintRules.push(hasMacroNameInMend)
+    }
   }
 }

src/types/LintRule.ts

@@ -1,16 +1,16 @@
 import { Diagnostic } from './Diagnostic'
+import { LintConfig } from './LintConfig'
 import { LintRuleType } from './LintRuleType'
 
 /**
- * A lint rule is defined by a type, name, description, warning text and a test function.
+ * A lint rule is defined by a type, name, description, message text and a test function.
  * The test function produces a set of diagnostics when executed.
  */
 export interface LintRule {
   type: LintRuleType
   name: string
   description: string
-  warning: string
-  test: (value: string, lineNumber: number) => Diagnostic[]
+  message: string
 }
 
 /**
@@ -18,6 +18,7 @@ export interface LintRule {
  */
 export interface LineLintRule extends LintRule {
   type: LintRuleType.Line
+  test: (value: string, lineNumber: number, config?: LintConfig) => Diagnostic[]
 }
 
 /**
@@ -27,3 +28,11 @@ export interface FileLintRule extends LintRule {
   type: LintRuleType.File
   test: (value: string) => Diagnostic[]
 }
+
+/**
+ * A PathLintRule is run once per file.
+ */
+export interface PathLintRule extends LintRule {
+  type: LintRuleType.Path
+  test: (value: string) => Diagnostic[]
+}

src/types/LintRuleType.ts

@@ -4,5 +4,6 @@
  */
 export enum LintRuleType {
   Line,
-  File
+  File,
+  Path
 }

src/types/Process.d.ts

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

src/types/Severity.ts

@@ -0,0 +1,8 @@
+/**
+ * Severity indicates the seriousness of a given violation.
+ */
+export enum Severity {
+  Info,
+  Warning,
+  Error
+}

src/types/index.ts

@@ -0,0 +1,5 @@
+export * from './Diagnostic'
+export * from './LintConfig'
+export * from './LintRule'
+export * from './LintRuleType'
+export * from './Severity'

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,8 @@
+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/getLintConfig.spec.ts

@@ -1,3 +1,4 @@
+import * as fileModule from '@sasjs/utils/file'
 import { LintConfig } from '../types/LintConfig'
 import { getLintConfig } from './getLintConfig'
 
@@ -7,4 +8,17 @@ describe('getLintConfig', () => {
 
     expect(config).toBeInstanceOf(LintConfig)
   })
+
+  it('should get the default config when a .sasjslint file is unavailable', async () => {
+    jest
+      .spyOn(fileModule, 'readFile')
+      .mockImplementationOnce(() => Promise.reject())
+
+    const config = await getLintConfig()
+
+    expect(config).toBeInstanceOf(LintConfig)
+    expect(config.fileLintRules.length).toEqual(1)
+    expect(config.lineLintRules.length).toEqual(5)
+    expect(config.pathLintRules.length).toEqual(2)
+  })
 })

src/utils/getLintConfig.ts

@@ -3,22 +3,32 @@ 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: false
 }
+
 /**
  * Fetches the config from the .sasjslint file and creates a LintConfig object.
+ * Returns the default configuration when a .sasjslint file is unavailable.
  * @returns {Promise<LintConfig>} resolves with an object representing the current lint configuration.
  */
 export async function getLintConfig(): Promise<LintConfig> {
   const projectRoot = await getProjectRoot()
   const configuration = await readFile(
     path.join(projectRoot, '.sasjslint')
-  ).catch((e) => {
-    console.error('Error reading .sasjslint file', e)
-    return JSON.stringify(defaultConfiguration)
+  ).catch((_) => {
+    return JSON.stringify(DefaultLintConfiguration)
   })
   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,6 @@
+import { listFilesInFolder } from '@sasjs/utils/file'
+
+export const listSasFiles = async (folderPath: string): Promise<string[]> => {
+  const files = await listFilesInFolder(folderPath)
+  return files.filter((f) => f.endsWith('.sas'))
+}

tsconfig.json

@@ -7,6 +7,7 @@
       ],
       "target": "es5",
       "module": "commonjs",
+      "downlevelIteration": true,
       "moduleResolution": "node",
       "esModuleInterop": true,
       "declaration": true,
@@ -19,6 +20,7 @@
   ],
   "exclude": [
       "node_modules",
-      "**/*.spec.ts"
+      "**/*.spec.ts",
+      "**/example.ts"
   ]
 }