Merge pull request #21 from sasjs/issue-12

feat: new rule hasMacroNameInMend

.sasjslint

@@ -6,5 +6,6 @@
     "maxLineLength": 80,
     "lowerCaseFileNames": true,
     "noTabIndentation": true,
-    "indentationMultiple": 2
+    "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"
   }
 }

src/index.ts

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

src/lint.spec.ts

@@ -1,158 +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(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
-    })
-  })
-})
-
-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, config))
-  })
-
-  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,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

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

@@ -11,7 +11,7 @@ const test = (value: string, lineNumber: number, config?: LintConfig) => {
 
   const indentationMultiple = isNaN(config?.indentationMultiple as number)
     ? 2
-    : config?.indentationMultiple
+    : config!.indentationMultiple
 
   if (indentationMultiple === 0) return []
   const numberOfSpaces = value.search(/\S|$/)

src/types/LintConfig.spec.ts

@@ -40,6 +40,24 @@ 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 })
 
@@ -58,18 +76,38 @@ describe('LintConfig', () => {
     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

@@ -6,6 +6,7 @@ import { noEncodedPasswords } from '../rules/noEncodedPasswords'
 import { noSpacesInFileNames } from '../rules/noSpacesInFileNames'
 import { noTabIndentation } from '../rules/noTabIndentation'
 import { noTrailingSpaces } from '../rules/noTrailingSpaces'
+import { hasMacroNameInMend } from '../rules/hasMacroNameInMend'
 import { FileLintRule, LineLintRule, PathLintRule } from './LintRule'
 
 /**
@@ -56,5 +57,9 @@ export class LintConfig {
     if (json?.lowerCaseFileNames) {
       this.pathLintRules.push(lowerCaseFileNames)
     }
+
+    if (json?.hasMacroNameInMend) {
+      this.fileLintRules.push(hasMacroNameInMend)
+    }
   }
 }

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

@@ -14,7 +14,8 @@ export const DefaultLintConfiguration = {
   lowerCaseFileNames: true,
   maxLineLength: 80,
   noTabIndentation: true,
-  indentationMultiple: 2
+  indentationMultiple: 2,
+  hasMacroNameInMend: false
 }
 
 /**

src/utils/index.ts

@@ -1,2 +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,