Merge pull request #195 from sasjs/issue-140

fix: update regex to handle single quotes in macro options

.all-contributorsrc

@@ -0,0 +1,113 @@
+{
+  "files": [
+    "README.md"
+  ],
+  "imageSize": 100,
+  "commit": false,
+  "contributors": [
+    {
+      "login": "Carus11",
+      "name": "Carus Kyle",
+      "avatar_url": "https://avatars.githubusercontent.com/u/4925828?v=4",
+      "profile": "https://github.com/Carus11",
+      "contributions": [
+        "ideas"
+      ]
+    },
+    {
+      "login": "allanbowe",
+      "name": "Allan Bowe",
+      "avatar_url": "https://avatars.githubusercontent.com/u/4420615?v=4",
+      "profile": "https://github.com/allanbowe",
+      "contributions": [
+        "code",
+        "test",
+        "review",
+        "video",
+        "doc"
+      ]
+    },
+    {
+      "login": "YuryShkoda",
+      "name": "Yury Shkoda",
+      "avatar_url": "https://avatars.githubusercontent.com/u/25773492?v=4",
+      "profile": "https://www.erudicat.com/",
+      "contributions": [
+        "code",
+        "test",
+        "projectManagement",
+        "video",
+        "doc"
+      ]
+    },
+    {
+      "login": "krishna-acondy",
+      "name": "Krishna Acondy",
+      "avatar_url": "https://avatars.githubusercontent.com/u/2980428?v=4",
+      "profile": "https://krishna-acondy.io/",
+      "contributions": [
+        "code",
+        "test",
+        "review",
+        "infra",
+        "platform",
+        "maintenance",
+        "content"
+      ]
+    },
+    {
+      "login": "saadjutt01",
+      "name": "Muhammad Saad ",
+      "avatar_url": "https://avatars.githubusercontent.com/u/8914650?v=4",
+      "profile": "https://github.com/saadjutt01",
+      "contributions": [
+        "code",
+        "test",
+        "review",
+        "mentoring",
+        "doc"
+      ]
+    },
+    {
+      "login": "sabhas",
+      "name": "Sabir Hassan",
+      "avatar_url": "https://avatars.githubusercontent.com/u/82647447?v=4",
+      "profile": "https://github.com/sabhas",
+      "contributions": [
+        "code",
+        "test",
+        "review",
+        "ideas"
+      ]
+    },
+    {
+      "login": "medjedovicm",
+      "name": "Mihajlo Medjedovic",
+      "avatar_url": "https://avatars.githubusercontent.com/u/18329105?v=4",
+      "profile": "https://github.com/medjedovicm",
+      "contributions": [
+        "code",
+        "test",
+        "review",
+        "infra"
+      ]
+    },
+    {
+      "login": "VladislavParhomchik",
+      "name": "Vladislav Parhomchik",
+      "avatar_url": "https://avatars.githubusercontent.com/u/83717836?v=4",
+      "profile": "https://github.com/VladislavParhomchik",
+      "contributions": [
+        "test",
+        "review"
+      ]
+    }
+  ],
+  "contributorsPerLine": 7,
+  "projectName": "lint",
+  "projectOwner": "sasjs",
+  "repoType": "github",
+  "repoHost": "https://github.com",
+  "skipCi": true,
+  "commitConvention": "none"
+}

.git-hooks/commit-msg

@@ -0,0 +1,18 @@
+#!/bin/sh
+RED="\033[1;31m"
+GREEN="\033[1;32m"
+
+# Get the commit message (the parameter we're given is just the path to the
+# temporary file which holds the message).
+commit_message=$(cat "$1")
+
+if (echo "$commit_message" | grep -Eq "^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\([a-z \-]+\))?!?: .+$") then
+   echo "${GREEN} ✔ Commit message meets Conventional Commit standards"
+   exit 0
+fi
+
+echo "${RED}❌ Commit message does not meet the Conventional Commit standard!"
+echo "An example of a valid message is:"
+echo "  feat(login): add the 'remember me' button"
+echo "ℹ More details at: https://www.conventionalcommits.org/en/v1.0.0/#summary"
+exit 1

.github/CONTRIBUTING.md

@@ -0,0 +1,54 @@
+# Contributing
+
+Contributions to `@sasjs/lint` are very welcome!
+Please fill in the pull request template and make sure that your code changes are adequately covered with tests when making a PR.
+
+## Architecture
+
+This project implements a number of rules for SAS projects and code. There are three types of rules:
+
+* File rules - rules applied at the file level
+* Line rules - rules applied to each line of a file 
+* Path rules - rules applied to paths and file names
+
+When implementing a new rule, place it in the appropriate folder for its type.
+Please also make sure to export it from the `index.ts` file in that folder.
+
+The file for each rule typically exports an object that conforms to the `LintRule` interface.
+This means it will have a `type`, `name`, `description` and `message` at a minimum.
+
+File, line and path lint rules also have a `test` property.
+This is a function that will run a piece of logic against the supplied item and produce an array of `Diagnostic` objects.
+These objects can be used in the consuming application to display the problems in the code.
+
+With some lint rules, we can also write logic that can automatically fix the issues found.
+These rules will also have a `fix` property, which is a function that takes the original content -
+either a line or the entire contents of a file, and returns the transformed content with the fix applied.
+
+## Testing
+
+Testing is one of the most important steps when developing a new lint rule.
+It helps us ensure that our lint rules do what they are intended to do.
+
+We use `jest` for testing, and since most of the code is based on pure functions, there is little mocking to do.
+This makes `@sasjs/lint` very easy to unit test, and so there is no excuse for not testing a new rule. :)
+
+When adding a new rule, please make sure that all positive and negative scenarios are tested in separate test cases.
+When modifying an existing rule, ensure that your changes haven't affected existing functionality by running the tests on your machine.
+
+You can run the tests using `npm test`.
+
+## Code Style
+
+This repository uses `Prettier` to ensure a uniform code style.
+If you are using VS Code for development, you can automatically fix your code to match the style as follows:
+
+- Install the `Prettier` extension for VS Code.
+- Open your `settings.json` file by choosing 'Preferences: Open Settings (JSON)' from the command palette.
+- Add the following items to the JSON.
+  ```
+    "editor.formatOnSave": true,
+    "editor.formatOnPaste": true,
+  ```
+
+If you are using another editor, or are unable to install the extension, you can run `npm run lint:fix` to fix the formatting after you've made your changes.

.github/PULL_REQUEST_TEMPLATE.md

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

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+  - package-ecosystem: npm
+    directory: '/'
+    schedule:
+      interval: monthly
+    open-pull-requests-limit: 10

.github/workflows/build.yml

@@ -13,14 +13,15 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [12.x]
+        node-version: [lts/*]
 
     steps:
       - uses: actions/checkout@v2
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v2
         with:
           node-version: ${{ matrix.node-version }}
+          cache: npm
       - name: Install Dependencies
         run: npm ci
       - name: Check Code Style

.gitpod.yml

@@ -0,0 +1,8 @@
+# This configuration file was automatically generated by Gitpod.
+# Please adjust to your needs (see https://www.gitpod.io/docs/config-gitpod-file)
+# and commit this file to your remote git repository to share the goodness with others.
+
+tasks:
+  - init: npm install && npm run build
+
+

.sasjslint

@@ -7,5 +7,7 @@
     "lowerCaseFileNames": true,
     "noTabIndentation": true,
     "indentationMultiple": 2,
-    "hasMacroNameInMend": false
+    "hasMacroNameInMend": true,
+    "noNestedMacros": true,
+    "hasMacroParentheses": true
 }

README.md

@@ -1,112 +1,253 @@
+![GitHub top language](https://img.shields.io/github/languages/top/sasjs/lint)
+[![GitHub closed issues](https://img.shields.io/github/issues-closed-raw/sasjs/lint)](https://github.com/sasjs/lint/issues?q=is%3Aissue+is%3Aclosed)
+[![GitHub issues](https://img.shields.io/github/issues-raw/sasjs/lint)](https://github.com/sasjs/lint/issues)
+![total lines](https://tokei.rs/b1/github/sasjs/lint)
+[![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-908a85?logo=gitpod)](https://gitpod.io/#https://github.com/sasjs/lint)
+
 # 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
+# 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/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.
+- [@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,
+  "noEncodedPasswords": true,
-    "hasDoxygenHeader": true,
+  "hasDoxygenHeader": true,
-    "indentationMultiple": 2,
+  "hasMacroNameInMend": true,
-    "lowerCaseFileNames": true,
+  "hasMacroParentheses": true,
-    "maxLineLength": 80,
+  "ignoreList": ["sajsbuild/", "sasjsresults/"],
-    "noSpacesInFileNames": true,
+  "indentationMultiple": 2,
-    "noTabIndentation": true,
+  "lowerCaseFileNames": true,
-    "noTrailingSpaces": true
+  "maxLineLength": 80,
+  "noNestedMacros": true,
+  "noGremlins": true,
+  "noSpacesInFileNames": true,
+  "noTabs": true,
+  "noTrailingSpaces": true,
+  "defaultHeader": "/**{lineEnding}  @file{lineEnding}  @brief <Your brief here>{lineEnding}  <h4> SAS Macros </h4>{lineEnding}**/"
 }
 ```
 
-### SAS Lint Settings
+## SAS Lint Settings
 
-#### noEncodedPasswords
+Each setting can have three states:
 
-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.
+- OFF - usually by setting the value to `false` or 0. In this case, the rule won't be executed.
+- WARN - a warning is written to the log, but the return code will be 0
+- ERROR - an error is written to the log, and the return code is 1
 
-Severity: ERROR
+For more details, and the default state, see the description of each rule below. It is also possible to change whether a rule returns ERROR or WARN using the `severityLevels` object.
 
-#### hasDoxygenHeader
+### defaultHeader
-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
+This isn't actually a rule - but rather a formatting setting, which applies to SAS program that do NOT begin with `/**`. It can be triggered by running `sasjs lint fix` in the SASjs CLI, or by hitting "save" when using the SASjs VS Code extension (with "formatOnSave" in place)
+
+The default header is as follows:
+
+```sas
+/**
+  @file
+  @brief <Your brief here>
+  <h4> SAS Macros </h4>
+**/
+```
+
+If creating a new value, use `{lineEnding}` instead of `\n`, eg as follows:
+
+```json
+{
+  "defaultHeader": "/**{lineEnding}  @file{lineEnding}  @brief Our Company Brief{lineEnding}**/"
+}
+```
+
+### noEncodedPasswords
+
+This rule will highlight any rows that contain a `{sas00X}` type password, or `{sasenc}`. These passwords (especially 001 and 002) are NOT secure, and should NEVER be pushed to source control or saved to the filesystem without special permissions applied.
+
+- Default: true
+- Severity: ERROR
+
+### hasDoxygenHeader
+
+The SASjs framework recommends the use of Doxygen headers for describing all types of SAS program. This check will identify files where a doxygen header does not begin in the first line.
+
+- Default: true
+- Severity: WARNING
+
+### hasMacroNameInMend
+
+The addition of the macro name in the `%mend` statement is optional, but can approve readability in large programs. A discussion on this topic can be found [here](https://www.linkedin.com/posts/allanbowe_sas-sasapps-sasjs-activity-6783413360781266945-1-7m). The default setting was the result of a poll with over 300 votes.
+
+- Default: true
+- Severity: WARNING
+
+### hasMacroParentheses
+
+As per the example [here](https://github.com/sasjs/lint/issues/20), macros defined without parentheses cause problems if that macro is ever extended (it's not possible to reliably extend that macro without potentially breaking some code that has used the macro). It's better to always define parentheses, even if they are not used. This check will also throw a warning if there are spaces between the macro name and the opening parenthesis.
+
+- Default: true
+- Severity: WARNING
+
+### ignoreList
+
+There may be specific files (or folders) that are not good candidates for linting. Simply list them in this array and they will be ignored. In addition, any files in the project `.gitignore` file will also be ignored.
+
+### indentationMultiple
 
-#### indentationMultiple
 This will check each line to ensure that the count of leading spaces can be divided cleanly by this multiple.
 
-Severity: WARNING
+- Default: 2
+- Severity: WARNING
 
-#### lowerCaseFileNames
+### 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
+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.
 
-#### maxLineLength
+- Default: true
-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).  
+- Severity: WARNING
-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.
+### maxLineLength
 
-Severity: WARNING
+Code becomes far more readable when line lengths are short. The most compelling reason for short line lengths is to avoid the need to scroll when performing a side-by-side 'compare' between two files (eg as part of a GIT feature branch review). A longer discussion on optimal code line length can be found [here](https://stackoverflow.com/questions/578059/studies-on-optimal-code-width)
+
+In batch mode, long SAS code lines may also be truncated, causing hard-to-detect errors.
+
+We strongly recommend a line length limit, and set the bar at 80. To turn this feature off, set the value to 0.
+
+- Default: 80
+- Severity: WARNING
+
+### noGremlins
+
+Capture zero-width whitespace and other non-standard characters.  The logic is borrowed from the [VSCode Gremlins Extension](https://github.com/nhoizey/vscode-gremlins) - if you are looking for more advanced gremlin zapping capabilities, we highly recommend to use their extension instead.
+
+The list of characters can be found in this file: [https://github.com/sasjs/lint/blob/main/src/utils/gremlinCharacters.ts](https://github.com/sasjs/lint/blob/main/src/utils/gremlinCharacters.ts)
+
+- Default: true
+- Severity: WARNING
+
+### noNestedMacros
+
+Where macros are defined inside other macros, they are recompiled every time the outer macro is invoked. Hence, it is widely considered inefficient, and bad practice, to nest macro definitions.
+
+- Default: true
+- Severity: WARNING
+
+### noSpacesInFileNames
 
-#### 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
+- 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
+- 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.
+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
+- Default: true
+- Severity: WARNING
 
-#### noTabIndentation
+### noTabs
-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
+Whilst there are some arguments for using tabs (such as the ability to set your own indentation width, and to reduce character count) there are many, many, many developers who think otherwise. We're in that camp. Sorry (not sorry).
 
-#### noTrailingSpaces
+- Alias: noTabIndentation
-This will highlight lines with trailing spaces.  Trailing spaces serve no useful purpose in a SAS program.
+- Default: true
+- Severity: WARNING
 
-severity: WARNING
+### noTrailingSpaces
 
-### Upcoming Linting Rules:
+This will highlight lines with trailing spaces. Trailing spaces serve no useful purpose in a SAS program.
 
-* `noTabs` -> does what it says on the tin 
+- Default: true
-* `noGremlins` -> identifies all invisible characters, other than spaces / tabs / line endings.  If you really need that bell character, use a hex literal!
+- severity: WARNING
-* `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
+## severityLevel
+
+This setting allows the default severity to be adjusted. This is helpful when running the lint in a pipeline or git hook. Simply list the rules you would like to adjust along with the desired setting ("warn" or "error"), eg as follows:
+
+```json
+{
+  "noTrailingSpaces": true,
+  "hasDoxygenHeader": true,
+  "maxLineLength": 100,
+  "severityLevel": {
+    "hasDoxygenHeader": "warn",
+    "maxLineLength": "error",
+    "noTrailingSpaces": "error"
+  }
+}
+```
+
+- "warn" - show warning in the log (doesn’t affect exit code)
+- "error" - show error in the log (exit code is 1 when triggered)
+
+## Upcoming Linting Rules:
+
+- `noGremlins` -> identifies all invisible characters, other than spaces / tabs / line endings. If you really need that bell character, use a hex literal!
+- `lineEndings` -> set a standard line ending, such as LF or CRLF
+
+# SAS Formatter
 
 A formatter will automatically apply rules when you hit SAVE, which can save a LOT of time.
 
+We've already implemented the following rules:
+
+- Add the macro name to the %mend statement
+- Add a doxygen header template if none exists
+- Remove trailing spaces
+
 We're looking to implement the following rules:
 
-* Remove trailing spaces
+- Change tabs to spaces
-* Change tabs to spaces 
+- zap gremlins
-* Add the macro name to the %mend statement 
+- fix line endings
-* Add a doxygen header template if none exists 
 
-Later we will investigate some harder stuff, such as automatic indentation and code layout
+We are also investigating some harder stuff, such as automatic indentation and code layout
 
-## Sponsorship & Contributions
+# 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?
+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
+# Contributors ✨
 
-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.
+<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
 
-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.
+[![All Contributors](https://img.shields.io/badge/all_contributors-8-orange.svg?style=flat-square)](#contributors-)
 
-Contact [Allan Bowe](https://www.linkedin.com/in/allanbowe/) for further details.
+<!-- ALL-CONTRIBUTORS-BADGE:END -->
 
+Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
 
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- prettier-ignore-start -->
+<!-- markdownlint-disable -->
+<table>
+  <tr>
+    <td align="center"><a href="https://github.com/Carus11"><img src="https://avatars.githubusercontent.com/u/4925828?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Carus Kyle</b></sub></a><br /><a href="#ideas-Carus11" title="Ideas, Planning, & Feedback">🤔</a></td>
+    <td align="center"><a href="https://github.com/allanbowe"><img src="https://avatars.githubusercontent.com/u/4420615?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Allan Bowe</b></sub></a><br /><a href="https://github.com/sasjs/lint/commits?author=allanbowe" title="Code">💻</a> <a href="https://github.com/sasjs/lint/commits?author=allanbowe" title="Tests">⚠️</a> <a href="https://github.com/sasjs/lint/pulls?q=is%3Apr+reviewed-by%3Aallanbowe" title="Reviewed Pull Requests">👀</a> <a href="#video-allanbowe" title="Videos">📹</a> <a href="https://github.com/sasjs/lint/commits?author=allanbowe" title="Documentation">📖</a></td>
+    <td align="center"><a href="https://www.erudicat.com/"><img src="https://avatars.githubusercontent.com/u/25773492?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Yury Shkoda</b></sub></a><br /><a href="https://github.com/sasjs/lint/commits?author=YuryShkoda" title="Code">💻</a> <a href="https://github.com/sasjs/lint/commits?author=YuryShkoda" title="Tests">⚠️</a> <a href="#projectManagement-YuryShkoda" title="Project Management">📆</a> <a href="#video-YuryShkoda" title="Videos">📹</a> <a href="https://github.com/sasjs/lint/commits?author=YuryShkoda" title="Documentation">📖</a></td>
+    <td align="center"><a href="https://krishna-acondy.io/"><img src="https://avatars.githubusercontent.com/u/2980428?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Krishna Acondy</b></sub></a><br /><a href="https://github.com/sasjs/lint/commits?author=krishna-acondy" title="Code">💻</a> <a href="https://github.com/sasjs/lint/commits?author=krishna-acondy" title="Tests">⚠️</a> <a href="https://github.com/sasjs/lint/pulls?q=is%3Apr+reviewed-by%3Akrishna-acondy" title="Reviewed Pull Requests">👀</a> <a href="#infra-krishna-acondy" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="#platform-krishna-acondy" title="Packaging/porting to new platform">📦</a> <a href="#maintenance-krishna-acondy" title="Maintenance">🚧</a> <a href="#content-krishna-acondy" title="Content">🖋</a></td>
+    <td align="center"><a href="https://github.com/saadjutt01"><img src="https://avatars.githubusercontent.com/u/8914650?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Muhammad Saad </b></sub></a><br /><a href="https://github.com/sasjs/lint/commits?author=saadjutt01" title="Code">💻</a> <a href="https://github.com/sasjs/lint/commits?author=saadjutt01" title="Tests">⚠️</a> <a href="https://github.com/sasjs/lint/pulls?q=is%3Apr+reviewed-by%3Asaadjutt01" title="Reviewed Pull Requests">👀</a> <a href="#mentoring-saadjutt01" title="Mentoring">🧑‍🏫</a> <a href="https://github.com/sasjs/lint/commits?author=saadjutt01" title="Documentation">📖</a></td>
+    <td align="center"><a href="https://github.com/sabhas"><img src="https://avatars.githubusercontent.com/u/82647447?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Sabir Hassan</b></sub></a><br /><a href="https://github.com/sasjs/lint/commits?author=sabhas" title="Code">💻</a> <a href="https://github.com/sasjs/lint/commits?author=sabhas" title="Tests">⚠️</a> <a href="https://github.com/sasjs/lint/pulls?q=is%3Apr+reviewed-by%3Asabhas" title="Reviewed Pull Requests">👀</a> <a href="#ideas-sabhas" title="Ideas, Planning, & Feedback">🤔</a></td>
+    <td align="center"><a href="https://github.com/medjedovicm"><img src="https://avatars.githubusercontent.com/u/18329105?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mihajlo Medjedovic</b></sub></a><br /><a href="https://github.com/sasjs/lint/commits?author=medjedovicm" title="Code">💻</a> <a href="https://github.com/sasjs/lint/commits?author=medjedovicm" title="Tests">⚠️</a> <a href="https://github.com/sasjs/lint/pulls?q=is%3Apr+reviewed-by%3Amedjedovicm" title="Reviewed Pull Requests">👀</a> <a href="#infra-medjedovicm" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
+  </tr>
+  <tr>
+    <td align="center"><a href="https://github.com/VladislavParhomchik"><img src="https://avatars.githubusercontent.com/u/83717836?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Vladislav Parhomchik</b></sub></a><br /><a href="https://github.com/sasjs/lint/commits?author=VladislavParhomchik" title="Tests">⚠️</a> <a href="https://github.com/sasjs/lint/pulls?q=is%3Apr+reviewed-by%3AVladislavParhomchik" title="Reviewed Pull Requests">👀</a></td>
+  </tr>
+</table>
+
+<!-- markdownlint-restore -->
+<!-- prettier-ignore-end -->
+
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

checkNodeVersion.js

@@ -0,0 +1,16 @@
+const result = process.versions
+if (result && result.node) {
+  if (parseInt(result.node) < 14) {
+    console.log(
+      '\x1b[31m%s\x1b[0m',
+      `❌ Process failed due to Node Version,\nPlease install and use Node Version >= 14\nYour current Node Version is: ${result.node}`
+    )
+    process.exit(1)
+  }
+} else {
+  console.log(
+    '\x1b[31m%s\x1b[0m',
+    'Something went wrong while checking Node version'
+  )
+  process.exit(1)
+}

jest.config.js

@@ -9,5 +9,5 @@ module.exports = {
       statements: -10
     }
   },
-  collectCoverageFrom: ['src/**/{!(index|example),}.ts']
+  collectCoverageFrom: ['src/**/{!(index|formatExample|lintExample),}.ts']
 }

package.json

@@ -4,11 +4,14 @@
   "scripts": {
     "test": "jest --coverage",
     "build": "rimraf build && tsc",
+    "preinstall": "node checkNodeVersion",
+    "prebuild": "node checkNodeVersion",
     "prepublishOnly": "cp -r ./build/* . && rm -rf ./build && rm -rf ./src && rm tsconfig.json",
     "postpublish": "git clean -fd",
-    "package:lib": "npm run build && cp ./package.json build && cp README.md build && cd build && npm version \"5.0.0\" && npm pack",
+    "package:lib": "npm run build && cp ./package.json ./checkNodeVersion.js build && cp README.md build && cd build && npm version \"5.0.0\" && npm pack",
-    "lint:fix": "npx prettier --write '{src,test}/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}'",
+    "lint:fix": "npx prettier --write \"{src,test}/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\"",
-    "lint": "npx prettier --check '{src,test}/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}'"
+    "lint": "npx prettier --check \"{src,test}/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\"",
+    "prepare": "git rev-parse --git-dir && git config core.hooksPath ./.git-hooks || true"
   },
   "publishConfig": {
     "access": "public"
@@ -36,14 +39,16 @@
   },
   "homepage": "https://github.com/sasjs/lint#readme",
   "devDependencies": {
-    "@types/jest": "^26.0.21",
+    "@types/jest": "^26.0.23",
-    "@types/node": "^14.14.35",
+    "@types/node": "^15.12.2",
+    "all-contributors-cli": "^6.20.0",
     "jest": "^26.6.3",
     "rimraf": "^3.0.2",
-    "ts-jest": "^26.5.4",
+    "ts-jest": "^26.5.6",
-    "typescript": "^4.2.3"
+    "typescript": "^4.3.2"
   },
   "dependencies": {
-    "@sasjs/utils": "^2.10.1"
+    "@sasjs/utils": "^2.19.0",
+    "ignore": "^5.2.0"
   }
 }

sasjslint-schema.json

@@ -5,14 +5,22 @@
   "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,
+    "defaultHeader": "/**{lineEnding}  @file{lineEnding}  @brief <Your brief here>{lineEnding}  <h4> SAS Macros </h4>{lineEnding}**/",
+    "hasMacroNameInMend": false,
+    "hasMacroParentheses": true,
+    "indentationMultiple": 2,
     "lowerCaseFileNames": true,
     "maxLineLength": 80,
-    "noTabIndentation": true,
+    "noGremlins": true,
-    "indentationMultiple": 2
+    "noNestedMacros": true,
+    "noSpacesInFileNames": true,
+    "noTabs": true,
+    "noTrailingSpaces": true,
+    "lineEndings": "lf",
+    "strictMacroDefinition": true,
+    "ignoreList": ["sajsbuild", "sasjsresults"]
   },
   "examples": [
     {
@@ -22,19 +30,18 @@
       "noSpacesInFileNames": true,
       "lowerCaseFileNames": true,
       "maxLineLength": 80,
-      "noTabIndentation": true,
+      "noGremlins": true,
-      "indentationMultiple": 4
+      "noTabs": true,
+      "indentationMultiple": 4,
+      "hasMacroNameInMend": true,
+      "noNestedMacros": true,
+      "hasMacroParentheses": true,
+      "lineEndings": "crlf",
+      "strictMacroDefinition": true,
+      "ignoreList": ["sajsbuild", "sasjsresults"]
     }
   ],
   "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",
@@ -51,14 +58,46 @@
       "default": true,
       "examples": [true, false]
     },
-    "noSpacesInFileNames": {
+    "defaultHeader": {
-      "$id": "#/properties/noSpacesInFileNames",
+      "$id": "#/properties/defaultHeader",
+      "type": "string",
+      "title": "defaultHeader",
+      "description": "This sets the default program header - applies when a SAS program does NOT begin with `/**`.",
+      "default": "/**{lineEnding}  @file{lineEnding}  @brief <Your brief here>{lineEnding}  <h4> SAS Macros </h4>{lineEnding}**/",
+      "examples": []
+    },
+    "noGremlins": {
+      "$id": "#/properties/noGremlins",
       "type": "boolean",
-      "title": "noSpacesInFileNames",
+      "title": "noGremlins",
-      "description": "Enforces no spaces in file names. Shows a warning when they are present.",
+      "description": "Captures problematic characters such as zero-width whitespace and others that look valid but usually are not (such as the en dash)",
+      "default": [true],
+      "examples": [true, false]
+    },
+    "hasMacroNameInMend": {
+      "$id": "#/properties/hasMacroNameInMend",
+      "type": "boolean",
+      "title": "hasMacroNameInMend",
+      "description": "Enforces the presence of macro names in %mend statements. Shows a warning for %mend statements with missing or mismatched macro names.",
+      "default": false,
+      "examples": [true, false]
+    },
+    "hasMacroParentheses": {
+      "$id": "#/properties/hasMacroParentheses",
+      "type": "boolean",
+      "title": "hasMacroParentheses",
+      "description": "Enforces the presence of parentheses in macro definitions. Shows a warning for each macro defined without parentheses, or with spaces between the macro name and the opening parenthesis.",
       "default": true,
       "examples": [true, false]
     },
+    "indentationMultiple": {
+      "$id": "#/properties/indentationMultiple",
+      "type": "number",
+      "title": "indentationMultiple",
+      "description": "Enforces a configurable multiple for the number of spaces for indentation. Shows a warning for lines that are not indented by a multiple of this number.",
+      "default": 2,
+      "examples": [2, 3, 4]
+    },
     "lowerCaseFileNames": {
       "$id": "#/properties/lowerCaseFileNames",
       "type": "boolean",
@@ -75,21 +114,180 @@
       "default": 80,
       "examples": [60, 80, 120]
     },
-    "noTabIndentation": {
+    "noNestedMacros": {
-      "$id": "#/properties/noTabIndentation",
+      "$id": "#/properties/noNestedMacros",
       "type": "boolean",
-      "title": "noTabIndentation",
+      "title": "noNestedMacros",
-      "description": "Enforces no indentation using tabs. Shows a warning when a line starts with a tab.",
+      "description": "Enforces the absence of nested macro definitions. Shows a warning for each nested macro definition.",
       "default": true,
       "examples": [true, false]
     },
-    "indentationMultiple": {
+    "noSpacesInFileNames": {
-      "$id": "#/properties/indentationMultiple",
+      "$id": "#/properties/noSpacesInFileNames",
-      "type": "number",
+      "type": "boolean",
-      "title": "indentationMultiple",
+      "title": "noSpacesInFileNames",
-      "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.",
+      "description": "Enforces no spaces in file names. Shows a warning when they are present.",
-      "default": 2,
+      "default": true,
-      "examples": [2, 3, 4]
+      "examples": [true, false]
+    },
+    "noTabs": {
+      "$id": "#/properties/noTabs",
+      "type": "boolean",
+      "title": "noTabs",
+      "description": "Enforces no indentation using tabs. Shows a warning when a line contains a tab.",
+      "default": true,
+      "examples": [true, false]
+    },
+    "noTrailingSpaces": {
+      "$id": "#/properties/noTrailingSpaces",
+      "type": "boolean",
+      "title": "noTrailingSpaces",
+      "description": "Enforces no trailing spaces in lines of SAS code. Shows a warning when they are present.",
+      "default": true,
+      "examples": [true, false]
+    },
+    "lineEndings": {
+      "$id": "#/properties/lineEndings",
+      "type": "string",
+      "title": "lineEndings",
+      "description": "Enforces the configured terminating character for each line. Shows a warning when incorrect line endings are present.",
+      "default": "lf",
+      "examples": ["lf", "crlf"]
+    },
+    "strictMacroDefinition": {
+      "$id": "#/properties/strictMacroDefinition",
+      "type": "boolean",
+      "title": "strictMacroDefinition",
+      "description": "Enforces Macro Definition syntax. Shows a warning when incorrect syntax is used.",
+      "default": true,
+      "examples": [true, false]
+    },
+    "ignoreList": {
+      "$id": "#/properties/ignoreList",
+      "type": "array",
+      "title": "ignoreList",
+      "description": "An array of paths or path patterns to ignore when linting. Any files or matching patterns in the .gitignore file will also be ignored.",
+      "default": ["sasjsbuild/", "sasjsresults/"],
+      "examples": ["sasjs/tests", "tmp/scratch.sas"]
+    },
+    "severityLevel": {
+      "$id": "#/properties/severityLevel",
+      "type": "object",
+      "title": "severityLevel",
+      "description": "An object which specifies the severity level of each rule.",
+      "default": {},
+      "examples": [
+        {
+          "hasDoxygenHeader": "warn",
+          "maxLineLength": "warn",
+          "noTrailingSpaces": "error"
+        },
+        {
+          "hasDoxygenHeader": "warn",
+          "maxLineLength": "error",
+          "noTrailingSpaces": "error"
+        }
+      ],
+      "properties": {
+        "noEncodedPasswords": {
+          "$id": "#/properties/severityLevel/noEncodedPasswords",
+          "title": "noEncodedPasswords",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "error"
+        },
+        "hasDoxygenHeader": {
+          "$id": "#/properties/severityLevel/hasDoxygenHeader",
+          "title": "hasDoxygenHeader",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "noGremlins": {
+          "$id": "#/properties/severityLevel/noGremlins",
+          "title": "noGremlins",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "hasMacroNameInMend": {
+          "$id": "#/properties/severityLevel/hasMacroNameInMend",
+          "title": "hasMacroNameInMend",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "hasMacroParentheses": {
+          "$id": "#/properties/severityLevel/hasMacroParentheses",
+          "title": "hasMacroParentheses",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "indentationMultiple": {
+          "$id": "#/properties/severityLevel/indentationMultiple",
+          "title": "indentationMultiple",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "lowerCaseFileNames": {
+          "$id": "#/properties/severityLevel/lowerCaseFileNames",
+          "title": "lowerCaseFileNames",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "maxLineLength": {
+          "$id": "#/properties/severityLevel/maxLineLength",
+          "title": "maxLineLength",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "noNestedMacros": {
+          "$id": "#/properties/severityLevel/noNestedMacros",
+          "title": "noNestedMacros",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "noSpacesInFileNames": {
+          "$id": "#/properties/severityLevel/noSpacesInFileNames",
+          "title": "noSpacesInFileNames",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "noTabs": {
+          "$id": "#/properties/severityLevel/noTabs",
+          "title": "noTabs",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "noTrailingSpaces": {
+          "$id": "#/properties/severityLevel/noTrailingSpaces",
+          "title": "noTrailingSpaces",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "lineEndings": {
+          "$id": "#/properties/severityLevel/lineEndings",
+          "title": "lineEndings",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        },
+        "strictMacroDefinition": {
+          "$id": "#/properties/severityLevel/strictMacroDefinition",
+          "title": "strictMacroDefinition",
+          "type": "string",
+          "enum": ["error", "warn"],
+          "default": "warn"
+        }
+      }
     }
   }
 }

src/format.ts

@@ -1 +0,0 @@
-export const format = (text: string) => {}

src/format/formatFile.spec.ts

@@ -0,0 +1,89 @@
+import { formatFile } from './formatFile'
+import path from 'path'
+import { createFile, deleteFile, readFile } from '@sasjs/utils/file'
+import { LintConfig } from '../types'
+
+describe('formatFile', () => {
+  it('should fix linting issues in a given file', async () => {
+    const content = `%macro somemacro();  \n%put 'hello';\n%mend;`
+    const expectedContent = `/**\n  @file\n  @brief <Your brief here>\n  <h4> SAS Macros </h4>\n**/\n%macro somemacro();\n%put 'hello';\n%mend somemacro;`
+    await createFile(path.join(__dirname, 'format-file-test.sas'), content)
+    const expectedResult = {
+      updatedFilePaths: [path.join(__dirname, 'format-file-test.sas')],
+      fixedDiagnosticsCount: 3,
+      unfixedDiagnostics: []
+    }
+
+    const result = await formatFile(
+      path.join(__dirname, 'format-file-test.sas')
+    )
+    const formattedContent = await readFile(
+      path.join(__dirname, 'format-file-test.sas')
+    )
+
+    expect(result).toEqual(expectedResult)
+    expect(formattedContent).toEqual(expectedContent)
+
+    await deleteFile(path.join(__dirname, 'format-file-test.sas'))
+  })
+
+  it('should use the provided config if available', async () => {
+    const content = `%macro somemacro();  \n%put 'hello';\n%mend;`
+    const expectedContent = `/**\r\n  @file\r\n  @brief <Your brief here>\r\n  <h4> SAS Macros </h4>\r\n**/\r\n%macro somemacro();\r\n%put 'hello';\r\n%mend;`
+    const expectedResult = {
+      updatedFilePaths: [path.join(__dirname, 'format-file-config.sas')],
+      fixedDiagnosticsCount: 4,
+      unfixedDiagnostics: []
+    }
+    await createFile(path.join(__dirname, 'format-file-config.sas'), content)
+
+    const result = await formatFile(
+      path.join(__dirname, 'format-file-config.sas'),
+      new LintConfig({
+        lineEndings: 'crlf',
+        hasMacroNameInMend: false,
+        hasDoxygenHeader: true,
+        noTrailingSpaces: true
+      })
+    )
+    const formattedContent = await readFile(
+      path.join(__dirname, 'format-file-config.sas')
+    )
+
+    expect(result).toEqual(expectedResult)
+    expect(formattedContent).toEqual(expectedContent)
+
+    await deleteFile(path.join(__dirname, 'format-file-config.sas'))
+  })
+
+  it('should not update any files if there are no formatting violations', async () => {
+    const content = `/**\r\n  @file\r\n  @brief <Your brief here>\r\n  <h4> SAS Macros </h4>\r\n**/\r\n%macro somemacro();\r\n%put 'hello';\r\n%mend somemacro;`
+    const expectedResult = {
+      updatedFilePaths: [],
+      fixedDiagnosticsCount: 0,
+      unfixedDiagnostics: []
+    }
+    await createFile(
+      path.join(__dirname, 'format-file-no-violations.sas'),
+      content
+    )
+
+    const result = await formatFile(
+      path.join(__dirname, 'format-file-no-violations.sas'),
+      new LintConfig({
+        lineEndings: 'crlf',
+        hasMacroNameInMend: true,
+        hasDoxygenHeader: true,
+        noTrailingSpaces: true
+      })
+    )
+    const formattedContent = await readFile(
+      path.join(__dirname, 'format-file-no-violations.sas')
+    )
+
+    expect(result).toEqual(expectedResult)
+    expect(formattedContent).toEqual(content)
+
+    await deleteFile(path.join(__dirname, 'format-file-no-violations.sas'))
+  })
+})

src/format/formatFile.ts

@@ -0,0 +1,45 @@
+import { createFile, readFile } from '@sasjs/utils/file'
+import { lintFile } from '../lint'
+import { FormatResult } from '../types'
+import { LintConfig } from '../types/LintConfig'
+import { getLintConfig } from '../utils/getLintConfig'
+import { processText } from './shared'
+
+/**
+ * Applies automatic formatting to the file at the given path.
+ * @param {string} filePath - the path to the file to be formatted.
+ * @param {LintConfig} configuration - an optional configuration. When not passed in, this is read from the .sasjslint file.
+ * @returns {Promise<FormatResult>} Resolves successfully when the file has been formatted.
+ */
+export const formatFile = async (
+  filePath: string,
+  configuration?: LintConfig
+): Promise<FormatResult> => {
+  const config = configuration || (await getLintConfig())
+  const diagnosticsBeforeFormat = await lintFile(filePath, config)
+  const diagnosticsCountBeforeFormat = diagnosticsBeforeFormat.length
+
+  const text = await readFile(filePath)
+
+  const formattedText = processText(text, config)
+
+  await createFile(filePath, formattedText)
+
+  const diagnosticsAfterFormat = await lintFile(filePath, config)
+  const diagnosticsCountAfterFormat = diagnosticsAfterFormat.length
+
+  const fixedDiagnosticsCount =
+    diagnosticsCountBeforeFormat - diagnosticsCountAfterFormat
+
+  const updatedFilePaths: string[] = []
+
+  if (fixedDiagnosticsCount) {
+    updatedFilePaths.push(filePath)
+  }
+
+  return {
+    updatedFilePaths,
+    fixedDiagnosticsCount,
+    unfixedDiagnostics: diagnosticsAfterFormat
+  }
+}

src/format/formatFolder.spec.ts

@@ -0,0 +1,228 @@
+import { formatFolder } from './formatFolder'
+import path from 'path'
+import {
+  createFile,
+  createFolder,
+  deleteFolder,
+  readFile
+} from '@sasjs/utils/file'
+import { Diagnostic, LintConfig } from '../types'
+
+describe('formatFolder', () => {
+  it('should fix linting issues in a given folder', async () => {
+    const content = `%macro somemacro();  \n%put 'hello';\n%mend;`
+    const expectedContent = `/**\n  @file\n  @brief <Your brief here>\n  <h4> SAS Macros </h4>\n**/\n%macro somemacro();\n%put 'hello';\n%mend somemacro;`
+    const expectedResult = {
+      updatedFilePaths: [
+        path.join(__dirname, 'format-folder-test', 'format-folder-test.sas')
+      ],
+      fixedDiagnosticsCount: 3,
+      unfixedDiagnostics: new Map<string, Diagnostic[]>([
+        [
+          path.join(__dirname, 'format-folder-test', 'format-folder-test.sas'),
+          []
+        ]
+      ])
+    }
+    await createFolder(path.join(__dirname, 'format-folder-test'))
+    await createFile(
+      path.join(__dirname, 'format-folder-test', 'format-folder-test.sas'),
+      content
+    )
+
+    const result = await formatFolder(
+      path.join(__dirname, 'format-folder-test')
+    )
+    const formattedContent = await readFile(
+      path.join(__dirname, 'format-folder-test', 'format-folder-test.sas')
+    )
+
+    expect(formattedContent).toEqual(expectedContent)
+    expect(result).toEqual(expectedResult)
+
+    await deleteFolder(path.join(__dirname, 'format-folder-test'))
+  })
+
+  it('should fix linting issues in subfolders of a given folder', async () => {
+    const content = `%macro somemacro();  \n%put 'hello';\n%mend;`
+    const expectedContent = `/**\n  @file\n  @brief <Your brief here>\n  <h4> SAS Macros </h4>\n**/\n%macro somemacro();\n%put 'hello';\n%mend somemacro;`
+    const expectedResult = {
+      updatedFilePaths: [
+        path.join(
+          __dirname,
+          'format-folder-test',
+          'subfolder',
+          'format-folder-test.sas'
+        )
+      ],
+      fixedDiagnosticsCount: 3,
+      unfixedDiagnostics: new Map<string, Diagnostic[]>([
+        [
+          path.join(
+            __dirname,
+            'format-folder-test',
+            'subfolder',
+            'format-folder-test.sas'
+          ),
+          []
+        ]
+      ])
+    }
+
+    await createFolder(path.join(__dirname, 'format-folder-test'))
+    await createFolder(path.join(__dirname, 'subfolder'))
+    await createFile(
+      path.join(
+        __dirname,
+        'format-folder-test',
+        'subfolder',
+        'format-folder-test.sas'
+      ),
+      content
+    )
+
+    const result = await formatFolder(
+      path.join(__dirname, 'format-folder-test')
+    )
+    const formattedContent = await readFile(
+      path.join(
+        __dirname,
+        'format-folder-test',
+        'subfolder',
+        'format-folder-test.sas'
+      )
+    )
+
+    expect(result).toEqual(expectedResult)
+    expect(formattedContent).toEqual(expectedContent)
+
+    await deleteFolder(path.join(__dirname, 'format-folder-test'))
+  })
+
+  it('should use a custom configuration when provided', async () => {
+    const content = `%macro somemacro();  \n%put 'hello';\n%mend;`
+    const expectedContent = `/**\n  @file\n  @brief <Your brief here>\n  <h4> SAS Macros </h4>\n**/\n%macro somemacro();\n%put 'hello';\n%mend somemacro;`
+    const expectedResult = {
+      updatedFilePaths: [
+        path.join(__dirname, 'format-folder-test', 'format-folder-test.sas')
+      ],
+      fixedDiagnosticsCount: 3,
+      unfixedDiagnostics: new Map<string, Diagnostic[]>([
+        [
+          path.join(__dirname, 'format-folder-test', 'format-folder-test.sas'),
+          []
+        ]
+      ])
+    }
+    await createFolder(path.join(__dirname, 'format-folder-test'))
+    await createFile(
+      path.join(__dirname, 'format-folder-test', 'format-folder-test.sas'),
+      content
+    )
+
+    const result = await formatFolder(
+      path.join(__dirname, 'format-folder-test'),
+      new LintConfig({
+        lineEndings: 'crlf',
+        hasMacroNameInMend: false,
+        hasDoxygenHeader: true,
+        noTrailingSpaces: true
+      })
+    )
+    const formattedContent = await readFile(
+      path.join(__dirname, 'format-folder-test', 'format-folder-test.sas')
+    )
+
+    expect(formattedContent).toEqual(expectedContent)
+    expect(result).toEqual(expectedResult)
+
+    await deleteFolder(path.join(__dirname, 'format-folder-test'))
+  })
+
+  it('should fix linting issues in subfolders of a given folder', async () => {
+    const content = `%macro somemacro();  \n%put 'hello';\n%mend;`
+    const expectedContent = `/**\n  @file\n  @brief <Your brief here>\n  <h4> SAS Macros </h4>\n**/\n%macro somemacro();\n%put 'hello';\n%mend somemacro;`
+    const expectedResult = {
+      updatedFilePaths: [
+        path.join(
+          __dirname,
+          'format-folder-test',
+          'subfolder',
+          'format-folder-test.sas'
+        )
+      ],
+      fixedDiagnosticsCount: 3,
+      unfixedDiagnostics: new Map<string, Diagnostic[]>([
+        [
+          path.join(
+            __dirname,
+            'format-folder-test',
+            'subfolder',
+            'format-folder-test.sas'
+          ),
+          []
+        ]
+      ])
+    }
+
+    await createFolder(path.join(__dirname, 'format-folder-test'))
+    await createFolder(path.join(__dirname, 'subfolder'))
+    await createFile(
+      path.join(
+        __dirname,
+        'format-folder-test',
+        'subfolder',
+        'format-folder-test.sas'
+      ),
+      content
+    )
+
+    const result = await formatFolder(
+      path.join(__dirname, 'format-folder-test')
+    )
+    const formattedContent = await readFile(
+      path.join(
+        __dirname,
+        'format-folder-test',
+        'subfolder',
+        'format-folder-test.sas'
+      )
+    )
+
+    expect(result).toEqual(expectedResult)
+    expect(formattedContent).toEqual(expectedContent)
+
+    await deleteFolder(path.join(__dirname, 'format-folder-test'))
+  })
+
+  it('should not update any files when there are no violations', async () => {
+    const content = `/**\n  @file\n  @brief <Your brief here>\n  <h4> SAS Macros </h4>\n**/\n%macro somemacro();\n%put 'hello';\n%mend somemacro;`
+    const expectedResult = {
+      updatedFilePaths: [],
+      fixedDiagnosticsCount: 0,
+      unfixedDiagnostics: new Map<string, Diagnostic[]>([
+        [
+          path.join(__dirname, 'format-folder-test', 'format-folder-test.sas'),
+          []
+        ]
+      ])
+    }
+    await createFolder(path.join(__dirname, 'format-folder-test'))
+    await createFile(
+      path.join(__dirname, 'format-folder-test', 'format-folder-test.sas'),
+      content
+    )
+
+    const result = await formatFolder(
+      path.join(__dirname, 'format-folder-test')
+    )
+    const formattedContent = await readFile(
+      path.join(__dirname, 'format-folder-test', 'format-folder-test.sas')
+    )
+
+    expect(formattedContent).toEqual(content)
+    expect(result).toEqual(expectedResult)
+
+    await deleteFolder(path.join(__dirname, 'format-folder-test'))
+  })
+})

src/format/formatFolder.ts

@@ -0,0 +1,74 @@
+import { listSubFoldersInFolder } from '@sasjs/utils/file'
+import path from 'path'
+import { lintFolder } from '../lint'
+import { FormatResult } from '../types'
+import { LintConfig } from '../types/LintConfig'
+import { asyncForEach } from '../utils/asyncForEach'
+import { getLintConfig } from '../utils/getLintConfig'
+import { listSasFiles } from '../utils/listSasFiles'
+import { formatFile } from './formatFile'
+
+const excludeFolders = [
+  '.git',
+  '.github',
+  '.vscode',
+  'node_modules',
+  'sasjsbuild',
+  'sasjsresults'
+]
+
+/**
+ * Automatically formats all SAS files in the folder at the given path.
+ * @param {string} folderPath - the path to the folder to be formatted.
+ * @param {LintConfig} configuration - an optional configuration. When not passed in, this is read from the .sasjslint file.
+ * @returns {Promise<FormatResult>} Resolves successfully when all SAS files in the given folder have been formatted.
+ */
+export const formatFolder = async (
+  folderPath: string,
+  configuration?: LintConfig
+): Promise<FormatResult> => {
+  const config = configuration || (await getLintConfig())
+  const diagnosticsBeforeFormat = await lintFolder(folderPath)
+  const diagnosticsCountBeforeFormat = Array.from(
+    diagnosticsBeforeFormat.values()
+  ).reduce((a, b) => a + b.length, 0)
+
+  const fileNames = await listSasFiles(folderPath)
+  await asyncForEach(fileNames, async (fileName) => {
+    const filePath = path.join(folderPath, fileName)
+    await formatFile(filePath)
+  })
+
+  const subFolders = (await listSubFoldersInFolder(folderPath)).filter(
+    (f: string) => !excludeFolders.includes(f)
+  )
+
+  await asyncForEach(subFolders, async (subFolder) => {
+    await formatFolder(path.join(folderPath, subFolder), config)
+  })
+
+  const diagnosticsAfterFormat = await lintFolder(folderPath)
+  const diagnosticsCountAfterFormat = Array.from(
+    diagnosticsAfterFormat.values()
+  ).reduce((a, b) => a + b.length, 0)
+
+  const fixedDiagnosticsCount =
+    diagnosticsCountBeforeFormat - diagnosticsCountAfterFormat
+
+  const updatedFilePaths: string[] = []
+
+  Array.from(diagnosticsBeforeFormat.keys()).forEach((filePath) => {
+    const diagnosticsBefore = diagnosticsBeforeFormat.get(filePath) || []
+    const diagnosticsAfter = diagnosticsAfterFormat.get(filePath) || []
+
+    if (diagnosticsBefore.length !== diagnosticsAfter.length) {
+      updatedFilePaths.push(filePath)
+    }
+  })
+
+  return {
+    updatedFilePaths,
+    fixedDiagnosticsCount,
+    unfixedDiagnostics: diagnosticsAfterFormat
+  }
+}

src/format/formatProject.spec.ts

@@ -0,0 +1,51 @@
+import { formatProject } from './formatProject'
+import path from 'path'
+import {
+  createFile,
+  createFolder,
+  deleteFolder,
+  readFile
+} from '@sasjs/utils/file'
+import { DefaultLintConfiguration } from '../utils'
+import * as getProjectRootModule from '../utils/getProjectRoot'
+jest.mock('../utils/getProjectRoot')
+
+describe('formatProject', () => {
+  it('should format files in the current project', async () => {
+    const content = `%macro somemacro();  \n%put 'hello';\n%mend;`
+    const expectedContent = `/**\n  @file\n  @brief <Your brief here>\n  <h4> SAS Macros </h4>\n**/\n%macro somemacro();\n%put 'hello';\n%mend somemacro;`
+    await createFolder(path.join(__dirname, 'format-project-test'))
+    await createFile(
+      path.join(__dirname, 'format-project-test', 'format-project-test.sas'),
+      content
+    )
+    await createFile(
+      path.join(__dirname, 'format-project-test', '.sasjslint'),
+      JSON.stringify(DefaultLintConfiguration)
+    )
+    jest
+      .spyOn(getProjectRootModule, 'getProjectRoot')
+      .mockImplementation(() =>
+        Promise.resolve(path.join(__dirname, 'format-project-test'))
+      )
+
+    await formatProject()
+    const result = await readFile(
+      path.join(__dirname, 'format-project-test', 'format-project-test.sas')
+    )
+
+    expect(result).toEqual(expectedContent)
+
+    await deleteFolder(path.join(__dirname, 'format-project-test'))
+  })
+
+  it('should throw an error when a project root is not found', async () => {
+    jest
+      .spyOn(getProjectRootModule, 'getProjectRoot')
+      .mockImplementationOnce(() => Promise.resolve(''))
+
+    await expect(formatProject()).rejects.toThrowError(
+      'SASjs Project Root was not found.'
+    )
+  })
+})

src/format/formatProject.ts

@@ -0,0 +1,18 @@
+import { lintFolder } from '../lint/lintFolder'
+import { FormatResult } from '../types/FormatResult'
+import { getProjectRoot } from '../utils/getProjectRoot'
+import { formatFolder } from './formatFolder'
+
+/**
+ * Automatically formats all SAS files in the current project.
+ * @returns {Promise<FormatResult>} Resolves successfully when all SAS files in the current project have been formatted.
+ */
+export const formatProject = async (): Promise<FormatResult> => {
+  const projectRoot =
+    (await getProjectRoot()) || process.projectDir || process.currentDir
+  if (!projectRoot) {
+    throw new Error('SASjs Project Root was not found.')
+  }
+
+  return await formatFolder(projectRoot)
+}

src/format/formatText.spec.ts

@@ -0,0 +1,49 @@
+import { formatText } from './formatText'
+import * as getLintConfigModule from '../utils/getLintConfig'
+import { LintConfig } from '../types'
+jest.mock('../utils/getLintConfig')
+
+describe('formatText', () => {
+  it('should format the given text based on configured rules', async () => {
+    jest
+      .spyOn(getLintConfigModule, 'getLintConfig')
+      .mockImplementationOnce(() =>
+        Promise.resolve(
+          new LintConfig(getLintConfigModule.DefaultLintConfiguration)
+        )
+      )
+    const text = `%macro test;
+  %put 'hello';\r\n%mend; `
+
+    const expectedOutput = `/**
+  @file
+  @brief <Your brief here>
+  <h4> SAS Macros </h4>
+**/\n%macro test;
+  %put 'hello';\n%mend test;`
+
+    const output = await formatText(text)
+
+    expect(output).toEqual(expectedOutput)
+  })
+
+  it('should use CRLF line endings when configured', async () => {
+    jest
+      .spyOn(getLintConfigModule, 'getLintConfig')
+      .mockImplementationOnce(() =>
+        Promise.resolve(
+          new LintConfig({
+            ...getLintConfigModule.DefaultLintConfiguration,
+            lineEndings: 'crlf'
+          })
+        )
+      )
+    const text = `%macro test;\n  %put 'hello';\r\n%mend; `
+
+    const expectedOutput = `/**\r\n  @file\r\n  @brief <Your brief here>\r\n  <h4> SAS Macros </h4>\r\n**/\r\n%macro test;\r\n  %put 'hello';\r\n%mend test;`
+
+    const output = await formatText(text)
+
+    expect(output).toEqual(expectedOutput)
+  })
+})

src/format/formatText.ts

@@ -0,0 +1,8 @@
+import { LintConfig } from '../types'
+import { getLintConfig } from '../utils'
+import { processText } from './shared'
+
+export const formatText = async (text: string, configuration?: LintConfig) => {
+  const config = configuration || (await getLintConfig())
+  return processText(text, config)
+}

src/format/index.ts

@@ -0,0 +1,4 @@
+export * from './formatText'
+export * from './formatFile'
+export * from './formatFolder'
+export * from './formatProject'

src/format/shared.ts

@@ -0,0 +1,37 @@
+import { LintConfig } from '../types'
+import { LineEndings } from '../types/LineEndings'
+import { splitText } from '../utils/splitText'
+
+export const processText = (text: string, config: LintConfig) => {
+  const processedText = processContent(config, text)
+  const lines = splitText(processedText, config)
+  const formattedLines = lines.map((line) => {
+    return processLine(config, line)
+  })
+
+  const configuredLineEnding =
+    config.lineEndings === LineEndings.LF ? '\n' : '\r\n'
+  return formattedLines.join(configuredLineEnding)
+}
+
+const processContent = (config: LintConfig, content: string): string => {
+  let processedContent = content
+  config.fileLintRules
+    .filter((r) => !!r.fix)
+    .forEach((rule) => {
+      processedContent = rule.fix!(processedContent, config)
+    })
+
+  return processedContent
+}
+
+export const processLine = (config: LintConfig, line: string): string => {
+  let processedLine = line
+  config.lineLintRules
+    .filter((r) => !!r.fix)
+    .forEach((rule) => {
+      processedLine = rule.fix!(processedLine, config)
+    })
+
+  return processedLine
+}

src/formatExample.ts

@@ -0,0 +1,21 @@
+import { formatText } from './format/formatText'
+import { lintText } from './lint'
+
+const content = `%put 'Hello';   
+%put 'World'; 
+%macro somemacro()
+  %put 'test';
+%mend;\r\n`
+
+console.log(content)
+lintText(content).then((diagnostics) => {
+  console.log('Before Formatting:')
+  console.table(diagnostics)
+  formatText(content).then((formattedText) => {
+    lintText(formattedText).then((newDiagnostics) => {
+      console.log('After Formatting:')
+      console.log(formattedText)
+      console.table(newDiagnostics)
+    })
+  })
+})

src/index.ts

@@ -1,3 +1,4 @@
+export * from './format'
 export * from './lint'
 export * from './types'
 export * from './utils'

src/lint/lintFile.spec.ts

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

@@ -1,18 +1,20 @@
 import { readFile } from '@sasjs/utils/file'
-import { LintConfig } from '../types/LintConfig'
+import { Diagnostic, LintConfig } from '../types'
-import { getLintConfig } from '../utils/getLintConfig'
+import { getLintConfig, isIgnored } from '../utils'
 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.
+ * @returns {Promise<Diagnostic[]>} array of diagnostic objects, each containing a warning, line number and column number.
  */
 export const lintFile = async (
   filePath: string,
   configuration?: LintConfig
-) => {
+): Promise<Diagnostic[]> => {
+  if (await isIgnored(filePath)) return []
+
   const config = configuration || (await getLintConfig())
   const text = await readFile(filePath)
 

src/lint/lintFolder.spec.ts

@@ -1,71 +1,135 @@
 import { lintFolder } from './lintFolder'
 import { Severity } from '../types/Severity'
 import path from 'path'
+import {
+  createFile,
+  createFolder,
+  deleteFolder,
+  readFile
+} from '@sasjs/utils/file'
+
+const expectedFilesCount = 1
+const expectedDiagnostics = [
+  {
+    message: 'Line contains trailing spaces',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line contains trailing spaces',
+    lineNumber: 2,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File name contains spaces',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File name contains uppercase characters',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File missing Doxygen header',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line contains encoded password',
+    lineNumber: 5,
+    startColumnNumber: 10,
+    endColumnNumber: 18,
+    severity: Severity.Error
+  },
+  {
+    message: 'Line contains a tab character (09x)',
+    lineNumber: 7,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line has incorrect indentation - 3 spaces',
+    lineNumber: 6,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: '%mend statement is missing macro name - mf_getuniquelibref',
+    lineNumber: 17,
+    startColumnNumber: 3,
+    endColumnNumber: 9,
+    severity: Severity.Warning
+  }
+]
 
 describe('lintFolder', () => {
   it('should identify lint issues in a given folder', async () => {
-    const results = await lintFolder(path.join(__dirname, '..'))
+    await createFolder(path.join(__dirname, 'lint-folder-test'))
-
+    const content = await readFile(
-    expect(results.size).toEqual(1)
-    const diagnostics = results.get(
       path.join(__dirname, '..', 'Example File.sas')
+    )
+    await createFile(
+      path.join(__dirname, 'lint-folder-test', 'Example File.sas'),
+      content
+    )
+    const results = await lintFolder(path.join(__dirname, 'lint-folder-test'))
+    expect(results.size).toEqual(expectedFilesCount)
+    const diagnostics = results.get(
+      path.join(__dirname, 'lint-folder-test', 'Example File.sas')
     )!
-    expect(diagnostics.length).toEqual(8)
+    expect(diagnostics.length).toEqual(expectedDiagnostics.length)
-    expect(diagnostics).toContainEqual({
+    expect(diagnostics).toContainEqual(expectedDiagnostics[0])
-      message: 'Line contains trailing spaces',
+    expect(diagnostics).toContainEqual(expectedDiagnostics[1])
-      lineNumber: 1,
+    expect(diagnostics).toContainEqual(expectedDiagnostics[2])
-      startColumnNumber: 1,
+    expect(diagnostics).toContainEqual(expectedDiagnostics[3])
-      endColumnNumber: 2,
+    expect(diagnostics).toContainEqual(expectedDiagnostics[4])
-      severity: Severity.Warning
+    expect(diagnostics).toContainEqual(expectedDiagnostics[5])
-    })
+    expect(diagnostics).toContainEqual(expectedDiagnostics[6])
-    expect(diagnostics).toContainEqual({
+    expect(diagnostics).toContainEqual(expectedDiagnostics[7])
-      message: 'Line contains trailing spaces',
+    expect(diagnostics).toContainEqual(expectedDiagnostics[8])
-      lineNumber: 2,
+
-      startColumnNumber: 1,
+    await deleteFolder(path.join(__dirname, 'lint-folder-test'))
-      endColumnNumber: 2,
+  })
-      severity: Severity.Warning
+
-    })
+  it('should identify lint issues in subfolders of a given folder', async () => {
-    expect(diagnostics).toContainEqual({
+    await createFolder(path.join(__dirname, 'lint-folder-test'))
-      message: 'File name contains spaces',
+    await createFolder(path.join(__dirname, 'lint-folder-test', 'subfolder'))
-      lineNumber: 1,
+    const content = await readFile(
-      startColumnNumber: 1,
+      path.join(__dirname, '..', 'Example File.sas')
-      endColumnNumber: 1,
+    )
-      severity: Severity.Warning
+    await createFile(
-    })
+      path.join(__dirname, 'lint-folder-test', 'subfolder', 'Example File.sas'),
-    expect(diagnostics).toContainEqual({
+      content
-      message: 'File name contains uppercase characters',
+    )
-      lineNumber: 1,
+    const results = await lintFolder(path.join(__dirname, 'lint-folder-test'))
-      startColumnNumber: 1,
+    expect(results.size).toEqual(expectedFilesCount)
-      endColumnNumber: 1,
+    const diagnostics = results.get(
-      severity: Severity.Warning
+      path.join(__dirname, 'lint-folder-test', 'subfolder', 'Example File.sas')
-    })
+    )!
-    expect(diagnostics).toContainEqual({
+    expect(diagnostics.length).toEqual(expectedDiagnostics.length)
-      message: 'File missing Doxygen header',
+    expect(diagnostics).toContainEqual(expectedDiagnostics[0])
-      lineNumber: 1,
+    expect(diagnostics).toContainEqual(expectedDiagnostics[1])
-      startColumnNumber: 1,
+    expect(diagnostics).toContainEqual(expectedDiagnostics[2])
-      endColumnNumber: 1,
+    expect(diagnostics).toContainEqual(expectedDiagnostics[3])
-      severity: Severity.Warning
+    expect(diagnostics).toContainEqual(expectedDiagnostics[4])
-    })
+    expect(diagnostics).toContainEqual(expectedDiagnostics[5])
-    expect(diagnostics).toContainEqual({
+    expect(diagnostics).toContainEqual(expectedDiagnostics[6])
-      message: 'Line contains encoded password',
+    expect(diagnostics).toContainEqual(expectedDiagnostics[7])
-      lineNumber: 5,
+    expect(diagnostics).toContainEqual(expectedDiagnostics[8])
-      startColumnNumber: 10,
+
-      endColumnNumber: 18,
+    await deleteFolder(path.join(__dirname, 'lint-folder-test'))
-      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

@@ -1,10 +1,7 @@
 import { listSubFoldersInFolder } from '@sasjs/utils/file'
 import path from 'path'
-import { Diagnostic } from '../types/Diagnostic'
+import { Diagnostic, LintConfig } from '../types'
-import { LintConfig } from '../types/LintConfig'
+import { asyncForEach, getLintConfig, isIgnored, listSasFiles } from '../utils'
-import { asyncForEach } from '../utils/asyncForEach'
-import { getLintConfig } from '../utils/getLintConfig'
-import { listSasFiles } from '../utils/listSasFiles'
 import { lintFile } from './lintFile'
 
 const excludeFolders = [
@@ -28,6 +25,9 @@ export const lintFolder = async (
 ) => {
   const config = configuration || (await getLintConfig())
   let diagnostics: Map<string, Diagnostic[]> = new Map<string, Diagnostic[]>()
+
+  if (await isIgnored(folderPath)) return diagnostics
+
   const fileNames = await listSasFiles(folderPath)
   await asyncForEach(fileNames, async (fileName) => {
     const filePath = path.join(folderPath, fileName)
@@ -39,10 +39,8 @@ export const lintFolder = async (
   )
 
   await asyncForEach(subFolders, async (subFolder) => {
-    const subFolderDiagnostics = await lintFolder(
+    const subFolderPath = path.join(folderPath, subFolder)
-      path.join(folderPath, subFolder),
+    const subFolderDiagnostics = await lintFolder(subFolderPath, config)
-      config
-    )
     diagnostics = new Map([...diagnostics, ...subFolderDiagnostics])
   })
 

src/lint/lintProject.spec.ts

@@ -1,82 +1,121 @@
 import { lintProject } from './lintProject'
 import { Severity } from '../types/Severity'
-import * as utils from '../utils'
+import * as getProjectRootModule from '../utils/getProjectRoot'
 import path from 'path'
-jest.mock('../utils')
+import { createFolder, createFile, readFile, deleteFolder } from '@sasjs/utils'
+import { DefaultLintConfiguration } from '../utils'
+jest.mock('../utils/getProjectRoot')
+
+const expectedFilesCount = 1
+const expectedDiagnostics = [
+  {
+    message: 'Line contains trailing spaces',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line contains trailing spaces',
+    lineNumber: 2,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File name contains spaces',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File name contains uppercase characters',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'File missing Doxygen header',
+    lineNumber: 1,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line contains encoded password',
+    lineNumber: 5,
+    startColumnNumber: 10,
+    endColumnNumber: 18,
+    severity: Severity.Error
+  },
+  {
+    message: 'Line contains a tab character (09x)',
+    lineNumber: 7,
+    startColumnNumber: 1,
+    endColumnNumber: 2,
+    severity: Severity.Warning
+  },
+  {
+    message: 'Line has incorrect indentation - 3 spaces',
+    lineNumber: 6,
+    startColumnNumber: 1,
+    endColumnNumber: 1,
+    severity: Severity.Warning
+  },
+  {
+    message: '%mend statement is missing macro name - mf_getuniquelibref',
+    lineNumber: 17,
+    startColumnNumber: 3,
+    endColumnNumber: 9,
+    severity: Severity.Warning
+  }
+]
 
 describe('lintProject', () => {
   it('should identify lint issues in a given project', async () => {
+    await createFolder(path.join(__dirname, 'lint-project-test'))
+    const content = await readFile(
+      path.join(__dirname, '..', 'Example File.sas')
+    )
+    await createFile(
+      path.join(__dirname, 'lint-project-test', 'Example File.sas'),
+      content
+    )
+    await createFile(
+      path.join(__dirname, 'lint-project-test', '.sasjslint'),
+      JSON.stringify(DefaultLintConfiguration)
+    )
+
     jest
-      .spyOn(utils, 'getProjectRoot')
+      .spyOn(getProjectRootModule, 'getProjectRoot')
-      .mockImplementationOnce(() => Promise.resolve(path.join(__dirname, '..')))
+      .mockImplementation(() =>
+        Promise.resolve(path.join(__dirname, 'lint-project-test'))
+      )
     const results = await lintProject()
 
-    expect(results.size).toEqual(1)
+    expect(results.size).toEqual(expectedFilesCount)
     const diagnostics = results.get(
-      path.join(__dirname, '..', 'Example File.sas')
+      path.join(__dirname, 'lint-project-test', 'Example File.sas')
     )!
-    expect(diagnostics.length).toEqual(8)
+    expect(diagnostics.length).toEqual(expectedDiagnostics.length)
-    expect(diagnostics).toContainEqual({
+    expect(diagnostics).toContainEqual(expectedDiagnostics[0])
-      message: 'Line contains trailing spaces',
+    expect(diagnostics).toContainEqual(expectedDiagnostics[1])
-      lineNumber: 1,
+    expect(diagnostics).toContainEqual(expectedDiagnostics[2])
-      startColumnNumber: 1,
+    expect(diagnostics).toContainEqual(expectedDiagnostics[3])
-      endColumnNumber: 2,
+    expect(diagnostics).toContainEqual(expectedDiagnostics[4])
-      severity: Severity.Warning
+    expect(diagnostics).toContainEqual(expectedDiagnostics[5])
-    })
+    expect(diagnostics).toContainEqual(expectedDiagnostics[6])
-    expect(diagnostics).toContainEqual({
+    expect(diagnostics).toContainEqual(expectedDiagnostics[7])
-      message: 'Line contains trailing spaces',
+    expect(diagnostics).toContainEqual(expectedDiagnostics[8])
-      lineNumber: 2,
+
-      startColumnNumber: 1,
+    await deleteFolder(path.join(__dirname, 'lint-project-test'))
-      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')
+      .spyOn(getProjectRootModule, 'getProjectRoot')
       .mockImplementationOnce(() => Promise.resolve(''))
 
     await expect(lintProject()).rejects.toThrowError(

src/lint/lintProject.ts

@@ -1,4 +1,4 @@
-import { getProjectRoot } from '../utils'
+import { getProjectRoot } from '../utils/getProjectRoot'
 import { lintFolder } from './lintFolder'
 
 /**
@@ -8,7 +8,6 @@ import { lintFolder } from './lintFolder'
 export const lintProject = async () => {
   const projectRoot =
     (await getProjectRoot()) || process.projectDir || process.currentDir
-
   if (!projectRoot) {
     throw new Error('SASjs Project Root was not found.')
   }

src/lint/shared.spec.ts

@@ -1,25 +0,0 @@
-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,17 +1,8 @@
 import { LintConfig, Diagnostic } from '../types'
-
+import { splitText } from '../utils'
-/**
- * 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 lines = splitText(text, config)
   const diagnostics: Diagnostic[] = []
   diagnostics.push(...processContent(config, text))
   lines.forEach((line, index) => {
@@ -27,7 +18,7 @@ export const processFile = (
 ): Diagnostic[] => {
   const diagnostics: Diagnostic[] = []
   config.pathLintRules.forEach((rule) => {
-    diagnostics.push(...rule.test(filePath))
+    diagnostics.push(...rule.test(filePath, config))
   })
 
   return diagnostics
@@ -36,7 +27,7 @@ export const processFile = (
 const processContent = (config: LintConfig, content: string): Diagnostic[] => {
   const diagnostics: Diagnostic[] = []
   config.fileLintRules.forEach((rule) => {
-    diagnostics.push(...rule.test(content))
+    diagnostics.push(...rule.test(content, config))
   })
 
   return diagnostics

src/rules/file/hasDoxygenHeader.spec.ts

@@ -0,0 +1,168 @@
+import { LintConfig } from '../../types'
+import { Severity } from '../../types/Severity'
+import { hasDoxygenHeader } from './hasDoxygenHeader'
+
+describe('hasDoxygenHeader - test', () => {
+  it('should return an empty array when the file starts with a doxygen header', () => {
+    const content = `/**
+   @file
+   @brief Returns an unused libref
+ **/
+
+ %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+   %local x libref;
+   %let x={SAS002};
+   %do x=0 %to &maxtries;`
+
+    expect(hasDoxygenHeader.test(content)).toEqual([])
+  })
+
+  it('should return an empty array when the file starts with a doxygen header', () => {
+    const content = `
+    
+    
+    /*
+   @file
+   @brief Returns an unused libref
+ */
+
+ %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+   %local x libref;
+   %let x={SAS002};
+   %do x=0 %to &maxtries;`
+
+    expect(hasDoxygenHeader.test(content)).toEqual([
+      {
+        message:
+          'File not following Doxygen header style, use double asterisks',
+        lineNumber: 4,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostic when the file has no header', () => {
+    const content = `
+ %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+   %local x libref;
+   %let x={SAS002};
+   %do x=0 %to &maxtries;`
+
+    expect(hasDoxygenHeader.test(content)).toEqual([
+      {
+        message: 'File missing Doxygen header',
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostic when the file has comment blocks but no header', () => {
+    const content = `
+ %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+   %local x libref;
+   %let x={SAS002};
+  /** Comment Line 1
+   * Comment Line 2
+   */
+   %do x=0 %to &maxtries;`
+
+    expect(hasDoxygenHeader.test(content)).toEqual([
+      {
+        message: 'File missing Doxygen header',
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostic when the file is undefined', () => {
+    const content = undefined
+
+    expect(hasDoxygenHeader.test(content as unknown as string)).toEqual([
+      {
+        message: 'File missing Doxygen header',
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
+})
+
+describe('hasDoxygenHeader - fix', () => {
+  it('should not alter the text if a doxygen header is already present', () => {
+    const content = `/**
+   @file
+   @brief Returns an unused libref
+ **/
+
+ %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+   %local x libref;
+   %let x={SAS002};
+   %do x=0 %to &maxtries;`
+
+    expect(hasDoxygenHeader.fix!(content)).toEqual(content)
+  })
+
+  it('should update single asterisks to double if a doxygen header is already present', () => {
+    const contentOriginal = `
+    /*
+   @file
+   @brief Returns an unused libref
+ */
+
+ %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+   %local x libref;
+   %let x={SAS002};
+   %do x=0 %to &maxtries;`
+
+    const contentExpected = `
+    /**
+   @file
+   @brief Returns an unused libref
+ */
+
+ %macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+   %local x libref;
+   %let x={SAS002};
+   %do x=0 %to &maxtries;`
+
+    expect(hasDoxygenHeader.fix!(contentOriginal)).toEqual(contentExpected)
+  })
+
+  it('should add a doxygen header if not present', () => {
+    const content = `%macro mf_getuniquelibref(prefix=mclib,maxtries=1000);
+%local x libref;
+%let x={SAS002};
+%do x=0 %to &maxtries;`
+
+    expect(hasDoxygenHeader.fix!(content)).toEqual(
+      `/**
+  @file
+  @brief <Your brief here>
+  <h4> SAS Macros </h4>
+**/` +
+        '\n' +
+        content
+    )
+  })
+
+  it('should use CRLF line endings when configured', () => {
+    const content = `%macro mf_getuniquelibref(prefix=mclib,maxtries=1000);\n%local x libref;\n%let x={SAS002};\n%do x=0 %to &maxtries;`
+    const config = new LintConfig({ lineEndings: 'crlf' })
+
+    expect(hasDoxygenHeader.fix!(content, config)).toEqual(
+      `/**\r\n  @file\r\n  @brief <Your brief here>\r\n  <h4> SAS Macros </h4>\r\n**/` +
+        '\r\n' +
+        content
+    )
+  })
+})

src/rules/file/hasDoxygenHeader.ts

@@ -0,0 +1,86 @@
+import { LintConfig } from '../../types'
+import { LineEndings } from '../../types/LineEndings'
+import { FileLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
+import { DefaultLintConfiguration } from '../../utils/getLintConfig'
+
+const name = 'hasDoxygenHeader'
+const description =
+  'Enforce the presence of a Doxygen header at the start of each file.'
+const message = 'File missing Doxygen header'
+const messageForSingleAsterisk =
+  'File not following Doxygen header style, use double asterisks'
+
+const test = (value: string, config?: LintConfig) => {
+  const lineEnding = config?.lineEndings === LineEndings.CRLF ? '\r\n' : '\n'
+  const severity = config?.severityLevel[name] || Severity.Warning
+
+  try {
+    const hasFileHeader = value.trimStart().startsWith('/**')
+    if (hasFileHeader) return []
+
+    const hasFileHeaderWithSingleAsterisk = value.trimStart().startsWith('/*')
+    if (hasFileHeaderWithSingleAsterisk)
+      return [
+        {
+          message: messageForSingleAsterisk,
+          lineNumber:
+            (value.split('/*')![0]!.match(new RegExp(lineEnding, 'g')) ?? [])
+              .length + 1,
+          startColumnNumber: 1,
+          endColumnNumber: 1,
+          severity
+        }
+      ]
+
+    return [
+      {
+        message,
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity
+      }
+    ]
+  } catch (e) {
+    return [
+      {
+        message,
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity
+      }
+    ]
+  }
+}
+
+const fix = (value: string, config?: LintConfig): string => {
+  const result = test(value, config)
+  if (result.length === 0) {
+    return value
+  } else if (result[0].message == messageForSingleAsterisk)
+    return value.replace('/*', '/**')
+
+  config = config || new LintConfig(DefaultLintConfiguration)
+  const lineEndingConfig = config?.lineEndings || LineEndings.LF
+  const lineEnding = lineEndingConfig === LineEndings.LF ? '\n' : '\r\n'
+
+  return `${config?.defaultHeader.replace(
+    /{lineEnding}/g,
+    lineEnding
+  )}${lineEnding}${value}`
+}
+
+/**
+ * Lint rule that checks for the presence of a Doxygen header in a given file.
+ */
+export const hasDoxygenHeader: FileLintRule = {
+  type: LintRuleType.File,
+  name,
+  description,
+  message,
+  test,
+  fix
+}

src/rules/file/hasMacroNameInMend.spec.ts

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

src/rules/file/hasMacroNameInMend.ts

@@ -0,0 +1,141 @@
+import { Diagnostic } from '../../types/Diagnostic'
+import { FileLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
+import { getColumnNumber } from '../../utils/getColumnNumber'
+import { LintConfig } from '../../types'
+import { LineEndings } from '../../types/LineEndings'
+import { parseMacros } from '../../utils/parseMacros'
+
+const name = 'hasMacroNameInMend'
+const description =
+  'Enforces the presence of the macro name in each %mend statement.'
+const message = '%mend statement has missing or incorrect macro name'
+
+const test = (value: string, config?: LintConfig) => {
+  const lineEnding = config?.lineEndings === LineEndings.CRLF ? '\r\n' : '\n'
+  const lines: string[] = value ? value.split(lineEnding) : []
+  const macros = parseMacros(value, config)
+  const severity = config?.severityLevel[name] || Severity.Warning
+  const diagnostics: Diagnostic[] = []
+
+  macros.forEach((macro) => {
+    if (macro.startLineNumbers.length === 0 && macro.endLineNumber !== null) {
+      const endLine = lines[macro.endLineNumber - 1]
+      diagnostics.push({
+        message: `%mend statement is redundant`,
+        lineNumber: macro.endLineNumber,
+        startColumnNumber: getColumnNumber(endLine, '%mend'),
+        endColumnNumber:
+          getColumnNumber(endLine, '%mend') + macro.termination.length,
+        severity
+      })
+    } else if (
+      macro.endLineNumber === null &&
+      macro.startLineNumbers.length !== 0
+    ) {
+      diagnostics.push({
+        message: `Missing %mend statement for macro - ${macro.name}`,
+        lineNumber: macro.startLineNumbers![0],
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity
+      })
+    } else if (macro.mismatchedMendMacroName) {
+      const endLine = lines[(macro.endLineNumber as number) - 1]
+      diagnostics.push({
+        message: `%mend statement has mismatched macro name, it should be '${
+          macro!.name
+        }'`,
+        lineNumber: macro.endLineNumber as number,
+        startColumnNumber: getColumnNumber(
+          endLine,
+          macro.mismatchedMendMacroName
+        ),
+        endColumnNumber:
+          getColumnNumber(endLine, macro.mismatchedMendMacroName) +
+          macro.mismatchedMendMacroName.length -
+          1,
+        severity
+      })
+    } else if (!macro.hasMacroNameInMend) {
+      const endLine = lines[(macro.endLineNumber as number) - 1]
+      diagnostics.push({
+        message: `%mend statement is missing macro name - ${macro.name}`,
+        lineNumber: macro.endLineNumber as number,
+        startColumnNumber: getColumnNumber(endLine, '%mend'),
+        endColumnNumber: getColumnNumber(endLine, '%mend') + 6,
+        severity
+      })
+    }
+  })
+
+  return diagnostics
+}
+
+const fix = (value: string, config?: LintConfig): string => {
+  const lineEnding = config?.lineEndings === LineEndings.CRLF ? '\r\n' : '\n'
+  const lines: string[] = value ? value.split(lineEnding) : []
+  const macros = parseMacros(value, config)
+
+  macros.forEach((macro) => {
+    if (macro.startLineNumbers.length === 0 && macro.endLineNumber !== null) {
+      // %mend statement is redundant
+      const endLine = lines[macro.endLineNumber - 1]
+      const startColumnNumber = getColumnNumber(endLine, '%mend')
+      const endColumnNumber =
+        getColumnNumber(endLine, '%mend') + macro.termination.length
+
+      const beforeStatement = endLine.slice(0, startColumnNumber - 1)
+      const afterStatement = endLine.slice(endColumnNumber)
+      lines[macro.endLineNumber - 1] = beforeStatement + afterStatement
+    } else if (
+      macro.endLineNumber === null &&
+      macro.startLineNumbers.length !== 0
+    ) {
+      // missing %mend statement
+    } else if (macro.mismatchedMendMacroName) {
+      // mismatched macro name
+      const endLine = lines[(macro.endLineNumber as number) - 1]
+      const startColumnNumber = getColumnNumber(
+        endLine,
+        macro.mismatchedMendMacroName
+      )
+      const endColumnNumber =
+        getColumnNumber(endLine, macro.mismatchedMendMacroName) +
+        macro.mismatchedMendMacroName.length -
+        1
+
+      const beforeMacroName = endLine.slice(0, startColumnNumber - 1)
+      const afterMacroName = endLine.slice(endColumnNumber)
+
+      lines[(macro.endLineNumber as number) - 1] =
+        beforeMacroName + macro.name + afterMacroName
+    } else if (!macro.hasMacroNameInMend) {
+      // %mend statement is missing macro name
+      const endLine = lines[(macro.endLineNumber as number) - 1]
+      const startColumnNumber = getColumnNumber(endLine, '%mend')
+      const endColumnNumber = getColumnNumber(endLine, '%mend') + 4
+
+      const beforeStatement = endLine.slice(0, startColumnNumber - 1)
+      const afterStatement = endLine.slice(endColumnNumber)
+      lines[(macro.endLineNumber as number) - 1] =
+        beforeStatement + `%mend ${macro.name}` + afterStatement
+    }
+  })
+  const formattedText = lines.join(lineEnding)
+
+  return formattedText
+}
+
+/**
+ * Lint rule that checks for the presence of macro name in %mend statement.
+ */
+export const hasMacroNameInMend: FileLintRule = {
+  type: LintRuleType.File,
+  name,
+  description,
+  message,
+  test,
+  fix
+}

src/rules/file/hasMacroParentheses.spec.ts

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

src/rules/file/hasMacroParentheses.ts

@@ -0,0 +1,67 @@
+import { Diagnostic } from '../../types/Diagnostic'
+import { FileLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
+import { getColumnNumber } from '../../utils/getColumnNumber'
+import { parseMacros } from '../../utils/parseMacros'
+import { LintConfig } from '../../types'
+
+const name = 'hasMacroParentheses'
+const description = 'Enforces the presence of parentheses in macro definitions.'
+const message = 'Macro definition missing parentheses'
+
+const test = (value: string, config?: LintConfig) => {
+  const diagnostics: Diagnostic[] = []
+  const macros = parseMacros(value, config)
+  const severity = config?.severityLevel[name] || Severity.Warning
+
+  macros.forEach((macro) => {
+    if (!macro.name) {
+      diagnostics.push({
+        message: 'Macro definition missing name',
+        lineNumber: macro.startLineNumbers![0],
+        startColumnNumber: getColumnNumber(
+          macro.declarationLines![0],
+          '%macro'
+        ),
+        endColumnNumber:
+          getColumnNumber(macro.declarationLines![0], '%macro') +
+          macro.declaration.length,
+        severity
+      })
+    } else if (!macro.declarationLines.find((dl) => dl.includes('('))) {
+      const macroNameLineIndex = macro.declarationLines.findIndex((dl) =>
+        dl.includes(macro.name)
+      )
+      diagnostics.push({
+        message,
+        lineNumber: macro.startLineNumbers![macroNameLineIndex],
+        startColumnNumber: getColumnNumber(
+          macro.declarationLines[macroNameLineIndex],
+          macro.name
+        ),
+        endColumnNumber:
+          getColumnNumber(
+            macro.declarationLines[macroNameLineIndex],
+            macro.name
+          ) +
+          macro.name.length -
+          1,
+        severity
+      })
+    }
+  })
+
+  return diagnostics
+}
+
+/**
+ * Lint rule that enforces the presence of parentheses in macro definitions..
+ */
+export const hasMacroParentheses: FileLintRule = {
+  type: LintRuleType.File,
+  name,
+  description,
+  message,
+  test
+}

src/rules/file/index.ts

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

src/rules/file/lineEndings.spec.ts

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

src/rules/file/lineEndings.ts

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

src/rules/file/noNestedMacros.spec.ts

@@ -0,0 +1,96 @@
+import { LintConfig } from '../../types'
+import { Severity } from '../../types/Severity'
+import { noNestedMacros } from './noNestedMacros'
+
+describe('noNestedMacros', () => {
+  it('should return an empty array when no nested macro', () => {
+    const content = `
+  %macro somemacro();
+    %put &sysmacroname;
+  %mend somemacro;`
+
+    expect(noNestedMacros.test(content)).toEqual([])
+  })
+
+  it('should return an array with a single diagnostic when a macro contains a nested macro definition', () => {
+    const content = `
+    %macro outer();
+      /* any amount of arbitrary code */
+      %macro inner();
+        %put inner;
+      %mend;
+      %inner()
+      %put outer;
+    %mend;
+
+    %outer()`
+
+    expect(noNestedMacros.test(content)).toEqual([
+      {
+        message: "Macro definition for 'inner' present in macro 'outer'",
+        lineNumber: 4,
+        startColumnNumber: 7,
+        endColumnNumber: 21,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with two diagnostics when nested macros are defined at 2 levels', () => {
+    const content = `
+    %macro outer();
+      /* any amount of arbitrary code */
+      %macro inner();
+        %put inner;
+
+                %macro inner2();
+                  %put inner2;
+                %mend;
+      %mend;
+      %inner()
+      %put outer;
+    %mend;
+
+    %outer()`
+
+    expect(noNestedMacros.test(content)).toContainEqual({
+      message: "Macro definition for 'inner' present in macro 'outer'",
+      lineNumber: 4,
+      startColumnNumber: 7,
+      endColumnNumber: 21,
+      severity: Severity.Warning
+    })
+    expect(noNestedMacros.test(content)).toContainEqual({
+      message: "Macro definition for 'inner2' present in macro 'inner'",
+      lineNumber: 7,
+      startColumnNumber: 17,
+      endColumnNumber: 32,
+      severity: Severity.Warning
+    })
+  })
+
+  it('should return an empty array when the file is undefined', () => {
+    const content = undefined
+
+    expect(noNestedMacros.test(content as unknown as string)).toEqual([])
+  })
+
+  it('should use the configured line ending while testing content', () => {
+    const content = `%macro outer();\r\n%macro inner;\r\n%mend inner;\r\n%mend outer;`
+
+    const diagnostics = noNestedMacros.test(
+      content,
+      new LintConfig({ lineEndings: 'crlf' })
+    )
+
+    expect(diagnostics).toEqual([
+      {
+        message: "Macro definition for 'inner' present in macro 'outer'",
+        lineNumber: 2,
+        startColumnNumber: 1,
+        endColumnNumber: 13,
+        severity: Severity.Warning
+      }
+    ])
+  })
+})

src/rules/file/noNestedMacros.ts

@@ -0,0 +1,55 @@
+import { Diagnostic } from '../../types/Diagnostic'
+import { FileLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
+import { getColumnNumber } from '../../utils/getColumnNumber'
+import { parseMacros } from '../../utils/parseMacros'
+import { LintConfig } from '../../types'
+import { LineEndings } from '../../types/LineEndings'
+
+const name = 'noNestedMacros'
+const description = 'Enfoces the absence of nested macro definitions.'
+const message = `Macro definition for '{macro}' present in macro '{parent}'`
+
+const test = (value: string, config?: LintConfig) => {
+  const lineEnding = config?.lineEndings === LineEndings.CRLF ? '\r\n' : '\n'
+  const lines: string[] = value ? value.split(lineEnding) : []
+  const diagnostics: Diagnostic[] = []
+  const macros = parseMacros(value, config)
+  const severity = config?.severityLevel[name] || Severity.Warning
+
+  macros
+    .filter((m) => !!m.parentMacro)
+    .forEach((macro) => {
+      diagnostics.push({
+        message: message
+          .replace('{macro}', macro.name)
+          .replace('{parent}', macro.parentMacro),
+        lineNumber: macro.startLineNumbers![0] as number,
+        startColumnNumber: getColumnNumber(
+          lines[(macro.startLineNumbers![0] as number) - 1],
+          '%macro'
+        ),
+        endColumnNumber:
+          getColumnNumber(
+            lines[(macro.startLineNumbers![0] as number) - 1],
+            '%macro'
+          ) +
+          lines[(macro.startLineNumbers![0] as number) - 1].trim().length -
+          1,
+        severity
+      })
+    })
+  return diagnostics
+}
+
+/**
+ * Lint rule that checks for the absence of nested macro definitions.
+ */
+export const noNestedMacros: FileLintRule = {
+  type: LintRuleType.File,
+  name,
+  description,
+  message,
+  test
+}

src/rules/file/strictMacroDefinition.spec.ts

@@ -0,0 +1,216 @@
+import { LintConfig, Severity } from '../../types'
+import { strictMacroDefinition } from './strictMacroDefinition'
+
+describe('strictMacroDefinition', () => {
+  it('should return an empty array when the content has correct macro definition syntax', () => {
+    const content = '%macro somemacro;'
+    expect(strictMacroDefinition.test(content)).toEqual([])
+
+    const content2 = '%macro somemacro();'
+    expect(strictMacroDefinition.test(content2)).toEqual([])
+
+    const content3 = '%macro somemacro(var1);'
+    expect(strictMacroDefinition.test(content3)).toEqual([])
+
+    const content4 = '%macro somemacro/minoperator;'
+    expect(strictMacroDefinition.test(content4)).toEqual([])
+
+    const content5 = '%macro somemacro /minoperator;'
+    expect(strictMacroDefinition.test(content5)).toEqual([])
+
+    const content6 = '%macro somemacro(var1, var2)/minoperator;'
+    expect(strictMacroDefinition.test(content6)).toEqual([])
+
+    const content7 =
+      ' /* Some Comment */ %macro somemacro(var1, var2) /minoperator ; /* Some Comment */'
+    expect(strictMacroDefinition.test(content7)).toEqual([])
+
+    const content8 =
+      '%macro macroName( arr, arr/* / store source */3 ) /* / store source */;/* / store source */'
+    expect(strictMacroDefinition.test(content8)).toEqual([])
+
+    const content9 = '%macro macroName(var1, var2=with space, var3=);'
+    expect(strictMacroDefinition.test(content9)).toEqual([])
+
+    const content10 = '%macro macroName()/ /* some comment */ store source;'
+    expect(strictMacroDefinition.test(content10)).toEqual([])
+
+    const content11 = '`%macro macroName() /* / store source */;'
+    expect(strictMacroDefinition.test(content11)).toEqual([])
+
+    const content12 =
+      '%macro macroName()/ /* some comment */ store des="some description";'
+    expect(strictMacroDefinition.test(content12)).toEqual([])
+  })
+
+  it('should return an array with a single diagnostic when Macro definition has space in param', () => {
+    const content = '%macro somemacro(va r1);'
+    expect(strictMacroDefinition.test(content)).toEqual([
+      {
+        message: `Param 'va r1' cannot have space`,
+        lineNumber: 1,
+        startColumnNumber: 18,
+        endColumnNumber: 22,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a two diagnostics when Macro definition has space in params', () => {
+    const content = '%macro somemacro(var1, var 2, v ar3, var4);'
+    expect(strictMacroDefinition.test(content)).toEqual([
+      {
+        message: `Param 'var 2' cannot have space`,
+        lineNumber: 1,
+        startColumnNumber: 24,
+        endColumnNumber: 28,
+        severity: Severity.Warning
+      },
+      {
+        message: `Param 'v ar3' cannot have space`,
+        lineNumber: 1,
+        startColumnNumber: 31,
+        endColumnNumber: 35,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a two diagnostics when Macro definition has space in params - special case', () => {
+    const content =
+      '%macro macroName( arr, ar r/* / store source */ 3 ) /* / store source */;/* / store source */'
+    expect(strictMacroDefinition.test(content)).toEqual([
+      {
+        message: `Param 'ar r 3' cannot have space`,
+        lineNumber: 1,
+        startColumnNumber: 24,
+        endColumnNumber: 49,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a single diagnostic when Macro definition has invalid option', () => {
+    const content = '%macro somemacro(var1, var2)/minXoperator;'
+    expect(strictMacroDefinition.test(content)).toEqual([
+      {
+        message: `Option 'minXoperator' is not valid`,
+        lineNumber: 1,
+        startColumnNumber: 30,
+        endColumnNumber: 41,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  it('should return an array with a two diagnostics when Macro definition has invalid options', () => {
+    const content =
+      '%macro somemacro(var1, var2)/ store   invalidoption   secure ;'
+    expect(strictMacroDefinition.test(content)).toEqual([
+      {
+        message: `Option 'invalidoption' is not valid`,
+        lineNumber: 1,
+        startColumnNumber: 39,
+        endColumnNumber: 51,
+        severity: Severity.Warning
+      }
+    ])
+  })
+
+  describe('multi-content macro declarations', () => {
+    it('should return an empty array when the content has correct macro definition syntax', () => {
+      const content = `%macro mp_ds2cards(base_ds=, tgt_ds=\n    ,cards_file="%sysfunc(pathname(work))/cardgen.sas"\n    ,maxobs=max\n    ,random_sample=NO\n    ,showlog=YES\n    ,outencoding=\n    ,append=NO\n)/*/STORE SOURCE*/;`
+      expect(strictMacroDefinition.test(content)).toEqual([])
+
+      const content2 = `%macro mm_createapplication(\n    tree=/User Folders/sasdemo\n    ,name=myApp\n    ,ClassIdentifier=mcore\n    ,desc=Created by mm_createapplication\n    ,params= param1=1
param2=blah\n    ,version=\n    ,frefin=mm_in\n    ,frefout=mm_out\n    ,mDebug=1\n    );`
+      expect(strictMacroDefinition.test(content2)).toEqual([])
+    })
+
+    it('should return an array with a single diagnostic when Macro definition has space in param', () => {
+      const content = `%macro 
+       somemacro(va r1);`
+      expect(strictMacroDefinition.test(content)).toEqual([
+        {
+          message: `Param 'va r1' cannot have space`,
+          lineNumber: 2,
+          startColumnNumber: 18,
+          endColumnNumber: 22,
+          severity: Severity.Warning
+        }
+      ])
+    })
+
+    it('should return an array with a two diagnostics when Macro definition has space in params', () => {
+      const content = `%macro somemacro(
+      var1, 
+      var 2, 
+      v ar3, 
+      var4);`
+      expect(strictMacroDefinition.test(content)).toEqual([
+        {
+          message: `Param 'var 2' cannot have space`,
+          lineNumber: 3,
+          startColumnNumber: 7,
+          endColumnNumber: 11,
+          severity: Severity.Warning
+        },
+        {
+          message: `Param 'v ar3' cannot have space`,
+          lineNumber: 4,
+          startColumnNumber: 7,
+          endColumnNumber: 11,
+          severity: Severity.Warning
+        }
+      ])
+    })
+
+    it('should return an array with a two diagnostics when Macro definition has space in params - special case', () => {
+      const content = `%macro macroName( 
+      arr, 
+      ar r/* / store source */ 3 
+      ) /* / store source */;/* / store source */`
+      expect(strictMacroDefinition.test(content)).toEqual([
+        {
+          message: `Param 'ar r 3' cannot have space`,
+          lineNumber: 3,
+          startColumnNumber: 7,
+          endColumnNumber: 32,
+          severity: Severity.Warning
+        }
+      ])
+    })
+
+    it('should return an array with a single diagnostic when Macro definition has invalid option', () => {
+      const content = `%macro somemacro(var1, var2)
+      /minXoperator;`
+      expect(strictMacroDefinition.test(content)).toEqual([
+        {
+          message: `Option 'minXoperator' is not valid`,
+          lineNumber: 2,
+          startColumnNumber: 8,
+          endColumnNumber: 19,
+          severity: Severity.Warning
+        }
+      ])
+    })
+
+    it('should return an array with a two diagnostics when Macro definition has invalid options', () => {
+      const content = `%macro 
+           somemacro(
+             var1, var2
+             )
+           / store   
+               invalidoption   
+               secure ;`
+      expect(strictMacroDefinition.test(content)).toEqual([
+        {
+          message: `Option 'invalidoption' is not valid`,
+          lineNumber: 6,
+          startColumnNumber: 16,
+          endColumnNumber: 28,
+          severity: Severity.Warning
+        }
+      ])
+    })
+  })
+})

src/rules/file/strictMacroDefinition.ts

@@ -0,0 +1,173 @@
+import { Diagnostic, LintConfig, Macro, Severity } from '../../types'
+import { FileLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { parseMacros } from '../../utils/parseMacros'
+
+const name = 'strictMacroDefinition'
+const description = 'Enforce strictly rules of macro definition syntax.'
+const message = 'Incorrent Macro Definition Syntax'
+
+const validOptions = [
+  'CMD',
+  'DES',
+  'MINDELIMITER',
+  'MINOPERATOR',
+  'NOMINOPERATOR',
+  'PARMBUFF',
+  'SECURE',
+  'NOSECURE',
+  'STMT',
+  'SOURCE',
+  'SRC',
+  'STORE'
+]
+
+const processParams = (
+  content: string,
+  macro: Macro,
+  diagnostics: Diagnostic[],
+  config?: LintConfig
+): string => {
+  const declaration = macro.declaration
+  const severity = config?.severityLevel[name] || Severity.Warning
+
+  const regExpParams = new RegExp(/(?<=\().*(?=\))/)
+  const regExpParamsResult = regExpParams.exec(declaration)
+
+  let _declaration = declaration
+  if (regExpParamsResult) {
+    const paramsPresent = regExpParamsResult[0]
+
+    const params = paramsPresent.trim().split(',')
+    params.forEach((param) => {
+      const trimedParam = param.split('=')[0].trim()
+
+      let paramLineNumber: number = 1,
+        paramStartIndex: number = 1,
+        paramEndIndex: number = content.length
+
+      if (
+        macro.declarationLines.findIndex(
+          (dl) => dl.indexOf(trimedParam) !== -1
+        ) === -1
+      ) {
+        const comment = '/\\*(.*?)\\*/'
+        for (let i = 1; i < trimedParam.length; i++) {
+          const paramWithComment =
+            trimedParam.slice(0, i) + comment + trimedParam.slice(i)
+          const regEx = new RegExp(paramWithComment)
+
+          const declarationLineIndex = macro.declarationLines.findIndex(
+            (dl) => !!regEx.exec(dl)
+          )
+
+          if (declarationLineIndex !== -1) {
+            const declarationLine = macro.declarationLines[declarationLineIndex]
+            const partFound = regEx.exec(declarationLine)![0]
+
+            paramLineNumber = macro.startLineNumbers[declarationLineIndex]
+            paramStartIndex = declarationLine.indexOf(partFound)
+            paramEndIndex =
+              declarationLine.indexOf(partFound) + partFound.length
+            break
+          }
+        }
+      } else {
+        const declarationLineIndex = macro.declarationLines.findIndex(
+          (dl) => dl.indexOf(trimedParam) !== -1
+        )
+        const declarationLine = macro.declarationLines[declarationLineIndex]
+        paramLineNumber = macro.startLineNumbers[declarationLineIndex]
+
+        paramStartIndex = declarationLine.indexOf(trimedParam)
+        paramEndIndex =
+          declarationLine.indexOf(trimedParam) + trimedParam.length
+      }
+
+      if (trimedParam.includes(' ')) {
+        diagnostics.push({
+          message: `Param '${trimedParam}' cannot have space`,
+          lineNumber: paramLineNumber,
+          startColumnNumber: paramStartIndex + 1,
+          endColumnNumber: paramEndIndex,
+          severity
+        })
+      }
+    })
+
+    _declaration = declaration.split(`(${paramsPresent})`)[1]
+  }
+  return _declaration
+}
+
+const processOptions = (
+  _declaration: string,
+  macro: Macro,
+  diagnostics: Diagnostic[],
+  config?: LintConfig
+): void => {
+  let optionsPresent = _declaration.split('/')?.[1]?.trim()
+  const severity = config?.severityLevel[name] || Severity.Warning
+
+  if (optionsPresent) {
+    const regex = new RegExp(/=["|'](.*?)["|']/, 'g')
+
+    let result = regex.exec(optionsPresent)
+
+    // removing Option's `="..."` part, e.g. des="..."
+    while (result) {
+      optionsPresent =
+        optionsPresent.slice(0, result.index) +
+        optionsPresent.slice(result.index + result[0].length)
+
+      result = regex.exec(optionsPresent)
+    }
+
+    optionsPresent
+      .split(' ')
+      ?.filter((o) => !!o)
+      .forEach((option) => {
+        const trimmedOption = option.trim()
+        if (!validOptions.includes(trimmedOption.toUpperCase())) {
+          const declarationLineIndex = macro.declarationLines.findIndex(
+            (dl) => dl.indexOf(trimmedOption) !== -1
+          )
+          const declarationLine = macro.declarationLines[declarationLineIndex]
+
+          diagnostics.push({
+            message: `Option '${trimmedOption}' is not valid`,
+            lineNumber: macro.startLineNumbers[declarationLineIndex],
+            startColumnNumber: declarationLine.indexOf(trimmedOption) + 1,
+            endColumnNumber:
+              declarationLine.indexOf(trimmedOption) + trimmedOption.length,
+            severity
+          })
+        }
+      })
+  }
+}
+
+const test = (value: string, config?: LintConfig) => {
+  const diagnostics: Diagnostic[] = []
+
+  const macros = parseMacros(value, config)
+
+  macros.forEach((macro) => {
+    const _declaration = processParams(value, macro, diagnostics, config)
+
+    processOptions(_declaration, macro, diagnostics, config)
+  })
+
+  return diagnostics
+}
+
+/**
+ * Lint rule that checks if a line has followed syntax for macro definition
+ */
+export const strictMacroDefinition: FileLintRule = {
+  type: LintRuleType.File,
+  name,
+  description,
+  message,
+  test
+}

src/rules/hasDoxygenHeader.spec.ts

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

src/rules/hasDoxygenHeader.ts

@@ -1,44 +0,0 @@
-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 message = 'File missing Doxygen header'
-const test = (value: string) => {
-  try {
-    const hasFileHeader = value.trimStart().startsWith('/*')
-    if (hasFileHeader) return []
-    return [
-      {
-        message,
-        lineNumber: 1,
-        startColumnNumber: 1,
-        endColumnNumber: 1,
-        severity: Severity.Warning
-      }
-    ]
-  } catch (e) {
-    return [
-      {
-        message,
-        lineNumber: 1,
-        startColumnNumber: 1,
-        endColumnNumber: 1,
-        severity: Severity.Warning
-      }
-    ]
-  }
-}
-
-/**
- * Lint rule that checks for the presence of a Doxygen header in a given file.
- */
-export const hasDoxygenHeader: FileLintRule = {
-  type: LintRuleType.File,
-  name,
-  description,
-  message,
-  test
-}

src/rules/hasMacroNameInMend.spec.ts

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

@@ -1,106 +0,0 @@
-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/line/indentationMultiple.spec.ts

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

src/rules/line/indentationMultiple.ts

@@ -1,14 +1,16 @@
-import { LintConfig } from '../types'
+import { LintConfig } from '../../types'
-import { LineLintRule } from '../types/LintRule'
+import { LineLintRule } from '../../types/LintRule'
-import { LintRuleType } from '../types/LintRuleType'
+import { LintRuleType } from '../../types/LintRuleType'
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
 
 const name = '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 severity = config?.severityLevel[name] || Severity.Warning
   const indentationMultiple = isNaN(config?.indentationMultiple as number)
     ? 2
     : config!.indentationMultiple
@@ -24,7 +26,7 @@ const test = (value: string, lineNumber: number, config?: LintConfig) => {
       lineNumber,
       startColumnNumber: 1,
       endColumnNumber: 1,
-      severity: Severity.Warning
+      severity
     }
   ]
 }

src/rules/line/index.ts

@@ -0,0 +1,6 @@
+export { noGremlins } from './noGremlins'
+export { indentationMultiple } from './indentationMultiple'
+export { maxLineLength } from './maxLineLength'
+export { noEncodedPasswords } from './noEncodedPasswords'
+export { noTabs } from './noTabs'
+export { noTrailingSpaces } from './noTrailingSpaces'

src/rules/line/maxLineLength.spec.ts

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

src/rules/line/maxLineLength.ts

@@ -1,12 +1,14 @@
-import { LintConfig } from '../types'
+import { LintConfig } from '../../types'
-import { LineLintRule } from '../types/LintRule'
+import { LineLintRule } from '../../types/LintRule'
-import { LintRuleType } from '../types/LintRuleType'
+import { LintRuleType } from '../../types/LintRuleType'
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
 
 const name = 'maxLineLength'
 const description = 'Restrict lines to the specified length.'
 const message = 'Line exceeds maximum length'
+
 const test = (value: string, lineNumber: number, config?: LintConfig) => {
+  const severity = config?.severityLevel[name] || Severity.Warning
   const maxLineLength = config?.maxLineLength || 80
   if (value.length <= maxLineLength) return []
   return [
@@ -15,7 +17,7 @@ const test = (value: string, lineNumber: number, config?: LintConfig) => {
       lineNumber,
       startColumnNumber: 1,
       endColumnNumber: 1,
-      severity: Severity.Warning
+      severity
     }
   ]
 }

src/rules/line/noEncodedPasswords.spec.ts

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

src/rules/line/noEncodedPasswords.ts

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

src/rules/line/noGremlins.spec.ts

@@ -0,0 +1,15 @@
+import { Severity } from '../../types/Severity'
+import { noGremlins } from './noGremlins'
+
+describe('noTabs', () => {
+  it('should return an empty array when the line does not have any gremlin', () => {
+    const line = "%put 'hello';"
+    expect(noGremlins.test(line, 1)).toEqual([])
+  })
+
+  it('should return a diagnostic array when the line contains gremlins', () => {
+    const line = "–  ‘ %put 'hello';"
+    const diagnostics = noGremlins.test(line, 1)
+    expect(diagnostics.length).toEqual(2)
+  })
+})

src/rules/line/noGremlins.ts

@@ -0,0 +1,59 @@
+import { Diagnostic, LintConfig } from '../../types'
+import { LineLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
+import { gremlinCharacters } from '../../utils'
+
+const name = 'noGremlins'
+const description = 'Disallow characters specified in gremlins array'
+const message = 'Line contains a gremlin'
+
+const test = (value: string, lineNumber: number, config?: LintConfig) => {
+  const severity = config?.severityLevel[name] || Severity.Warning
+
+  const diagnostics: Diagnostic[] = []
+
+  const gremlins: any = {}
+
+  for (const [hexCode, config] of Object.entries(gremlinCharacters)) {
+    gremlins[charFromHex(hexCode)] = Object.assign({}, config, {
+      hexCode
+    })
+  }
+
+  const regexpWithAllChars = new RegExp(
+    Object.keys(gremlins)
+      .map((char) => `${char}+`)
+      .join('|'),
+    'g'
+  )
+
+  let match
+  while ((match = regexpWithAllChars.exec(value))) {
+    const matchedCharacter = match[0][0]
+    const gremlin = gremlins[matchedCharacter]
+
+    diagnostics.push({
+      message: `${message}: ${gremlin.description}, hexCode(${gremlin.hexCode})`,
+      lineNumber,
+      startColumnNumber: match.index + 1,
+      endColumnNumber: match.index + 1 + match[0].length,
+      severity
+    })
+  }
+
+  return diagnostics
+}
+
+/**
+ * Lint rule that checks if a given line of text contains any gremlins.
+ */
+export const noGremlins: LineLintRule = {
+  type: LintRuleType.Line,
+  name,
+  description,
+  message,
+  test
+}
+
+const charFromHex = (hexCode: string) => String.fromCodePoint(parseInt(hexCode))

src/rules/line/noTabs.spec.ts

@@ -1,20 +1,20 @@
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
-import { noTabIndentation } from './noTabIndentation'
+import { noTabs } from './noTabs'
 
 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([])
+    expect(noTabs.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([
+    expect(noTabs.test(line, 1)).toEqual([
       {
-        message: 'Line is indented with a tab',
+        message: 'Line contains a tab character (09x)',
         lineNumber: 1,
         startColumnNumber: 1,
-        endColumnNumber: 1,
+        endColumnNumber: 2,
         severity: Severity.Warning
       }
     ])

src/rules/line/noTabs.ts

@@ -0,0 +1,38 @@
+import { LintConfig } from '../../types'
+import { LineLintRule } from '../../types/LintRule'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
+import { getIndicesOf } from '../../utils'
+
+const name = 'noTabs'
+const alias = 'noTabIndentation'
+const description = 'Disallow indenting with tabs.'
+const message = 'Line contains a tab character (09x)'
+
+const test = (value: string, lineNumber: number, config?: LintConfig) => {
+  const severity =
+    config?.severityLevel[name] ||
+    config?.severityLevel[alias] ||
+    Severity.Warning
+
+  const indices = getIndicesOf('\t', value)
+
+  return indices.map((index) => ({
+    message,
+    lineNumber,
+    startColumnNumber: index + 1,
+    endColumnNumber: index + 2,
+    severity
+  }))
+}
+
+/**
+ * Lint rule that checks if a given line of text is indented with a tab.
+ */
+export const noTabs: LineLintRule = {
+  type: LintRuleType.Line,
+  name,
+  description,
+  message,
+  test
+}

src/rules/line/noTrailingSpaces.spec.ts

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

src/rules/line/noTrailingSpaces.ts

@@ -1,12 +1,16 @@
-import { LineLintRule } from '../types/LintRule'
+import { LintConfig } from '../../types'
-import { LintRuleType } from '../types/LintRuleType'
+import { LineLintRule } from '../../types/LintRule'
-import { Severity } from '../types/Severity'
+import { LintRuleType } from '../../types/LintRuleType'
+import { Severity } from '../../types/Severity'
 
 const name = 'noTrailingSpaces'
 const description = 'Disallow trailing spaces on lines.'
 const message = 'Line contains trailing spaces'
-const test = (value: string, lineNumber: number) =>
+
-  value.trimEnd() === value
+const test = (value: string, lineNumber: number, config?: LintConfig) => {
+  const severity = config?.severityLevel[name] || Severity.Warning
+
+  return value.trimEnd() === value
     ? []
     : [
         {
@@ -14,9 +18,12 @@ const test = (value: string, lineNumber: number) =>
           lineNumber,
           startColumnNumber: value.trimEnd().length + 1,
           endColumnNumber: value.length,
-          severity: Severity.Warning
+          severity
         }
       ]
+}
+
+const fix = (value: string) => value.trimEnd()
 
 /**
  * Lint rule that checks for the presence of trailing space(s) in a given line of text.
@@ -26,5 +33,6 @@ export const noTrailingSpaces: LineLintRule = {
   name,
   description,
   message,
-  test
+  test,
+  fix
 }

src/rules/noTabIndentation.ts

@@ -1,30 +0,0 @@
-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/path/index.ts

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

src/rules/path/lowerCaseFileNames.spec.ts

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

src/rules/path/lowerCaseFileNames.ts

@@ -1,21 +1,26 @@
-import { PathLintRule } from '../types/LintRule'
+import { PathLintRule } from '../../types/LintRule'
-import { LintRuleType } from '../types/LintRuleType'
+import { LintRuleType } from '../../types/LintRuleType'
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
 import path from 'path'
+import { LintConfig } from '../../types'
 
 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 test = (value: string, config?: LintConfig) => {
+  const severity = config?.severityLevel[name] || Severity.Warning
   const fileName = path.basename(value)
+
   if (fileName.toLocaleLowerCase() === fileName) return []
+
   return [
     {
       message,
       lineNumber: 1,
       startColumnNumber: 1,
       endColumnNumber: 1,
-      severity: Severity.Warning
+      severity
     }
   ]
 }

src/rules/path/noSpacesInFileNames.spec.ts

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

src/rules/path/noSpacesInFileNames.ts

@@ -1,13 +1,17 @@
-import { PathLintRule } from '../types/LintRule'
+import { PathLintRule } from '../../types/LintRule'
-import { LintRuleType } from '../types/LintRuleType'
+import { LintRuleType } from '../../types/LintRuleType'
-import { Severity } from '../types/Severity'
+import { Severity } from '../../types/Severity'
 import path from 'path'
+import { LintConfig } from '../../types'
 
 const name = 'noSpacesInFileNames'
 const description = 'Enforce the absence of spaces within file names.'
 const message = 'File name contains spaces'
-const test = (value: string) => {
+
+const test = (value: string, config?: LintConfig) => {
+  const severity = config?.severityLevel[name] || Severity.Warning
   const fileName = path.basename(value)
+
   if (fileName.includes(' ')) {
     return [
       {
@@ -15,7 +19,7 @@ const test = (value: string) => {
         lineNumber: 1,
         startColumnNumber: 1,
         endColumnNumber: 1,
-        severity: Severity.Warning
+        severity
       }
     ]
   }

src/types/FormatResult.ts

@@ -0,0 +1,10 @@
+import { Diagnostic } from './Diagnostic'
+
+/**
+ * Represents the result of a format operation on a file, folder or project.
+ */
+export interface FormatResult {
+  updatedFilePaths: string[]
+  fixedDiagnosticsCount: number
+  unfixedDiagnostics: Map<string, Diagnostic[]> | Diagnostic[]
+}

src/types/LineEndings.ts

@@ -0,0 +1,4 @@
+export enum LineEndings {
+  LF = 'lf',
+  CRLF = 'crlf'
+}

src/types/LintConfig.spec.ts

@@ -1,61 +1,78 @@
+import { LineEndings } from './LineEndings'
 import { LintConfig } from './LintConfig'
 import { LintRuleType } from './LintRuleType'
+import { Severity } from './Severity'
 
 describe('LintConfig', () => {
-  it('should create an empty instance', () => {
+  it('should create an instance with default values when no configuration is provided', () => {
     const config = new LintConfig()
-
     expect(config).toBeTruthy()
-    expect(config.fileLintRules.length).toEqual(0)
-    expect(config.lineLintRules.length).toEqual(0)
   })
 
-  it('should create an instance with the noTrailingSpaces flag set', () => {
+  it('should create an instance with the noTrailingSpaces flag off', () => {
-    const config = new LintConfig({ noTrailingSpaces: true })
+    const config = new LintConfig({ noTrailingSpaces: false })
 
     expect(config).toBeTruthy()
-    expect(config.lineLintRules.length).toEqual(1)
+    expect(config.lineLintRules.length).toBeGreaterThan(0)
-    expect(config.lineLintRules[0].name).toEqual('noTrailingSpaces')
+    expect(config.fileLintRules.length).toBeGreaterThan(0)
-    expect(config.lineLintRules[0].type).toEqual(LintRuleType.Line)
+    expect(
-    expect(config.fileLintRules.length).toEqual(0)
+      config.lineLintRules.find((rule) => rule.name === 'noTrailingSpaces')
+    ).toBeUndefined()
   })
 
-  it('should create an instance with the noEncodedPasswords flag set', () => {
+  it('should create an instance with the noEncodedPasswords flag off', () => {
-    const config = new LintConfig({ noEncodedPasswords: true })
+    const config = new LintConfig({ noEncodedPasswords: false })
 
     expect(config).toBeTruthy()
-    expect(config.lineLintRules.length).toEqual(1)
+    expect(config.lineLintRules.length).toBeGreaterThan(0)
-    expect(config.lineLintRules[0].name).toEqual('noEncodedPasswords')
+    expect(config.fileLintRules.length).toBeGreaterThan(0)
-    expect(config.lineLintRules[0].type).toEqual(LintRuleType.Line)
+    expect(
-    expect(config.fileLintRules.length).toEqual(0)
+      config.lineLintRules.find((rule) => rule.name === 'noEncodedPasswords')
+    ).toBeUndefined()
   })
 
-  it('should create an instance with the hasDoxygenHeader flag set', () => {
+  it('should create an instance with the hasDoxygenHeader flag off', () => {
-    const config = new LintConfig({ hasDoxygenHeader: true })
+    const config = new LintConfig({ hasDoxygenHeader: false })
 
     expect(config).toBeTruthy()
-    expect(config.lineLintRules.length).toEqual(0)
+    expect(config.lineLintRules.length).toBeGreaterThan(0)
-    expect(config.fileLintRules.length).toEqual(1)
+    expect(config.fileLintRules.length).toBeGreaterThan(0)
-    expect(config.fileLintRules[0].name).toEqual('hasDoxygenHeader')
+    expect(
-    expect(config.fileLintRules[0].type).toEqual(LintRuleType.File)
+      config.fileLintRules.find((rule) => rule.name === 'hasDoxygenHeader')
-  })
+    ).toBeUndefined()
-
-  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.lineLintRules.length).toBeGreaterThan(0)
-    expect(config.fileLintRules.length).toEqual(0)
+    expect(config.fileLintRules.length).toBeGreaterThan(0)
+    expect(
+      config.fileLintRules.find((rule) => rule.name === 'hasMacroNameInMend')
+    ).toBeUndefined()
+  })
+
+  it('should create an instance with the noNestedMacros flag off', () => {
+    const config = new LintConfig({ noNestedMacros: false })
+
+    expect(config).toBeTruthy()
+    expect(config.lineLintRules.length).toBeGreaterThan(0)
+    expect(config.fileLintRules.length).toBeGreaterThan(0)
+    expect(
+      config.fileLintRules.find((rule) => rule.name === 'noNestedMacros')
+    ).toBeUndefined()
+  })
+
+  it('should create an instance with the hasMacroParentheses flag off', () => {
+    const config = new LintConfig({ hasMacroParentheses: false })
+
+    expect(config).toBeTruthy()
+    expect(config.lineLintRules.length).toBeGreaterThan(0)
+    expect(config.fileLintRules.length).toBeGreaterThan(0)
+    expect(
+      config.fileLintRules.find((rule) => rule.name === 'hasMacroParentheses')
+    ).toBeUndefined()
   })
 
   it('should create an instance with the indentation multiple set', () => {
@@ -72,6 +89,50 @@ describe('LintConfig', () => {
     expect(config.indentationMultiple).toEqual(0)
   })
 
+  it('should create an instance with the line endings set to LF', () => {
+    const config = new LintConfig({ lineEndings: 'lf' })
+
+    expect(config).toBeTruthy()
+    expect(config.lineEndings).toEqual(LineEndings.LF)
+  })
+
+  it('should create an instance with the line endings set to CRLF', () => {
+    const config = new LintConfig({ lineEndings: 'crlf' })
+
+    expect(config).toBeTruthy()
+    expect(config.lineEndings).toEqual(LineEndings.CRLF)
+  })
+
+  it('should create an instance with the severityLevel config', () => {
+    const config = new LintConfig({
+      severityLevel: {
+        hasDoxygenHeader: 'warn',
+        maxLineLength: 'error',
+        noTrailingSpaces: 'error'
+      }
+    })
+
+    expect(config).toBeTruthy()
+    expect(config.severityLevel).toEqual({
+      hasDoxygenHeader: Severity.Warning,
+      maxLineLength: Severity.Error,
+      noTrailingSpaces: Severity.Error
+    })
+  })
+
+  it('should create an instance with the line endings set to LF by default', () => {
+    const config = new LintConfig({})
+
+    expect(config).toBeTruthy()
+    expect(config.lineEndings).toEqual(LineEndings.LF)
+  })
+
+  it('should throw an error with an invalid value for line endings', () => {
+    expect(() => new LintConfig({ lineEndings: 'test' })).toThrowError(
+      `Invalid value for lineEndings: can be ${LineEndings.LF} or ${LineEndings.CRLF}`
+    )
+  })
+
   it('should create an instance with all flags set', () => {
     const config = new LintConfig({
       noTrailingSpaces: true,
@@ -82,11 +143,14 @@ describe('LintConfig', () => {
       maxLineLength: 80,
       noTabIndentation: true,
       indentationMultiple: 2,
-      hasMacroNameInMend: true
+      hasMacroNameInMend: true,
+      noNestedMacros: true,
+      hasMacroParentheses: true,
+      noGremlins: true
     })
 
     expect(config).toBeTruthy()
-    expect(config.lineLintRules.length).toEqual(5)
+    expect(config.lineLintRules.length).toEqual(6)
     expect(config.lineLintRules[0].name).toEqual('noTrailingSpaces')
     expect(config.lineLintRules[0].type).toEqual(LintRuleType.Line)
     expect(config.lineLintRules[1].name).toEqual('noEncodedPasswords')
@@ -97,12 +161,22 @@ describe('LintConfig', () => {
     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.lineLintRules[5].name).toEqual('noGremlins')
+    expect(config.lineLintRules[5].type).toEqual(LintRuleType.Line)
 
-    expect(config.fileLintRules.length).toEqual(2)
+    expect(config.fileLintRules.length).toEqual(6)
-    expect(config.fileLintRules[0].name).toEqual('hasDoxygenHeader')
+    expect(config.fileLintRules[0].name).toEqual('lineEndings')
     expect(config.fileLintRules[0].type).toEqual(LintRuleType.File)
-    expect(config.fileLintRules[1].name).toEqual('hasMacroNameInMend')
+    expect(config.fileLintRules[1].name).toEqual('hasDoxygenHeader')
     expect(config.fileLintRules[1].type).toEqual(LintRuleType.File)
+    expect(config.fileLintRules[2].name).toEqual('hasMacroNameInMend')
+    expect(config.fileLintRules[2].type).toEqual(LintRuleType.File)
+    expect(config.fileLintRules[3].name).toEqual('noNestedMacros')
+    expect(config.fileLintRules[3].type).toEqual(LintRuleType.File)
+    expect(config.fileLintRules[4].name).toEqual('hasMacroParentheses')
+    expect(config.fileLintRules[4].type).toEqual(LintRuleType.File)
+    expect(config.fileLintRules[5].name).toEqual('strictMacroDefinition')
+    expect(config.fileLintRules[5].type).toEqual(LintRuleType.File)
 
     expect(config.pathLintRules.length).toEqual(2)
     expect(config.pathLintRules[0].name).toEqual('noSpacesInFileNames')

src/types/LintConfig.ts

@@ -1,13 +1,24 @@
-import { hasDoxygenHeader } from '../rules/hasDoxygenHeader'
+import {
-import { indentationMultiple } from '../rules/indentationMultiple'
+  hasDoxygenHeader,
-import { lowerCaseFileNames } from '../rules/lowerCaseFileNames'
+  hasMacroNameInMend,
-import { maxLineLength } from '../rules/maxLineLength'
+  noNestedMacros,
-import { noEncodedPasswords } from '../rules/noEncodedPasswords'
+  hasMacroParentheses,
-import { noSpacesInFileNames } from '../rules/noSpacesInFileNames'
+  lineEndings,
-import { noTabIndentation } from '../rules/noTabIndentation'
+  strictMacroDefinition
-import { noTrailingSpaces } from '../rules/noTrailingSpaces'
+} from '../rules/file'
-import { hasMacroNameInMend } from '../rules/hasMacroNameInMend'
+import {
+  indentationMultiple,
+  maxLineLength,
+  noEncodedPasswords,
+  noTabs,
+  noTrailingSpaces,
+  noGremlins
+} from '../rules/line'
+import { lowerCaseFileNames, noSpacesInFileNames } from '../rules/path'
+import { LineEndings } from './LineEndings'
 import { FileLintRule, LineLintRule, PathLintRule } from './LintRule'
+import { getDefaultHeader } from '../utils'
+import { Severity } from './Severity'
 
 /**
  * LintConfig is the logical representation of the .sasjslint file.
@@ -17,49 +28,108 @@ import { FileLintRule, LineLintRule, PathLintRule } from './LintRule'
  * More types of rules, when available, will be added here.
  */
 export class LintConfig {
+  readonly ignoreList: string[] = []
   readonly lineLintRules: LineLintRule[] = []
   readonly fileLintRules: FileLintRule[] = []
   readonly pathLintRules: PathLintRule[] = []
   readonly maxLineLength: number = 80
   readonly indentationMultiple: number = 2
+  readonly lineEndings: LineEndings = LineEndings.LF
+  readonly defaultHeader: string = getDefaultHeader()
+  readonly severityLevel: { [key: string]: Severity } = {}
 
   constructor(json?: any) {
-    if (json?.noTrailingSpaces) {
+    if (json?.ignoreList) {
+      if (Array.isArray(json.ignoreList)) {
+        json.ignoreList.forEach((item: any) => {
+          if (typeof item === 'string') this.ignoreList.push(item)
+          else
+            throw new Error(
+              `Property "ignoreList" has invalid type of values. It can contain only strings.`
+            )
+        })
+      } else {
+        throw new Error(`Property "ignoreList" can only be an array of strings`)
+      }
+    }
+
+    if (json?.noTrailingSpaces !== false) {
       this.lineLintRules.push(noTrailingSpaces)
     }
 
-    if (json?.noEncodedPasswords) {
+    if (json?.noEncodedPasswords !== false) {
       this.lineLintRules.push(noEncodedPasswords)
     }
 
-    if (json?.noTabIndentation) {
+    this.lineLintRules.push(noTabs)
-      this.lineLintRules.push(noTabIndentation)
+    if (json?.noTabs === false || json?.noTabIndentation === false) {
+      this.lineLintRules.pop()
     }
 
-    if (json?.maxLineLength) {
+    this.lineLintRules.push(maxLineLength)
+    if (!isNaN(json?.maxLineLength)) {
       this.maxLineLength = json.maxLineLength
-      this.lineLintRules.push(maxLineLength)
     }
 
+    this.fileLintRules.push(lineEndings)
+    if (json?.lineEndings) {
+      if (
+        json.lineEndings !== LineEndings.LF &&
+        json.lineEndings !== LineEndings.CRLF
+      ) {
+        throw new Error(
+          `Invalid value for lineEndings: can be ${LineEndings.LF} or ${LineEndings.CRLF}`
+        )
+      }
+      this.lineEndings = json.lineEndings
+    }
+
+    this.lineLintRules.push(indentationMultiple)
     if (!isNaN(json?.indentationMultiple)) {
       this.indentationMultiple = json.indentationMultiple as number
-      this.lineLintRules.push(indentationMultiple)
     }
 
-    if (json?.hasDoxygenHeader) {
+    if (json?.hasDoxygenHeader !== false) {
       this.fileLintRules.push(hasDoxygenHeader)
     }
 
-    if (json?.noSpacesInFileNames) {
+    if (json?.defaultHeader) {
+      this.defaultHeader = json.defaultHeader
+    }
+
+    if (json?.noSpacesInFileNames !== false) {
       this.pathLintRules.push(noSpacesInFileNames)
     }
 
-    if (json?.lowerCaseFileNames) {
+    if (json?.lowerCaseFileNames !== false) {
       this.pathLintRules.push(lowerCaseFileNames)
     }
 
     if (json?.hasMacroNameInMend) {
       this.fileLintRules.push(hasMacroNameInMend)
     }
+
+    if (json?.noNestedMacros !== false) {
+      this.fileLintRules.push(noNestedMacros)
+    }
+
+    if (json?.hasMacroParentheses !== false) {
+      this.fileLintRules.push(hasMacroParentheses)
+    }
+
+    if (json?.strictMacroDefinition !== false) {
+      this.fileLintRules.push(strictMacroDefinition)
+    }
+
+    if (json?.noGremlins !== false) {
+      this.lineLintRules.push(noGremlins)
+    }
+
+    if (json?.severityLevel) {
+      for (const [rule, severity] of Object.entries(json.severityLevel)) {
+        if (severity === 'warn') this.severityLevel[rule] = Severity.Warning
+        if (severity === 'error') this.severityLevel[rule] = Severity.Error
+      }
+    }
   }
 }

src/types/LintRule.ts

@@ -19,6 +19,7 @@ export interface LintRule {
 export interface LineLintRule extends LintRule {
   type: LintRuleType.Line
   test: (value: string, lineNumber: number, config?: LintConfig) => Diagnostic[]
+  fix?: (value: string, config?: LintConfig) => string
 }
 
 /**
@@ -26,7 +27,8 @@ export interface LineLintRule extends LintRule {
  */
 export interface FileLintRule extends LintRule {
   type: LintRuleType.File
-  test: (value: string) => Diagnostic[]
+  test: (value: string, config?: LintConfig) => Diagnostic[]
+  fix?: (value: string, config?: LintConfig) => string
 }
 
 /**
@@ -34,5 +36,5 @@ export interface FileLintRule extends LintRule {
  */
 export interface PathLintRule extends LintRule {
   type: LintRuleType.Path
-  test: (value: string) => Diagnostic[]
+  test: (value: string, config?: LintConfig) => Diagnostic[]
 }

src/types/Macro.ts

@@ -0,0 +1,12 @@
+export interface Macro {
+  name: string
+  startLineNumbers: number[]
+  endLineNumber: number | null
+  declarationLines: string[]
+  terminationLine: string
+  declaration: string
+  termination: string
+  parentMacro: string
+  hasMacroNameInMend: boolean
+  mismatchedMendMacroName: string
+}

src/types/index.ts

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

src/utils/asyncForEach.ts

@@ -1,3 +1,6 @@
+/**
+ * Executes an async callback for each item in the given array.
+ */
 export async function asyncForEach(
   array: any[],
   callback: (item: any, index: number, originalArray: any[]) => any

src/utils/getColumnNumber.spec.ts

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

src/utils/getColumnNumber.ts

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

src/utils/getIndicesOf.ts

@@ -0,0 +1,26 @@
+export const getIndicesOf = (
+  searchStr: string,
+  str: string,
+  caseSensitive: boolean = true
+) => {
+  const searchStrLen = searchStr.length
+  if (searchStrLen === 0) {
+    return []
+  }
+
+  let startIndex = 0,
+    index,
+    indices = []
+
+  if (!caseSensitive) {
+    str = str.toLowerCase()
+    searchStr = searchStr.toLowerCase()
+  }
+
+  while ((index = str.indexOf(searchStr, startIndex)) > -1) {
+    indices.push(index)
+    startIndex = index + searchStrLen
+  }
+
+  return indices
+}

src/utils/getLintConfig.spec.ts

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

src/utils/getLintConfig.ts

@@ -3,6 +3,9 @@ import { LintConfig } from '../types/LintConfig'
 import { readFile } from '@sasjs/utils/file'
 import { getProjectRoot } from './getProjectRoot'
 
+export const getDefaultHeader = () =>
+  `/**{lineEnding}  @file{lineEnding}  @brief <Your brief here>{lineEnding}  <h4> SAS Macros </h4>{lineEnding}**/`
+
 /**
  * Default configuration that is used when a .sasjslint file is not found
  */
@@ -15,7 +18,12 @@ export const DefaultLintConfiguration = {
   maxLineLength: 80,
   noTabIndentation: true,
   indentationMultiple: 2,
-  hasMacroNameInMend: false
+  hasMacroNameInMend: true,
+  noNestedMacros: true,
+  hasMacroParentheses: true,
+  strictMacroDefinition: true,
+  noGremlins: true,
+  defaultHeader: getDefaultHeader()
 }
 
 /**

src/utils/gremlinCharacters.ts

@@ -0,0 +1,314 @@
+// Used https://compart.com/en/unicode to find the to find the description of each gremlin
+// List of gremlins was deduced from https://github.com/redoPop/SublimeGremlins/blob/main/Gremlins.py#L13
+
+export const gremlinCharacters = {
+  '0x0003': {
+    description: 'End of Text'
+  },
+  '0x000b': {
+    description: 'Line Tabulation'
+  },
+  '0x007f': {
+    description: 'Delete'
+  },
+  '0x0080': {
+    description: 'Padding'
+  },
+  '0x0081': {
+    description: 'High Octet Preset'
+  },
+  '0x0082': {
+    description: 'Break Permitted Here'
+  },
+  '0x0083': {
+    description: 'No Break Here'
+  },
+  '0x0084': {
+    description: 'Index'
+  },
+  '0x0085': {
+    description: 'Next Line'
+  },
+  '0x0086': {
+    description: 'Start of Selected Area'
+  },
+  '0x0087': {
+    description: 'End of Selected Area'
+  },
+  '0x0088': {
+    description: 'Character Tabulation Set'
+  },
+  '0x0089': {
+    description: 'Character Tabulation with Justification'
+  },
+  '0x008a': {
+    description: 'Line Tabulation Set'
+  },
+  '0x008b': {
+    description: 'Partial Line Down'
+  },
+  '0x008c': {
+    description: 'Partial Line Backward'
+  },
+  '0x008d': {
+    description: 'Reverse Index'
+  },
+  '0x008e': {
+    description: 'Single Shift Two'
+  },
+  '0x008f': {
+    description: 'Single Shift Three'
+  },
+  '0x0090': {
+    description: 'Device Control String'
+  },
+  '0x0091': {
+    description: 'Private Use One'
+  },
+  '0x0092': {
+    description: 'Private Use Two'
+  },
+  '0x0093': {
+    description: 'Set Transmit State'
+  },
+  '0x0094': {
+    description: 'Cancel Character'
+  },
+  '0x0095': {
+    description: 'Message Waiting'
+  },
+  '0x0096': {
+    description: 'Start of Guarded Area'
+  },
+  '0x0097': {
+    description: 'End of Guarded Area'
+  },
+  '0x0098': {
+    description: 'Start of String'
+  },
+  '0x0099': {
+    description: 'Single Graphic Character Introducer'
+  },
+  '0x009a': {
+    description: 'Single Character Introducer'
+  },
+  '0x009b': {
+    description: 'Control Sequence Introducer'
+  },
+  '0x009c': {
+    description: 'String Terminator'
+  },
+  '0x009d': {
+    description: 'Operating System Command'
+  },
+  '0x009e': {
+    description: 'Privacy Message'
+  },
+  '0x009f': {
+    description: 'Application Program Command'
+  },
+  '0x00a0': {
+    description: 'non breaking space'
+  },
+  '0x00ad': {
+    description: 'Soft Hyphen'
+  },
+  '0x2000': {
+    description: 'En Quad'
+  },
+  '0x2001': {
+    description: 'Em Quad'
+  },
+  '0x2002': {
+    description: 'En Space'
+  },
+  '0x2003': {
+    description: 'Em Space'
+  },
+  '0x2004': {
+    description: 'Three-Per-Em Space'
+  },
+  '0x2005': {
+    description: 'Four-Per-Em Space'
+  },
+  '0x2006': {
+    description: 'Six-Per-Em Space'
+  },
+  '0x2007': {
+    description: 'Figure Space'
+  },
+  '0x2008': {
+    description: 'Punctuation Space'
+  },
+  '0x2009': {
+    description: 'Thin Space'
+  },
+  '0x200a': {
+    description: 'Hair Space'
+  },
+  '0x200b': {
+    description: 'Zero Width Space'
+  },
+  '0x200c': {
+    description: 'Zero Width Non-Joiner'
+  },
+  '0x200d': {
+    description: 'Zero Width Joiner'
+  },
+  '0x200e': {
+    description: 'Left-to-Right Mark'
+  },
+  '0x200f': {
+    description: 'Right-to-Left Mark'
+  },
+  '0x2013': {
+    description: 'En Dash'
+  },
+  '0x2018': {
+    description: 'Left Single Quotation Mark'
+  },
+  '0x2019': {
+    description: 'Right Single Quotation Mark'
+  },
+  '0x201c': {
+    description: 'Left Double Quotation Mark'
+  },
+  '0x201d': {
+    description: 'Right Double Quotation Mark'
+  },
+  '0x2028': {
+    description: 'Line Separator'
+  },
+  '0x2029': {
+    description: 'Paragraph Separator'
+  },
+  '0x202a': {
+    description: 'Left-to-Right Embedding'
+  },
+  '0x202b': {
+    description: 'Right-to-Left Embedding'
+  },
+  '0x202c': {
+    description: 'Pop Directional Formatting'
+  },
+  '0x202d': {
+    description: 'Left-to-Right Override'
+  },
+  '0x202e': {
+    description: 'Right-to-Left Override'
+  },
+  '0x202f': {
+    description: 'Narrow No-Break Space'
+  },
+  '0x205f': {
+    description: 'Medium Mathematical Space'
+  },
+  '0x2060': {
+    description: 'Word Joiner'
+  },
+  '0x2061': {
+    description: 'Function Application'
+  },
+  '0x2062': {
+    description: 'Invisible Times'
+  },
+  '0x2063': {
+    description: 'Invisible Separator'
+  },
+  '0x2064': {
+    description: 'Invisible Plus'
+  },
+  '0x2066': {
+    description: 'Left-to-Right Isolate'
+  },
+  '0x2067': {
+    description: 'Right-to-Left Isolate'
+  },
+  '0x2068': {
+    description: 'First Strong Isolate '
+  },
+  '0x2069': {
+    description: 'Pop Directional Isolate'
+  },
+  '0x206a': {
+    description: 'Inhibit Symmetric Swapping'
+  },
+  '0x206b': {
+    description: 'Activate Symmetric Swapping'
+  },
+  '0x206c': {
+    description: 'Inhibit Arabic Form Shaping'
+  },
+  '0x206d': {
+    description: 'Activate Arabic Form Shaping'
+  },
+  '0x206e': {
+    description: 'National Digit Shapes'
+  },
+  '0x206f': {
+    description: 'Nominal Digit Shapes'
+  },
+  '0x2800': {
+    description: 'Braille Pattern Blank'
+  },
+  '0x3000': {
+    description: 'Ideographic Space'
+  },
+  '0x3164': {
+    description: 'Hangul Filler'
+  },
+  '0xfe00': {
+    description: 'Variation Selector-1'
+  },
+  '0xfe01': {
+    description: 'Variation Selector-2'
+  },
+  '0xfe02': {
+    description: 'Variation Selector-3'
+  },
+  '0xfe03': {
+    description: 'Variation Selector-4'
+  },
+  '0xfe04': {
+    description: 'Variation Selector-5'
+  },
+  '0xfe05': {
+    description: 'Variation Selector-6'
+  },
+  '0xfe06': {
+    description: 'Variation Selector-7'
+  },
+  '0xfe07': {
+    description: 'Variation Selector-8'
+  },
+  '0xfe08': {
+    description: 'Variation Selector-9'
+  },
+  '0xfe09': {
+    description: 'Variation Selector-10'
+  },
+  '0xfe0a': {
+    description: 'Variation Selector-11'
+  },
+  '0xfe0b': {
+    description: 'Variation Selector-12 '
+  },
+  '0xfe0c': {
+    description: 'Variation Selector-13'
+  },
+  '0xfe0d': {
+    description: 'Variation Selector-14'
+  },
+  '0xfe0e': {
+    description: 'Variation Selector-15'
+  },
+  '0xfe0f': {
+    description: 'Variation Selector-16'
+  },
+  '0xfeff': {
+    description: 'Zero Width No-Break Space'
+  },
+  '0xfffc': {
+    description: 'Object Replacement Character'
+  }
+}

src/utils/index.ts

@@ -1,3 +1,8 @@
+export * from './asyncForEach'
 export * from './getLintConfig'
 export * from './getProjectRoot'
+export * from './gremlinCharacters'
+export * from './isIgnored'
 export * from './listSasFiles'
+export * from './splitText'
+export * from './getIndicesOf'

src/utils/isIgnored.spec.ts

@@ -0,0 +1,119 @@
+import path from 'path'
+import * as fileModule from '@sasjs/utils/file'
+import * as getLintConfigModule from './getLintConfig'
+import { getProjectRoot, DefaultLintConfiguration, isIgnored } from '.'
+import { LintConfig } from '../types'
+
+describe('isIgnored', () => {
+  it('should return true if provided path matches the patterns from .gitignore', async () => {
+    jest
+      .spyOn(getLintConfigModule, 'getLintConfig')
+      .mockImplementationOnce(
+        async () => new LintConfig(DefaultLintConfiguration)
+      )
+    jest
+      .spyOn(fileModule, 'fileExists')
+      .mockImplementationOnce(async () => true)
+
+    jest
+      .spyOn(fileModule, 'readFile')
+      .mockImplementationOnce(async () => 'sasjs')
+
+    const projectRoot = await getProjectRoot()
+    const pathToTest = path.join(projectRoot, 'sasjs')
+
+    const ignored = await isIgnored(pathToTest)
+
+    expect(ignored).toBeTruthy()
+  })
+
+  it('should return true if top level path of provided path is in .gitignore', async () => {
+    jest
+      .spyOn(getLintConfigModule, 'getLintConfig')
+      .mockImplementationOnce(
+        async () => new LintConfig(DefaultLintConfiguration)
+      )
+    jest
+      .spyOn(fileModule, 'fileExists')
+      .mockImplementationOnce(async () => true)
+
+    jest
+      .spyOn(fileModule, 'readFile')
+      .mockImplementationOnce(async () => 'sasjs/common')
+
+    const projectRoot = await getProjectRoot()
+    const pathToTest = path.join(projectRoot, 'sasjs/common/init/init.sas')
+
+    const ignored = await isIgnored(pathToTest)
+
+    expect(ignored).toBeTruthy()
+  })
+
+  it('should return true if provided path matches any pattern from ignoreList (.sasjslint)', async () => {
+    jest
+      .spyOn(fileModule, 'fileExists')
+      .mockImplementationOnce(async () => false)
+
+    const projectRoot = await getProjectRoot()
+    const pathToTest = path.join(projectRoot, 'sasjs')
+
+    const ignored = await isIgnored(
+      pathToTest,
+      new LintConfig({
+        ...DefaultLintConfiguration,
+        ignoreList: ['sasjs']
+      })
+    )
+
+    expect(ignored).toBeTruthy()
+  })
+
+  it('should return true if top level path of provided path is in ignoreList (.sasjslint)', async () => {
+    jest
+      .spyOn(fileModule, 'fileExists')
+      .mockImplementationOnce(async () => false)
+
+    const projectRoot = await getProjectRoot()
+    const pathToTest = path.join(projectRoot, 'sasjs/common/init/init.sas')
+
+    const ignored = await isIgnored(
+      pathToTest,
+      new LintConfig({
+        ...DefaultLintConfiguration,
+        ignoreList: ['sasjs']
+      })
+    )
+
+    expect(ignored).toBeTruthy()
+  })
+
+  it('should return false if provided path does not matches any pattern from .gitignore and ignoreList (.sasjslint)', async () => {
+    jest
+      .spyOn(fileModule, 'fileExists')
+      .mockImplementationOnce(async () => true)
+
+    jest.spyOn(fileModule, 'readFile').mockImplementationOnce(async () => '')
+
+    const projectRoot = await getProjectRoot()
+    const pathToTest = path.join(projectRoot, 'sasjs')
+
+    const ignored = await isIgnored(
+      pathToTest,
+      new LintConfig(DefaultLintConfiguration)
+    )
+
+    expect(ignored).toBeFalsy()
+  })
+
+  it('should return false if provided path is equal to projectRoot', async () => {
+    const projectRoot = await getProjectRoot()
+    const pathToTest = path.join(projectRoot, '')
+
+    const ignored = await isIgnored(
+      pathToTest,
+      new LintConfig(DefaultLintConfiguration)
+    )
+
+    expect(ignored).toBeFalsy()
+  })
+})

src/utils/isIgnored.ts

@@ -0,0 +1,34 @@
+import { fileExists, readFile } from '@sasjs/utils'
+import path from 'path'
+import ignore from 'ignore'
+import { getLintConfig, getProjectRoot } from '.'
+import { LintConfig } from '../types'
+
+/**
+ * A function to check if file/folder path matches any pattern from .gitignore or ignoreList (.sasjsLint)
+ *
+ * @param {string} fPath - absolute path of file or folder
+ * @returns {Promise<boolean>} true if path matches the patterns from .gitignore file otherwise false
+ */
+export const isIgnored = async (
+  fPath: string,
+  configuration?: LintConfig
+): Promise<boolean> => {
+  const config = configuration || (await getLintConfig())
+  const projectRoot = await getProjectRoot()
+  const gitIgnoreFilePath = path.join(projectRoot, '.gitignore')
+  const rootPath = projectRoot + path.sep
+  const relativePath = fPath.replace(rootPath, '')
+
+  if (fPath === projectRoot) return false
+
+  let gitIgnoreFileContent = ''
+
+  if (await fileExists(gitIgnoreFilePath))
+    gitIgnoreFileContent = await readFile(gitIgnoreFilePath)
+
+  return ignore()
+    .add(gitIgnoreFileContent)
+    .add(config.ignoreList)
+    .ignores(relativePath)
+}

src/utils/listSasFiles.ts

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

src/utils/parseMacros.spec.ts

@@ -0,0 +1,279 @@
+import { LintConfig } from '../types'
+import { parseMacros } from './parseMacros'
+
+describe('parseMacros', () => {
+  it('should return an array with a single macro', () => {
+    const text = ` %macro test;\n  %put 'hello';\n%mend`
+
+    const macros = parseMacros(text, new LintConfig())
+
+    expect(macros.length).toEqual(1)
+    expect(macros).toContainEqual({
+      name: 'test',
+      declarationLines: [' %macro test;'],
+      terminationLine: '%mend',
+      declaration: '%macro test',
+      termination: '%mend',
+      startLineNumbers: [1],
+      endLineNumber: 3,
+      parentMacro: '',
+      hasMacroNameInMend: false,
+      mismatchedMendMacroName: ''
+    })
+  })
+
+  it('should return an array with a single macro having parameters', () => {
+    const text = `%macro test(var,sum);\n  %put 'hello';\n%mend`
+
+    const macros = parseMacros(text, new LintConfig())
+
+    expect(macros.length).toEqual(1)
+    expect(macros).toContainEqual({
+      name: 'test',
+      declarationLines: ['%macro test(var,sum);'],
+      terminationLine: '%mend',
+      declaration: '%macro test(var,sum)',
+      termination: '%mend',
+      startLineNumbers: [1],
+      endLineNumber: 3,
+      parentMacro: '',
+      hasMacroNameInMend: false,
+      mismatchedMendMacroName: ''
+    })
+  })
+
+  it('should return an array with a single macro having PARMBUFF option', () => {
+    const text = `%macro test/parmbuff;\n  %put 'hello';\n%mend`
+
+    const macros = parseMacros(text, new LintConfig())
+
+    expect(macros.length).toEqual(1)
+    expect(macros).toContainEqual({
+      name: 'test',
+      declarationLines: ['%macro test/parmbuff;'],
+      terminationLine: '%mend',
+      declaration: '%macro test/parmbuff',
+      termination: '%mend',
+      startLineNumbers: [1],
+      endLineNumber: 3,
+      parentMacro: '',
+      hasMacroNameInMend: false,
+      mismatchedMendMacroName: ''
+    })
+  })
+
+  it('should return an array with a single macro having paramerter & SOURCE option', () => {
+    const text = `/* commentary */  %macro foobar(arg) /store source\n      des="This macro does not do much";\n  %put 'hello';\n%mend`
+
+    const macros = parseMacros(text, new LintConfig())
+
+    expect(macros.length).toEqual(1)
+    expect(macros).toContainEqual({
+      name: 'foobar',
+      declarationLines: [
+        '/* commentary */  %macro foobar(arg) /store source',
+        '      des="This macro does not do much";'
+      ],
+      terminationLine: '%mend',
+      declaration:
+        '%macro foobar(arg) /store source des="This macro does not do much"',
+      termination: '%mend',
+      startLineNumbers: [1, 2],
+      endLineNumber: 4,
+      parentMacro: '',
+      hasMacroNameInMend: false,
+      mismatchedMendMacroName: ''
+    })
+  })
+
+  it('should return an array with multiple macros', () => {
+    const text = `%macro foo;\n  %put 'foo';\n%mend;\n%macro bar();\n  %put 'bar';\n%mend bar;`
+
+    const macros = parseMacros(text, new LintConfig())
+
+    expect(macros.length).toEqual(2)
+    expect(macros).toContainEqual({
+      name: 'foo',
+      declarationLines: ['%macro foo;'],
+      terminationLine: '%mend;',
+      declaration: '%macro foo',
+      termination: '%mend',
+      startLineNumbers: [1],
+      endLineNumber: 3,
+      parentMacro: '',
+      hasMacroNameInMend: false,
+      mismatchedMendMacroName: ''
+    })
+    expect(macros).toContainEqual({
+      name: 'bar',
+      declarationLines: ['%macro bar();'],
+      terminationLine: '%mend bar;',
+      declaration: '%macro bar()',
+      termination: '%mend bar',
+      startLineNumbers: [4],
+      endLineNumber: 6,
+      parentMacro: '',
+      hasMacroNameInMend: true,
+      mismatchedMendMacroName: ''
+    })
+  })
+
+  it('should detect nested macro definitions', () => {
+    const text = `%macro test();\n  %put 'hello';\n  %macro test2;\n    %put 'world;\n  %mend\n%mend test`
+
+    const macros = parseMacros(text, new LintConfig())
+
+    expect(macros.length).toEqual(2)
+    expect(macros).toContainEqual({
+      name: 'test',
+      declarationLines: ['%macro test();'],
+      terminationLine: '%mend test',
+      declaration: '%macro test()',
+      termination: '%mend test',
+      startLineNumbers: [1],
+      endLineNumber: 6,
+      parentMacro: '',
+      hasMacroNameInMend: true,
+      mismatchedMendMacroName: ''
+    })
+    expect(macros).toContainEqual({
+      name: 'test2',
+      declarationLines: ['  %macro test2;'],
+      terminationLine: '  %mend',
+      declaration: '%macro test2',
+      termination: '%mend',
+      startLineNumbers: [3],
+      endLineNumber: 5,
+      parentMacro: 'test',
+      hasMacroNameInMend: false,
+      mismatchedMendMacroName: ''
+    })
+  })
+
+  describe(`multi-line macro declarations`, () => {
+    it('should return an array with a single macro', () => {
+      const text = `%macro \n      test;\n  %put 'hello';\n%mend`
+
+      const macros = parseMacros(text, new LintConfig())
+
+      expect(macros.length).toEqual(1)
+      expect(macros).toContainEqual({
+        name: 'test',
+        declarationLines: ['%macro ', '      test;'],
+        terminationLine: '%mend',
+        declaration: '%macro test',
+        termination: '%mend',
+        startLineNumbers: [1, 2],
+        endLineNumber: 4,
+        parentMacro: '',
+        hasMacroNameInMend: false,
+        mismatchedMendMacroName: ''
+      })
+    })
+
+    it('should return an array with a single macro having parameters', () => {
+      const text = `%macro \n      test(\n        var,\n        sum);%put 'hello';\n%mend`
+
+      const macros = parseMacros(text, new LintConfig())
+
+      expect(macros.length).toEqual(1)
+      expect(macros).toContainEqual({
+        name: 'test',
+        declarationLines: [
+          '%macro ',
+          `      test(`,
+          `        var,`,
+          `        sum);%put 'hello';`
+        ],
+        terminationLine: '%mend',
+        declaration: '%macro test( var, sum)',
+        termination: '%mend',
+        startLineNumbers: [1, 2, 3, 4],
+        endLineNumber: 5,
+        parentMacro: '',
+        hasMacroNameInMend: false,
+        mismatchedMendMacroName: ''
+      })
+    })
+
+    it('should return an array with a single macro having PARMBUFF option', () => {
+      const text = `%macro test\n      /parmbuff;\n  %put 'hello';\n%mend`
+
+      const macros = parseMacros(text, new LintConfig())
+
+      expect(macros.length).toEqual(1)
+      expect(macros).toContainEqual({
+        name: 'test',
+        declarationLines: ['%macro test', '      /parmbuff;'],
+        terminationLine: '%mend',
+        declaration: '%macro test /parmbuff',
+        termination: '%mend',
+        startLineNumbers: [1, 2],
+        endLineNumber: 4,
+        parentMacro: '',
+        hasMacroNameInMend: false,
+        mismatchedMendMacroName: ''
+      })
+    })
+
+    it('should return an array with a single macro having paramerter & SOURCE option', () => {
+      const text = `/* commentary */  %macro foobar/* commentary */(arg) \n      /* commentary */\n      /store\n      /* commentary */source\n      des="This macro does not do much";\n  %put 'hello';\n%mend`
+
+      const macros = parseMacros(text, new LintConfig())
+
+      expect(macros.length).toEqual(1)
+      expect(macros).toContainEqual({
+        name: 'foobar',
+        declarationLines: [
+          '/* commentary */  %macro foobar/* commentary */(arg) ',
+          '      /* commentary */',
+          '      /store',
+          '      /* commentary */source',
+          '      des="This macro does not do much";'
+        ],
+        terminationLine: '%mend',
+        declaration:
+          '%macro foobar(arg) /store source des="This macro does not do much"',
+        termination: '%mend',
+        startLineNumbers: [1, 2, 3, 4, 5],
+        endLineNumber: 7,
+        parentMacro: '',
+        hasMacroNameInMend: false,
+        mismatchedMendMacroName: ''
+      })
+    })
+
+    it('should return an array with a single macro having semi-colon in params', () => {
+      const text = `\n%macro mm_createapplication(\n    tree=/User Folders/sasdemo\n    ,name=myApp\n    ,ClassIdentifier=mcore\n    ,desc=Created by mm_createapplication\n    ,params= param1=1
param2=blah\n    ,version=\n    ,frefin=mm_in\n    ,frefout=mm_out\n    ,mDebug=1\n    );`
+
+      const macros = parseMacros(text, new LintConfig())
+
+      expect(macros.length).toEqual(1)
+      expect(macros).toContainEqual({
+        name: 'mm_createapplication',
+        declarationLines: [
+          `%macro mm_createapplication(`,
+          `    tree=/User Folders/sasdemo`,
+          `    ,name=myApp`,
+          `    ,ClassIdentifier=mcore`,
+          `    ,desc=Created by mm_createapplication`,
+          `    ,params= param1=1
param2=blah`,
+          `    ,version=`,
+          `    ,frefin=mm_in`,
+          `    ,frefout=mm_out`,
+          `    ,mDebug=1`,
+          `    );`
+        ],
+        terminationLine: '',
+        declaration:
+          '%macro mm_createapplication( tree=/User Folders/sasdemo ,name=myApp ,ClassIdentifier=mcore ,desc=Created by mm_createapplication ,params= param1=1
param2=blah ,version= ,frefin=mm_in ,frefout=mm_out ,mDebug=1 )',
+        termination: '',
+        startLineNumbers: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
+        endLineNumber: null,
+        parentMacro: '',
+        hasMacroNameInMend: false,
+        mismatchedMendMacroName: ''
+      })
+    })
+  })
+})

src/utils/parseMacros.ts

@@ -0,0 +1,151 @@
+import { LintConfig, Macro } from '../types'
+import { LineEndings } from '../types/LineEndings'
+import { trimComments } from './trimComments'
+
+export const parseMacros = (text: string, config?: LintConfig): Macro[] => {
+  const lineEnding = config?.lineEndings === LineEndings.CRLF ? '\r\n' : '\n'
+  const lines: string[] = text ? text.split(lineEnding) : []
+  const macros: Macro[] = []
+
+  let isCommentStarted = false
+  let macroStack: Macro[] = []
+  let isReadingMacroDefinition = false
+  let isStatementContinues = true
+  let tempMacroDeclaration = ''
+  let tempMacroDeclarationLines: string[] = []
+  let tempStartLineNumbers: number[] = []
+  lines.forEach((line, lineIndex) => {
+    const { statement: trimmedLine, commentStarted } = trimComments(
+      line,
+      isCommentStarted
+    )
+    isCommentStarted = commentStarted
+
+    isStatementContinues = !trimmedLine.endsWith(';')
+
+    const statements: string[] = trimmedLine.split(';')
+
+    if (isReadingMacroDefinition) {
+      // checking if code is split into statements based on `;` is a part of HTML Encoded Character
+      // if it happened, merges two statements into one
+      statements.forEach((statement, statementIndex) => {
+        if (/&[^\s]{1,5}$/.test(statement)) {
+          const next = statements[statementIndex]
+          const updatedStatement = `${statement};${
+            statements[statementIndex + 1]
+          }`
+          statements.splice(statementIndex, 1, updatedStatement)
+          statements.splice(statementIndex + 1, 1)
+        }
+      })
+    }
+
+    statements.forEach((statement, statementIndex) => {
+      const { statement: trimmedStatement, commentStarted } = trimComments(
+        statement,
+        isCommentStarted
+      )
+      isCommentStarted = commentStarted
+
+      if (isReadingMacroDefinition) {
+        tempMacroDeclaration =
+          tempMacroDeclaration +
+          (trimmedStatement ? ' ' + trimmedStatement : '')
+        tempMacroDeclarationLines.push(line)
+        tempStartLineNumbers.push(lineIndex + 1)
+
+        if (!Object.is(statements.length - 1, statementIndex)) {
+          isReadingMacroDefinition = false
+
+          const name = tempMacroDeclaration
+            .slice(7, tempMacroDeclaration.length)
+            .trim()
+            .split('/')[0]
+            .split('(')[0]
+            .trim()
+          macroStack.push({
+            name,
+            startLineNumbers: tempStartLineNumbers,
+            endLineNumber: null,
+            parentMacro: macroStack.length
+              ? macroStack[macroStack.length - 1].name
+              : '',
+            hasMacroNameInMend: false,
+            mismatchedMendMacroName: '',
+            declarationLines: tempMacroDeclarationLines,
+            terminationLine: '',
+            declaration: tempMacroDeclaration,
+            termination: ''
+          })
+        }
+      }
+
+      if (trimmedStatement.startsWith('%macro')) {
+        const startLineNumber = lineIndex + 1
+
+        if (
+          isStatementContinues &&
+          Object.is(statements.length - 1, statementIndex)
+        ) {
+          tempMacroDeclaration = trimmedStatement
+          tempMacroDeclarationLines = [line]
+          tempStartLineNumbers = [startLineNumber]
+          isReadingMacroDefinition = true
+          return
+        }
+
+        const name = trimmedStatement
+          .slice(7, trimmedStatement.length)
+          .trim()
+          .split('/')[0]
+          .split('(')[0]
+          .trim()
+        macroStack.push({
+          name,
+          startLineNumbers: [startLineNumber],
+          endLineNumber: null,
+          parentMacro: macroStack.length
+            ? macroStack[macroStack.length - 1].name
+            : '',
+          hasMacroNameInMend: false,
+          mismatchedMendMacroName: '',
+          declarationLines: [line],
+          terminationLine: '',
+          declaration: trimmedStatement,
+          termination: ''
+        })
+      } else if (trimmedStatement.startsWith('%mend')) {
+        if (macroStack.length) {
+          const macro = macroStack.pop() as Macro
+          const mendMacroName =
+            trimmedStatement.split(' ').filter((s: string) => !!s)[1] || ''
+          macro.endLineNumber = lineIndex + 1
+          macro.hasMacroNameInMend = mendMacroName === macro.name
+          macro.mismatchedMendMacroName = macro.hasMacroNameInMend
+            ? ''
+            : mendMacroName
+          macro.terminationLine = line
+          macro.termination = trimmedStatement
+          macros.push(macro)
+        } else {
+          macros.push({
+            name: '',
+            startLineNumbers: [],
+            endLineNumber: lineIndex + 1,
+            parentMacro: '',
+            hasMacroNameInMend: false,
+            mismatchedMendMacroName: '',
+            declarationLines: [],
+            terminationLine: line,
+            declaration: '',
+            termination: trimmedStatement
+          })
+        }
+      }
+    })
+  })
+
+  macros.push(...macroStack)
+
+  return macros
+}

src/utils/splitText.spec.ts

@@ -0,0 +1,41 @@
+import { LintConfig } from '../types'
+import { splitText } from './splitText'
+
+describe('splitText', () => {
+  const config = new LintConfig({
+    noTrailingSpaces: true,
+    noEncodedPasswords: true,
+    hasDoxygenHeader: true,
+    noSpacesInFileNames: true,
+    maxLineLength: 80,
+    lowerCaseFileNames: true,
+    noTabIndentation: true,
+    indentationMultiple: 2,
+    hasMacroNameInMend: true,
+    noNestedMacros: true,
+    hasMacroParentheses: true,
+    lineEndings: 'lf'
+  })
+
+  it('should return an empty array when text is falsy', () => {
+    const lines = splitText('', config)
+
+    expect(lines.length).toEqual(0)
+  })
+
+  it('should return an array of lines from text', () => {
+    const lines = splitText(`line 1\nline 2`, config)
+
+    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`, config)
+
+    expect(lines.length).toEqual(2)
+    expect(lines[0]).toEqual('line 1')
+    expect(lines[1]).toEqual('line 2')
+  })
+})

src/utils/splitText.ts

@@ -0,0 +1,26 @@
+import { LintConfig } from '../types/LintConfig'
+import { LineEndings } from '../types/LineEndings'
+
+/**
+ * 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, config: LintConfig): string[] => {
+  if (!text) return []
+
+  const expectedLineEndings =
+    config.lineEndings === LineEndings.LF ? '\n' : '\r\n'
+
+  const incorrectLineEndings = expectedLineEndings === '\n' ? '\r\n' : '\n'
+
+  text = text.replace(
+    new RegExp(incorrectLineEndings, 'g'),
+    expectedLineEndings
+  )
+
+  // splitting text on '\r\n' was causing some problem
+  // as it was retaining carriage return at the end of each line
+  // so, removed the carriage returns from text and splitted on line feed (lf)
+  return text.replace(/\r/g, '').split(/\n/)
+}

src/utils/trimComments.spec.ts

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

src/utils/trimComments.ts

@@ -0,0 +1,38 @@
+export const trimComments = (
+  statement: string,
+  commentStarted: boolean = false,
+  trimEnd: boolean = false
+): { statement: string; commentStarted: boolean } => {
+  let trimmed = trimEnd ? (statement || '').trimEnd() : (statement || '').trim()
+
+  if (commentStarted || trimmed.startsWith('/*')) {
+    const parts = trimmed.startsWith('/*')
+      ? trimmed.slice(2).split('*/')
+      : trimmed.split('*/')
+    if (parts.length === 2) {
+      return {
+        statement: (parts.pop() as string).trim(),
+        commentStarted: false
+      }
+    } else if (parts.length > 2) {
+      parts.shift()
+      return trimComments(parts.join('*/'), false)
+    } else {
+      return { statement: '', commentStarted: true }
+    }
+  } else if (trimmed.includes('/*')) {
+    const statementBeforeCommentStarts = trimmed.slice(0, trimmed.indexOf('/*'))
+    trimmed = trimmed.slice(trimmed.indexOf('/*') + 2)
+    const remainingStatement = trimmed.slice(trimmed.indexOf('*/') + 2)
+
+    const result = trimComments(remainingStatement, false, true)
+    const completeStatement = statementBeforeCommentStarts + result.statement
+    return {
+      statement: trimEnd
+        ? completeStatement.trimEnd()
+        : completeStatement.trim(),
+      commentStarted: result.commentStarted
+    }
+  }
+  return { statement: trimmed, commentStarted: false }
+}