Merge pull request #210 from sasjs/issue-209

feat: support a user-level ~/.sasjslint
2025-12-10 17:34:36 +00:00 · 2023-04-13 11:08:32 +01:00 · 2023-04-12 23:06:08 +05:00 · 2023-02-22 14:29:01 +00:00 · 2023-02-22 14:13:46 +00:00 · 2023-02-22 12:03:31 +00:00
48 changed files with 2574 additions and 10067 deletions
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
      - name: Install Dependencies
        run: npm ci
      - name: Check Code Style
@@ -21,7 +21,7 @@ jobs:
      - name: Build Project
        run: npm run build
      - name: Semantic Release
-        uses: cycjimmy/semantic-release-action@v2
+        uses: cycjimmy/semantic-release-action@v3
        env:
          GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/README.md
+++ b/README.md
@@ -1,4 +1,3 @@
-[![License](https://img.shields.io/apm/l/atomic-design-ui.svg)](/LICENSE)
 ![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)
@@ -9,40 +8,67 @@

 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/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/vscode-extension](https://github.com/sasjs/vscode-extension) - just download SASjs in the VSCode marketplace, and select view/problems in the menu bar.
+- [@sasjs/cli](https://cli.sasjs.io/lint) - run `sasjs lint` to get a list of all files with their problems, along with line and column indexes.

 Configuration is via a `.sasjslint` file with the following structure (these are also the defaults if no .sasjslint file is found):

 ```json
 {
-    "noEncodedPasswords": true,
-    "hasDoxygenHeader": true,
-    "hasMacroNameInMend": true,
-    "hasMacroParentheses": true,
-    "ignoreList": [
-      "sajsbuild/",
-      "sasjsresults/"
-    ],
-    "indentationMultiple": 2,
-    "lowerCaseFileNames": true,
-    "maxLineLength": 80,
-    "noNestedMacros": true,
-    "noSpacesInFileNames": true,
-    "noTabIndentation": true,
-    "noTrailingSpaces": true,
-    "defaultHeader": "/**{lineEnding}  @file{lineEnding}  @brief <Your brief here>{lineEnding}  <h4> SAS Macros </h4>{lineEnding}**/"
+  "noEncodedPasswords": true,
+  "hasDoxygenHeader": true,
+  "hasMacroNameInMend": true,
+  "hasMacroParentheses": true,
+  "ignoreList": ["sasjsbuild/", "sasjsresults/"],
+  "indentationMultiple": 2,
+  "lineEndings": "off",
+  "lowerCaseFileNames": true,
+  "maxDataLineLength": 80,
+  "maxHeaderLineLength": 80,
+  "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

-#### defaultHeader
+Each setting can have three states:

-This sets the default program header - applies when a SAS program does NOT begin with `/**`.  The default header is as follows:
+- 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
+
+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.
+
+Configuring a non-zero return code (ERROR) is helpful when running `sasjs lint` as part of a git pre-commit hook.  An example is available [here](https://github.com/sasjs/template_jobs/blob/main/.git-hooks/pre-commit).
+
+### allowedGremlins
+
+An array of hex codes that represents allowed gremlins (invisible / undesirable characters). To allow all gremlins, you can also set the `noGremlins` rule to `false`.  The full gremlin list is [here](https://github.com/sasjs/lint/blob/main/src/utils/gremlinCharacters.ts).
+
+Example:
+
+```json
+{
+  "noGremlins": true,
+  "allowedGremlins": ["0x0080", "0x3000"]
+}
+```
+
+### defaultHeader
+
+This isn't a rule, but 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
 /**
@@ -52,7 +78,7 @@ This sets the default program header - applies when a SAS program does NOT begin
 **/
 ```

-The default header is automatically applied when running `sasjs lint fix` in the SASjs CLI, or by hitting "save" when using the SASjs VS Code extension.  If creating a new value, use `{lineEnding}` instead of `\n`, eg as follows:
+If creating a new value, use `{lineEnding}` instead of `\n`, eg as follows:

 ```json
 {
@@ -60,129 +86,224 @@ The default header is automatically applied when running `sasjs lint fix` in the
 }
 ```

-#### noEncodedPasswords
+### noEncodedPasswords

-This will highlight any rows that contain a `{sas00X}` type password, or `{sasenc}`.  These passwords (especially 001 and 002) are NOT secure, and should NEVER be pushed to source control or saved to the filesystem without special permissions applied.
+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
+- 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.
+### hasDoxygenHeader

-* Default:  true
-* Severity: WARNING
+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.

-#### 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

-* Default:  true
-* Severity: WARNING
+### hasMacroNameInMend

-#### 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.
+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
+- 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.
+### 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.

-* Default:  2
-* Severity: WARNING
+- Default: 2
+- Severity: WARNING

-#### lowerCaseFileNames
-On *nix systems, it is imperative that autocall macros are in lowercase.  When sharing code between windows and *nix systems, the difference in case sensitivity can also be a cause of lost developer time.  For this reason, we recommend that sas filenames are always lowercase.
+### lineEndings

-* Default: true
-* Severity: WARNING
+This setting ensures the line endings in a file to conform the configured type. Possible values are `lf`, `crlf` and `off` (off means rule is set to be off). If the value is missing, null or undefined then the check would also be switched off (no default applied).

-#### maxLineLength
-Code becomes far more readable when line lengths are short.  The most compelling reason for short line lengths is to avoid the need to scroll when performing a side-by-side 'compare' between two files (eg as part of a GIT feature branch review).  A longer discussion on optimal code line length can be found [here](https://stackoverflow.com/questions/578059/studies-on-optimal-code-width)
+- Default: "off"
+- Severity: WARNING
+
+Example (to enforce unix line endings):
+
+```json
+{
+  "lineEndings": "lf"
+}
+```
+
+### lowerCaseFileNames
+
+On *nix systems, it is imperative that autocall macros are in lowercase. When sharing code between windows and *nix systems, the difference in case sensitivity can also be a cause of lost developer time. For this reason, we recommend that sas filenames are always lowercase.
+
+- Default: true
+- Severity: WARNING
+
+### maxDataLineLength
+
+Datalines can be very wide, so to avoid the need to increase `maxLineLength` for the entire project, it is possible to raise the line length limit for the data records only. On a related note, as a developer, you should also be aware that code submitted in batch may have a default line length limit which is lower than you expect. See this [usage note](https://support.sas.com/kb/15/883.html) (and thanks to [sasutils for reminding us](https://github.com/sasjs/lint/issues/47#issuecomment-1064340104)).
+
+This feature will work for the following statements:
+
+- cards
+- cards4
+- datalines
+- datalines4
+- parmcards
+- parmcards4
+
+The `maxDataLineLength` setting is always the _higher_ of `maxDataLineLength` and `maxLineLength` (if you set a lower number, it is ignored).
+
+- Default: 80
+- Severity: WARNING
+
+See also:
+
+- [hasDoxygenHeader](#hasdoxygenheader)
+- [maxHeaderLineLength](#maxheaderlinelength)
+- [maxLineLength](#maxlinelength)
+
+### maxHeaderLineLength
+
+In a program header it can be necessary to insert items such as URLs or markdown tables, that cannot be split over multiple lines. To avoid the need to increase `maxLineLength` for the entire project, it is possible to raise the line length limit for the header section only.
+
+The `maxHeaderLineLength` setting is always the _higher_ of `maxHeaderLineLength` and `maxLineLength` (if you set a lower number, it is ignored).
+
+- Default: 80
+- Severity: WARNING
+
+See also:
+
+- [hasDoxygenHeader](#hasdoxygenheader)
+- [maxDataLineLength](#maxdatalinelength)
+- [maxLineLength](#maxlinelength)
+
+### maxLineLength
+
+Code becomes far more readable when line lengths are short. The most compelling reason for short line lengths is to avoid the need to scroll when performing a side-by-side 'compare' between two files (eg as part of a GIT feature branch review). A longer discussion on optimal code line length can be found [here](https://stackoverflow.com/questions/578059/studies-on-optimal-code-width)

 In batch mode, long SAS code lines may also be truncated, causing hard-to-detect errors.

-We strongly recommend a line length limit, and set the bar at 80.  To turn this feature off, set the value to 0.
+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
+- Default: 80
+- 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.
+See also:

-* Default:  true
-* Severity: WARNING
+- [maxDataLineLength](#maxdatalinelength)
+- [maxHeaderLineLength](#maxheaderlinelength)
+
+### 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
-* The need to quote such filepaths in order to use them in CLI commands
+- Loss of the in-built ability to 'click' a filepath and have the file open automatically
+- The need to quote such filepaths in order to use them in CLI commands

-In addition, when such files are used in URLs, they are often padded with a messy "%20" type quotation.  And of course, for macros (where the macro should match the filename) then spaces are simply not valid.
+In addition, when such files are used in URLs, they are often padded with a messy "%20" type quotation. And of course, for macros (where the macro should match the filename) then spaces are simply not valid.

-* Default:  true
-* Severity: WARNING
+- Default: true
+- Severity: WARNING

-#### noTabIndentation
-Whilst there are some arguments for using tabs to indent (such as the ability to set your own indentation width, and to reduce character count) there are many, many, many developers who think otherwise.  We're in that camp.  Sorry (not sorry).
+As an alternative (or in addition) to using a lint rule, you can also set the following in your `.gitignore` file to prevent files with spaces from being committed:

-* Default:  true
-* Severity: WARNING
+```
+# prevent files/folders with spaces
+**\ **
+```

-#### noTrailingSpaces
-This will highlight lines with trailing spaces.  Trailing spaces serve no useful purpose in a SAS program.
+### noTabs

-* Default:  true
-* 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).

-### Upcoming Linting Rules:
+- Alias: noTabIndentation
+- Default: true
+- Severity: WARNING

-* `noTabs` -> does what it says on the tin
-* `noGremlins` -> identifies all invisible characters, other than spaces / tabs / line endings.  If you really need that bell character, use a hex literal!
-* `lineEndings` -> set a standard line ending, such as LF or CRLF
+### noTrailingSpaces

-## SAS Formatter
+This will highlight lines with trailing spaces. Trailing spaces serve no useful purpose in a SAS program.
+
+- Default: true
+- severity: WARNING
+
+## 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)
+
+# 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
+- 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:

-* Change tabs to spaces
-* zap gremlins
-* fix line endings
+- Change tabs to spaces
+- zap gremlins
+- fix line endings

 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 SAS 9 system.  Maybe you are preparing for a migration.  Maybe you are preparing to hand over the control of your environment.  Either way, an assessment of your existing system would put minds at rest and pro-actively identify trouble spots.
-
-The SAS 9 Health Check is a 'plug & play' product, that uses the [SAS 9 REST API](https://sas9api.io) to run hundreds of metadata and system checks to identify common problems.  The checks are non-invasive, and becuase it is a client app, there is NOTHING TO INSTALL on your SAS server.  We offer this assessment for a low fixed fee, and if you engage our (competitively priced) services to address the issues we highlight, then the assessment is free.
-
-Contact [Allan Bowe](https://www.linkedin.com/in/allanbowe/) for further details.
-
-
-
-## Contributors ✨
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
+
 [![All Contributors](https://img.shields.io/badge/all_contributors-8-orange.svg?style=flat-square)](#contributors-)
+
 <!-- 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 -->
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -39,16 +39,16 @@
  },
  "homepage": "https://github.com/sasjs/lint#readme",
  "devDependencies": {
-    "@types/jest": "^26.0.23",
-    "@types/node": "^15.12.2",
-    "all-contributors-cli": "^6.20.0",
-    "jest": "^26.6.3",
+    "@types/jest": "29.2.5",
+    "@types/node": "18.11.18",
+    "all-contributors-cli": "6.24.0",
+    "jest": "29.3.1",
    "rimraf": "^3.0.2",
-    "ts-jest": "^26.5.6",
+    "ts-jest": "29.0.3",
    "typescript": "^4.3.2"
  },
  "dependencies": {
-    "@sasjs/utils": "^2.19.0",
-    "ignore": "^5.2.0"
+    "@sasjs/utils": "2.52.0",
+    "ignore": "5.2.4"
  }
 }
--- a/sasjslint-schema.json
+++ b/sasjslint-schema.json
@@ -13,11 +13,14 @@
    "indentationMultiple": 2,
    "lowerCaseFileNames": true,
    "maxLineLength": 80,
+    "maxHeaderLineLength": 80,
+    "maxDataLineLength": 80,
+    "noGremlins": true,
    "noNestedMacros": true,
    "noSpacesInFileNames": true,
-    "noTabIndentation": true,
+    "noTabs": true,
    "noTrailingSpaces": true,
-    "lineEndings": "lf",
+    "lineEndings": "off",
    "strictMacroDefinition": true,
    "ignoreList": ["sajsbuild", "sasjsresults"]
  },
@@ -29,7 +32,11 @@
      "noSpacesInFileNames": true,
      "lowerCaseFileNames": true,
      "maxLineLength": 80,
-      "noTabIndentation": true,
+      "maxHeaderLineLength": 80,
+      "maxDataLineLength": 80,
+      "noGremlins": true,
+      "allowedGremlins": ["0x0080", "0x3000"],
+      "noTabs": true,
      "indentationMultiple": 4,
      "hasMacroNameInMend": true,
      "noNestedMacros": true,
@@ -58,12 +65,32 @@
    },
    "defaultHeader": {
      "$id": "#/properties/defaultHeader",
-      "type": "boolean",
+      "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": "noGremlins",
+      "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]
+    },
+    "allowedGremlins": {
+      "$id": "#/properties/allowedGremlins",
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^0x[0-9A-Fa-f]{4}$"
+      },
+      "title": "allowedGremlins",
+      "description": "An array of hex codes that represents allowed gremlins.",
+      "default": [],
+      "examples": ["0x0080", "0x3000"]
+    },
    "hasMacroNameInMend": {
      "$id": "#/properties/hasMacroNameInMend",
      "type": "boolean",
@@ -104,6 +131,22 @@
      "default": 80,
      "examples": [60, 80, 120]
    },
+    "maxHeaderLineLength": {
+      "$id": "#/properties/maxHeaderLineLength",
+      "type": "number",
+      "title": "maxHeaderLineLength",
+      "description": "Enforces a configurable maximum line length for header section. Shows a warning for lines exceeding this length.",
+      "default": 80,
+      "examples": [60, 80, 120]
+    },
+    "maxDataLineLength": {
+      "$id": "#/properties/maxDataLineLength",
+      "type": "number",
+      "title": "maxDataLineLength",
+      "description": "Enforces a configurable maximum line length for data section. Shows a warning for lines exceeding this length.",
+      "default": 80,
+      "examples": [60, 80, 120]
+    },
    "noNestedMacros": {
      "$id": "#/properties/noNestedMacros",
      "type": "boolean",
@@ -120,11 +163,11 @@
      "default": true,
      "examples": [true, false]
    },
-    "noTabIndentation": {
-      "$id": "#/properties/noTabIndentation",
+    "noTabs": {
+      "$id": "#/properties/noTabs",
      "type": "boolean",
-      "title": "noTabIndentation",
-      "description": "Enforces no indentation using tabs. Shows a warning when a line starts with a tab.",
+      "title": "noTabs",
+      "description": "Enforces no indentation using tabs. Shows a warning when a line contains a tab.",
      "default": true,
      "examples": [true, false]
    },
@@ -139,9 +182,10 @@
    "lineEndings": {
      "$id": "#/properties/lineEndings",
      "type": "string",
+      "enum": ["lf", "crlf", "off"],
      "title": "lineEndings",
      "description": "Enforces the configured terminating character for each line. Shows a warning when incorrect line endings are present.",
-      "default": "lf",
+      "default": "off",
      "examples": ["lf", "crlf"]
    },
    "strictMacroDefinition": {
@@ -159,6 +203,125 @@
      "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"
+        }
+      }
    }
  }
 }
--- a/src/format/formatFile.spec.ts
+++ b/src/format/formatFile.spec.ts
@@ -32,16 +32,8 @@ describe('formatFile', () => {
    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: 2,
-      unfixedDiagnostics: [
-        {
-          endColumnNumber: 7,
-          lineNumber: 8,
-          message: '%mend statement is missing macro name - somemacro',
-          severity: 1,
-          startColumnNumber: 1
-        }
-      ]
+      fixedDiagnosticsCount: 4,
+      unfixedDiagnostics: []
    }
    await createFile(path.join(__dirname, 'format-file-config.sas'), content)

--- a/src/format/formatFile.ts
+++ b/src/format/formatFile.ts
@@ -16,7 +16,7 @@ export const formatFile = async (
  configuration?: LintConfig
 ): Promise<FormatResult> => {
  const config = configuration || (await getLintConfig())
-  const diagnosticsBeforeFormat = await lintFile(filePath)
+  const diagnosticsBeforeFormat = await lintFile(filePath, config)
  const diagnosticsCountBeforeFormat = diagnosticsBeforeFormat.length

  const text = await readFile(filePath)
@@ -25,7 +25,7 @@ export const formatFile = async (

  await createFile(filePath, formattedText)

-  const diagnosticsAfterFormat = await lintFile(filePath)
+  const diagnosticsAfterFormat = await lintFile(filePath, config)
  const diagnosticsCountAfterFormat = diagnosticsAfterFormat.length

  const fixedDiagnosticsCount =
--- a/src/format/formatProject.ts
+++ b/src/format/formatProject.ts
@@ -8,11 +8,12 @@ import { formatFolder } from './formatFolder'
 * @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
+  const projectRoot = (await getProjectRoot()) || process.currentDir
  if (!projectRoot) {
    throw new Error('SASjs Project Root was not found.')
  }

+  console.info(`Formatting all .sas files under ${projectRoot}`)
+
  return await formatFolder(projectRoot)
 }
--- a/src/format/shared.ts
+++ b/src/format/shared.ts
@@ -30,7 +30,7 @@ export const processLine = (config: LintConfig, line: string): string => {
  config.lineLintRules
    .filter((r) => !!r.fix)
    .forEach((rule) => {
-      processedLine = rule.fix!(line, config)
+      processedLine = rule.fix!(processedLine, config)
    })

  return processedLine
--- a/src/lint/lintFile.spec.ts
+++ b/src/lint/lintFile.spec.ts
@@ -46,10 +46,10 @@ const expectedDiagnostics = [
    severity: Severity.Error
  },
  {
-    message: 'Line is indented with a tab',
+    message: 'Line contains a tab character (09x)',
    lineNumber: 7,
    startColumnNumber: 1,
-    endColumnNumber: 1,
+    endColumnNumber: 2,
    severity: Severity.Warning
  },
  {
--- a/src/lint/lintFolder.spec.ts
+++ b/src/lint/lintFolder.spec.ts
@@ -53,10 +53,10 @@ const expectedDiagnostics = [
    severity: Severity.Error
  },
  {
-    message: 'Line is indented with a tab',
+    message: 'Line contains a tab character (09x)',
    lineNumber: 7,
    startColumnNumber: 1,
-    endColumnNumber: 1,
+    endColumnNumber: 2,
    severity: Severity.Warning
  },
  {
--- a/src/lint/lintProject.spec.ts
+++ b/src/lint/lintProject.spec.ts
@@ -51,10 +51,10 @@ const expectedDiagnostics = [
    severity: Severity.Error
  },
  {
-    message: 'Line is indented with a tab',
+    message: 'Line contains a tab character (09x)',
    lineNumber: 7,
    startColumnNumber: 1,
-    endColumnNumber: 1,
+    endColumnNumber: 2,
    severity: Severity.Warning
  },
  {
--- a/src/lint/lintProject.ts
+++ b/src/lint/lintProject.ts
@@ -6,10 +6,12 @@ import { lintFolder } from './lintFolder'
 * @returns {Promise<Map<string, Diagnostic[]>>} Resolves with a map with array of diagnostic objects, each containing a warning, line number and column number, and grouped by file path.
 */
 export const lintProject = async () => {
-  const projectRoot =
-    (await getProjectRoot()) || process.projectDir || process.currentDir
+  const projectRoot = (await getProjectRoot()) || process.currentDir
  if (!projectRoot) {
    throw new Error('SASjs Project Root was not found.')
  }
+
+  console.info(`Linting all .sas files under ${projectRoot}`)
+
  return await lintFolder(projectRoot)
 }
--- a/src/lint/shared.ts
+++ b/src/lint/shared.ts
@@ -1,12 +1,19 @@
-import { LintConfig, Diagnostic } from '../types'
-import { splitText } from '../utils'
+import { LintConfig, Diagnostic, LineLintRuleOptions } from '../types'
+import { getHeaderLinesCount, splitText } from '../utils'
+import { checkIsDataLine, getDataSectionsDetail } from '../utils'

 export const processText = (text: string, config: LintConfig) => {
  const lines = splitText(text, config)
+  const headerLinesCount = getHeaderLinesCount(text, config)
+  const dataSections = getDataSectionsDetail(text, config)
  const diagnostics: Diagnostic[] = []
  diagnostics.push(...processContent(config, text))
  lines.forEach((line, index) => {
-    diagnostics.push(...processLine(config, line, index + 1))
+    const isHeaderLine = index + 1 <= headerLinesCount
+    const isDataLine = checkIsDataLine(dataSections, index)
+    diagnostics.push(
+      ...processLine(config, line, index + 1, { isHeaderLine, isDataLine })
+    )
  })

  return diagnostics
@@ -18,7 +25,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
@@ -27,7 +34,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
@@ -36,11 +43,12 @@ const processContent = (config: LintConfig, content: string): Diagnostic[] => {
 export const processLine = (
  config: LintConfig,
  line: string,
-  lineNumber: number
+  lineNumber: number,
+  options: LineLintRuleOptions
 ): Diagnostic[] => {
  const diagnostics: Diagnostic[] = []
  config.lineLintRules.forEach((rule) => {
-    diagnostics.push(...rule.test(line, lineNumber, config))
+    diagnostics.push(...rule.test(line, lineNumber, config, options))
  })

  return diagnostics
--- a/src/rules/file/hasDoxygenHeader.ts
+++ b/src/rules/file/hasDoxygenHeader.ts
@@ -11,8 +11,11 @@ const description =
 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 []
@@ -27,7 +30,7 @@ const test = (value: string, config?: LintConfig) => {
              .length + 1,
          startColumnNumber: 1,
          endColumnNumber: 1,
-          severity: Severity.Warning
+          severity
        }
      ]

@@ -37,7 +40,7 @@ const test = (value: string, config?: LintConfig) => {
        lineNumber: 1,
        startColumnNumber: 1,
        endColumnNumber: 1,
-        severity: Severity.Warning
+        severity
      }
    ]
  } catch (e) {
@@ -47,7 +50,7 @@ const test = (value: string, config?: LintConfig) => {
        lineNumber: 1,
        startColumnNumber: 1,
        endColumnNumber: 1,
-        severity: Severity.Warning
+        severity
      }
    ]
  }
--- a/src/rules/file/hasMacroNameInMend.ts
+++ b/src/rules/file/hasMacroNameInMend.ts
@@ -11,11 +11,14 @@ 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]
@@ -25,7 +28,7 @@ const test = (value: string, config?: LintConfig) => {
        startColumnNumber: getColumnNumber(endLine, '%mend'),
        endColumnNumber:
          getColumnNumber(endLine, '%mend') + macro.termination.length,
-        severity: Severity.Warning
+        severity
      })
    } else if (
      macro.endLineNumber === null &&
@@ -36,7 +39,7 @@ const test = (value: string, config?: LintConfig) => {
        lineNumber: macro.startLineNumbers![0],
        startColumnNumber: 1,
        endColumnNumber: 1,
-        severity: Severity.Warning
+        severity
      })
    } else if (macro.mismatchedMendMacroName) {
      const endLine = lines[(macro.endLineNumber as number) - 1]
@@ -53,7 +56,7 @@ const test = (value: string, config?: LintConfig) => {
          getColumnNumber(endLine, macro.mismatchedMendMacroName) +
          macro.mismatchedMendMacroName.length -
          1,
-        severity: Severity.Warning
+        severity
      })
    } else if (!macro.hasMacroNameInMend) {
      const endLine = lines[(macro.endLineNumber as number) - 1]
@@ -62,7 +65,7 @@ const test = (value: string, config?: LintConfig) => {
        lineNumber: macro.endLineNumber as number,
        startColumnNumber: getColumnNumber(endLine, '%mend'),
        endColumnNumber: getColumnNumber(endLine, '%mend') + 6,
-        severity: Severity.Warning
+        severity
      })
    }
  })
--- a/src/rules/file/hasMacroParentheses.ts
+++ b/src/rules/file/hasMacroParentheses.ts
@@ -9,9 +9,12 @@ 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({
@@ -24,7 +27,7 @@ const test = (value: string, config?: LintConfig) => {
        endColumnNumber:
          getColumnNumber(macro.declarationLines![0], '%macro') +
          macro.declaration.length,
-        severity: Severity.Warning
+        severity
      })
    } else if (!macro.declarationLines.find((dl) => dl.includes('('))) {
      const macroNameLineIndex = macro.declarationLines.findIndex((dl) =>
@@ -44,7 +47,7 @@ const test = (value: string, config?: LintConfig) => {
          ) +
          macro.name.length -
          1,
-        severity: Severity.Warning
+        severity
      })
    }
  })
--- a/src/rules/file/lineEndings.ts
+++ b/src/rules/file/lineEndings.ts
@@ -7,6 +7,7 @@ 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 =
@@ -18,8 +19,10 @@ const test = (value: string, config?: LintConfig) => {
    .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({
@@ -29,7 +32,7 @@ const test = (value: string, config?: LintConfig) => {
        lineNumber: index + 1 + indexOffset,
        startColumnNumber: line.indexOf(incorrectLineEnding),
        endColumnNumber: line.indexOf(incorrectLineEnding) + 1,
-        severity: Severity.Warning
+        severity
      })
    } else {
      const splitLine = line.split(new RegExp(`(?<=${incorrectLineEnding})`))
@@ -51,7 +54,7 @@ const test = (value: string, config?: LintConfig) => {
            lineNumber: index + i + 1,
            startColumnNumber: l.indexOf(incorrectLineEnding),
            endColumnNumber: l.indexOf(incorrectLineEnding) + 1,
-            severity: Severity.Warning
+            severity
          })
        }
      })
--- a/src/rules/file/noNestedMacros.ts
+++ b/src/rules/file/noNestedMacros.ts
@@ -10,11 +10,14 @@ 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) => {
@@ -34,7 +37,7 @@ const test = (value: string, config?: LintConfig) => {
          ) +
          lines[(macro.startLineNumbers![0] as number) - 1].trim().length -
          1,
-        severity: Severity.Warning
+        severity
      })
    })
  return diagnostics
--- a/src/rules/file/strictMacroDefinition.ts
+++ b/src/rules/file/strictMacroDefinition.ts
@@ -25,9 +25,11 @@ const validOptions = [
 const processParams = (
  content: string,
  macro: Macro,
-  diagnostics: Diagnostic[]
+  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)
@@ -88,7 +90,7 @@ const processParams = (
          lineNumber: paramLineNumber,
          startColumnNumber: paramStartIndex + 1,
          endColumnNumber: paramEndIndex,
-          severity: Severity.Warning
+          severity
        })
      }
    })
@@ -101,12 +103,14 @@ const processParams = (
 const processOptions = (
  _declaration: string,
  macro: Macro,
-  diagnostics: Diagnostic[]
+  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')
+    const regex = new RegExp(/=["|'](.*?)["|']/, 'g')

    let result = regex.exec(optionsPresent)

@@ -136,7 +140,7 @@ const processOptions = (
            startColumnNumber: declarationLine.indexOf(trimmedOption) + 1,
            endColumnNumber:
              declarationLine.indexOf(trimmedOption) + trimmedOption.length,
-            severity: Severity.Warning
+            severity
          })
        }
      })
@@ -149,9 +153,9 @@ const test = (value: string, config?: LintConfig) => {
  const macros = parseMacros(value, config)

  macros.forEach((macro) => {
-    const _declaration = processParams(value, macro, diagnostics)
+    const _declaration = processParams(value, macro, diagnostics, config)

-    processOptions(_declaration, macro, diagnostics)
+    processOptions(_declaration, macro, diagnostics, config)
  })

  return diagnostics
--- a/src/rules/line/indentationMultiple.ts
+++ b/src/rules/line/indentationMultiple.ts
@@ -6,9 +6,11 @@ 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
    }
  ]
 }
--- a/src/rules/line/index.ts
+++ b/src/rules/line/index.ts
@@ -1,5 +1,6 @@
+export { noGremlins } from './noGremlins'
 export { indentationMultiple } from './indentationMultiple'
 export { maxLineLength } from './maxLineLength'
 export { noEncodedPasswords } from './noEncodedPasswords'
-export { noTabIndentation } from './noTabIndentation'
+export { noTabs } from './noTabs'
 export { noTrailingSpaces } from './noTrailingSpaces'
--- a/src/rules/line/maxLineLength.spec.ts
+++ b/src/rules/line/maxLineLength.spec.ts
@@ -41,4 +41,44 @@ describe('maxLineLength', () => {
      'Prow scuttle parrel provost Sail ho shrouds spirits boom mizzenmast yard'
    expect(maxLineLength.test(line, 1)).toEqual([])
  })
+
+  it('should return an array with a single diagnostic when the line in header section exceeds the specified length', () => {
+    const line = 'This line is from header section'
+    const config = new LintConfig({
+      maxLineLength: 10,
+      maxHeaderLineLength: 15
+    })
+    expect(maxLineLength.test(line, 1, config, { isHeaderLine: true })).toEqual(
+      [
+        {
+          message: `Line exceeds maximum length by ${
+            line.length - config.maxHeaderLineLength
+          } characters`,
+          lineNumber: 1,
+          startColumnNumber: 1,
+          endColumnNumber: 1,
+          severity: Severity.Warning
+        }
+      ]
+    )
+  })
+
+  it('should return an array with a single diagnostic when the line in data section exceeds the specified length', () => {
+    const line = 'GROUP_LOGIC:$3. SUBGROUP_LOGIC:$3. SUBGROUP_ID:8.'
+    const config = new LintConfig({
+      maxLineLength: 10,
+      maxDataLineLength: 15
+    })
+    expect(maxLineLength.test(line, 1, config, { isDataLine: true })).toEqual([
+      {
+        message: `Line exceeds maximum length by ${
+          line.length - config.maxDataLineLength
+        } characters`,
+        lineNumber: 1,
+        startColumnNumber: 1,
+        endColumnNumber: 1,
+        severity: Severity.Warning
+      }
+    ])
+  })
 })
--- a/src/rules/line/maxLineLength.ts
+++ b/src/rules/line/maxLineLength.ts
@@ -1,13 +1,32 @@
 import { LintConfig } from '../../types'
-import { LineLintRule } from '../../types/LintRule'
+import { LineLintRule, LineLintRuleOptions } from '../../types/LintRule'
 import { LintRuleType } from '../../types/LintRuleType'
 import { Severity } from '../../types/Severity'
+import { DefaultLintConfiguration } from '../../utils'

 const name = 'maxLineLength'
 const description = 'Restrict lines to the specified length.'
 const message = 'Line exceeds maximum length'
-const test = (value: string, lineNumber: number, config?: LintConfig) => {
-  const maxLineLength = config?.maxLineLength || 80
+
+const test = (
+  value: string,
+  lineNumber: number,
+  config?: LintConfig,
+  options?: LineLintRuleOptions
+) => {
+  const severity = config?.severityLevel[name] || Severity.Warning
+  let maxLineLength = DefaultLintConfiguration.maxLineLength
+
+  if (config) {
+    if (options?.isHeaderLine) {
+      maxLineLength = Math.max(config.maxLineLength, config.maxHeaderLineLength)
+    } else if (options?.isDataLine) {
+      maxLineLength = Math.max(config.maxLineLength, config.maxDataLineLength)
+    } else {
+      maxLineLength = config.maxLineLength
+    }
+  }
+
  if (value.length <= maxLineLength) return []
  return [
    {
@@ -15,7 +34,7 @@ const test = (value: string, lineNumber: number, config?: LintConfig) => {
      lineNumber,
      startColumnNumber: 1,
      endColumnNumber: 1,
-      severity: Severity.Warning
+      severity
    }
  ]
 }
--- a/src/rules/line/noEncodedPasswords.ts
+++ b/src/rules/line/noEncodedPasswords.ts
@@ -1,3 +1,4 @@
+import { LintConfig } from '../../types'
 import { LineLintRule } from '../../types/LintRule'
 import { LintRuleType } from '../../types/LintRuleType'
 import { Severity } from '../../types/Severity'
@@ -5,7 +6,9 @@ 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
  }))
 }

--- a/src/rules/line/noGremlins.spec.ts
+++ b/src/rules/line/noGremlins.spec.ts
@@ -0,0 +1,26 @@
+import { noGremlins, charFromHex } from './noGremlins'
+import { LintConfig } from '../../types'
+
+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 = `${charFromHex('0x0080')} ${charFromHex(
+      '0x3000'
+    )} %put 'hello';`
+    const diagnostics = noGremlins.test(line, 1)
+    expect(diagnostics.length).toEqual(2)
+  })
+
+  it('should return an empty array when the line contains gremlins but those gremlins are allowed', () => {
+    const config = new LintConfig({ allowedGremlins: ['0x0080', '0x3000'] })
+    const line = `${charFromHex('0x0080')} ${charFromHex(
+      '0x3000'
+    )} %put 'hello';`
+    const diagnostics = noGremlins.test(line, 1, config)
+    expect(diagnostics.length).toEqual(0)
+  })
+})
--- a/src/rules/line/noGremlins.ts
+++ b/src/rules/line/noGremlins.ts
@@ -0,0 +1,63 @@
+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 allowedGremlins = config?.allowedGremlins || []
+
+  const diagnostics: Diagnostic[] = []
+
+  const gremlins: any = {}
+
+  for (const [hexCode, gremlinConfig] of Object.entries(gremlinCharacters)) {
+    if (!allowedGremlins.includes(hexCode)) {
+      gremlins[charFromHex(hexCode)] = Object.assign({}, gremlinConfig, {
+        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
+}
+
+export const charFromHex = (hexCode: string) =>
+  String.fromCodePoint(parseInt(hexCode))
--- a/src/rules/line/noTabIndentation.ts
+++ b/src/rules/line/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
-}
--- a/src/rules/line/noTabIndentation.spec.ts
+++ b/src/rules/line/noTabIndentation.spec.ts
@@ -1,20 +1,20 @@
 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
      }
    ])
--- a/src/rules/line/noTabs.ts
+++ b/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
+}
--- a/src/rules/line/noTrailingSpaces.ts
+++ b/src/rules/line/noTrailingSpaces.ts
@@ -1,3 +1,4 @@
+import { LintConfig } from '../../types'
 import { LineLintRule } from '../../types/LintRule'
 import { LintRuleType } from '../../types/LintRuleType'
 import { Severity } from '../../types/Severity'
@@ -5,8 +6,11 @@ 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,11 @@ 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()

 /**
--- a/src/rules/path/lowerCaseFileNames.ts
+++ b/src/rules/path/lowerCaseFileNames.ts
@@ -2,20 +2,25 @@ import { PathLintRule } from '../../types/LintRule'
 import { LintRuleType } from '../../types/LintRuleType'
 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
    }
  ]
 }
--- a/src/rules/path/noSpacesInFileNames.ts
+++ b/src/rules/path/noSpacesInFileNames.ts
@@ -2,12 +2,16 @@ import { PathLintRule } from '../../types/LintRule'
 import { LintRuleType } from '../../types/LintRuleType'
 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
      }
    ]
  }
--- a/src/types/LineEndings.ts
+++ b/src/types/LineEndings.ts
@@ -1,4 +1,5 @@
 export enum LineEndings {
  LF = 'lf',
-  CRLF = 'crlf'
+  CRLF = 'crlf',
+  OFF = 'off'
 }
--- a/src/types/LintConfig.spec.ts
+++ b/src/types/LintConfig.spec.ts
@@ -1,98 +1,100 @@
 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', () => {
-    const config = new LintConfig({ noTrailingSpaces: true })
+  it('should create an instance with the noTrailingSpaces flag off', () => {
+    const config = new LintConfig({ noTrailingSpaces: false })

    expect(config).toBeTruthy()
-    expect(config.lineLintRules.length).toEqual(1)
-    expect(config.lineLintRules[0].name).toEqual('noTrailingSpaces')
-    expect(config.lineLintRules[0].type).toEqual(LintRuleType.Line)
-    expect(config.fileLintRules.length).toEqual(0)
+    expect(config.lineLintRules.length).toBeGreaterThan(0)
+    expect(config.fileLintRules.length).toBeGreaterThan(0)
+    expect(
+      config.lineLintRules.find((rule) => rule.name === 'noTrailingSpaces')
+    ).toBeUndefined()
  })

-  it('should create an instance with the noEncodedPasswords flag set', () => {
-    const config = new LintConfig({ noEncodedPasswords: true })
+  it('should create an instance with the noEncodedPasswords flag off', () => {
+    const config = new LintConfig({ noEncodedPasswords: false })

    expect(config).toBeTruthy()
-    expect(config.lineLintRules.length).toEqual(1)
-    expect(config.lineLintRules[0].name).toEqual('noEncodedPasswords')
-    expect(config.lineLintRules[0].type).toEqual(LintRuleType.Line)
-    expect(config.fileLintRules.length).toEqual(0)
+    expect(config.lineLintRules.length).toBeGreaterThan(0)
+    expect(config.fileLintRules.length).toBeGreaterThan(0)
+    expect(
+      config.lineLintRules.find((rule) => rule.name === 'noEncodedPasswords')
+    ).toBeUndefined()
  })

-  it('should create an instance with the hasDoxygenHeader flag set', () => {
-    const config = new LintConfig({ hasDoxygenHeader: true })
+  it('should create an instance with the maxLineLength flag off by setting value to 0', () => {
+    const config = new LintConfig({ maxLineLength: 0 })

    expect(config).toBeTruthy()
-    expect(config.lineLintRules.length).toEqual(0)
-    expect(config.fileLintRules.length).toEqual(1)
-    expect(config.fileLintRules[0].name).toEqual('hasDoxygenHeader')
-    expect(config.fileLintRules[0].type).toEqual(LintRuleType.File)
+    expect(config.lineLintRules.length).toBeGreaterThan(0)
+    expect(config.fileLintRules.length).toBeGreaterThan(0)
+    expect(
+      config.lineLintRules.find((rule) => rule.name === 'maxLineLength')
+    ).toBeUndefined()
  })

-  it('should create an instance with the hasMacroNameInMend flag set', () => {
-    const config = new LintConfig({ hasMacroNameInMend: true })
+  it('should create an instance with the maxLineLength flag off by setting value to a negative number', () => {
+    const config = new LintConfig({ maxLineLength: -1 })

    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)
+    expect(config.lineLintRules.length).toBeGreaterThan(0)
+    expect(config.fileLintRules.length).toBeGreaterThan(0)
+    expect(
+      config.lineLintRules.find((rule) => rule.name === 'maxLineLength')
+    ).toBeUndefined()
+  })
+
+  it('should create an instance with the hasDoxygenHeader flag off', () => {
+    const config = new LintConfig({ hasDoxygenHeader: false })
+
+    expect(config).toBeTruthy()
+    expect(config.lineLintRules.length).toBeGreaterThan(0)
+    expect(config.fileLintRules.length).toBeGreaterThan(0)
+    expect(
+      config.fileLintRules.find((rule) => rule.name === 'hasDoxygenHeader')
+    ).toBeUndefined()
  })

  it('should create an instance with the hasMacroNameInMend flag off', () => {
    const config = new LintConfig({ hasMacroNameInMend: false })

    expect(config).toBeTruthy()
-    expect(config.lineLintRules.length).toEqual(0)
-    expect(config.fileLintRules.length).toEqual(0)
-  })
-
-  it('should create an instance with the noNestedMacros flag set', () => {
-    const config = new LintConfig({ noNestedMacros: true })
-
-    expect(config).toBeTruthy()
-    expect(config.lineLintRules.length).toEqual(0)
-    expect(config.fileLintRules.length).toEqual(1)
-    expect(config.fileLintRules[0].name).toEqual('noNestedMacros')
-    expect(config.fileLintRules[0].type).toEqual(LintRuleType.File)
+    expect(config.lineLintRules.length).toBeGreaterThan(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).toEqual(0)
-    expect(config.fileLintRules.length).toEqual(0)
-  })
-
-  it('should create an instance with the hasMacroParentheses flag set', () => {
-    const config = new LintConfig({ hasMacroParentheses: true })
-
-    expect(config).toBeTruthy()
-    expect(config.lineLintRules.length).toEqual(0)
-    expect(config.fileLintRules.length).toEqual(1)
-    expect(config.fileLintRules[0].name).toEqual('hasMacroParentheses')
-    expect(config.fileLintRules[0].type).toEqual(LintRuleType.File)
+    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).toEqual(0)
-    expect(config.fileLintRules.length).toEqual(0)
+    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', () => {
@@ -123,6 +125,23 @@ describe('LintConfig', () => {
    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({})

@@ -148,11 +167,13 @@ describe('LintConfig', () => {
      indentationMultiple: 2,
      hasMacroNameInMend: true,
      noNestedMacros: true,
-      hasMacroParentheses: true
+      hasMacroParentheses: true,
+      noGremlins: true,
+      lineEndings: 'lf'
    })

    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')
@@ -163,16 +184,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(4)
-    expect(config.fileLintRules[0].name).toEqual('hasDoxygenHeader')
+    expect(config.fileLintRules.length).toEqual(6)
+    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('noNestedMacros')
+    expect(config.fileLintRules[2].name).toEqual('hasMacroNameInMend')
    expect(config.fileLintRules[2].type).toEqual(LintRuleType.File)
-    expect(config.fileLintRules[3].name).toEqual('hasMacroParentheses')
+    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')
--- a/src/types/LintConfig.ts
+++ b/src/types/LintConfig.ts
@@ -10,13 +10,15 @@ import {
  indentationMultiple,
  maxLineLength,
  noEncodedPasswords,
-  noTabIndentation,
-  noTrailingSpaces
+  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.
@@ -27,13 +29,17 @@ import { getDefaultHeader } from '../utils'
 */
 export class LintConfig {
  readonly ignoreList: string[] = []
+  readonly allowedGremlins: string[] = []
  readonly lineLintRules: LineLintRule[] = []
  readonly fileLintRules: FileLintRule[] = []
  readonly pathLintRules: PathLintRule[] = []
  readonly maxLineLength: number = 80
+  readonly maxHeaderLineLength: number = 80
+  readonly maxDataLineLength: 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?.ignoreList) {
@@ -50,24 +56,33 @@ export class LintConfig {
      }
    }

-    if (json?.noTrailingSpaces) {
+    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(noTabIndentation)
+    this.lineLintRules.push(noTabs)
+    if (json?.noTabs === false || json?.noTabIndentation === false) {
+      this.lineLintRules.pop()
    }

-    if (json?.maxLineLength) {
-      this.maxLineLength = json.maxLineLength
+    if (json?.maxLineLength > 0) {
      this.lineLintRules.push(maxLineLength)
+      this.maxLineLength = json.maxLineLength
+
+      if (!isNaN(json?.maxHeaderLineLength)) {
+        this.maxHeaderLineLength = json.maxHeaderLineLength
+      }
+
+      if (!isNaN(json?.maxDataLineLength)) {
+        this.maxDataLineLength = json.maxDataLineLength
+      }
    }

-    if (json?.lineEndings) {
+    if (json?.lineEndings && json.lineEndings !== LineEndings.OFF) {
      if (
        json.lineEndings !== LineEndings.LF &&
        json.lineEndings !== LineEndings.CRLF
@@ -76,16 +91,16 @@ export class LintConfig {
          `Invalid value for lineEndings: can be ${LineEndings.LF} or ${LineEndings.CRLF}`
        )
      }
-      this.lineEndings = json.lineEndings
      this.fileLintRules.push(lineEndings)
+      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)
    }

@@ -93,11 +108,11 @@ export class LintConfig {
      this.defaultHeader = json.defaultHeader
    }

-    if (json?.noSpacesInFileNames) {
+    if (json?.noSpacesInFileNames !== false) {
      this.pathLintRules.push(noSpacesInFileNames)
    }

-    if (json?.lowerCaseFileNames) {
+    if (json?.lowerCaseFileNames !== false) {
      this.pathLintRules.push(lowerCaseFileNames)
    }

@@ -105,16 +120,44 @@ export class LintConfig {
      this.fileLintRules.push(hasMacroNameInMend)
    }

-    if (json?.noNestedMacros) {
+    if (json?.noNestedMacros !== false) {
      this.fileLintRules.push(noNestedMacros)
    }

-    if (json?.hasMacroParentheses) {
+    if (json?.hasMacroParentheses !== false) {
      this.fileLintRules.push(hasMacroParentheses)
    }

-    if (json?.strictMacroDefinition) {
+    if (json?.strictMacroDefinition !== false) {
      this.fileLintRules.push(strictMacroDefinition)
    }
+
+    if (json?.noGremlins !== false) {
+      this.lineLintRules.push(noGremlins)
+
+      if (json?.allowedGremlins) {
+        if (Array.isArray(json.allowedGremlins)) {
+          json.allowedGremlins.forEach((item: any) => {
+            if (typeof item === 'string' && /^0x[0-9a-f]{4}$/i.test(item))
+              this.allowedGremlins.push(item)
+            else
+              throw new Error(
+                `Property "allowedGremlins" has invalid type of values. It can contain only strings of form hexcode like '["0x0080", "0x3000"]'`
+              )
+          })
+        } else {
+          throw new Error(
+            `Property "allowedGremlins" can only be an array of strings of form hexcode like '["0x0080", "0x3000"]'`
+          )
+        }
+      }
+    }
+
+    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
+      }
+    }
  }
 }
--- a/src/types/LintRule.ts
+++ b/src/types/LintRule.ts
@@ -13,12 +13,22 @@ export interface LintRule {
  message: string
 }

+export interface LineLintRuleOptions {
+  isHeaderLine?: boolean
+  isDataLine?: boolean
+}
+
 /**
 * A LineLintRule is run once per line of text.
 */
 export interface LineLintRule extends LintRule {
  type: LintRuleType.Line
-  test: (value: string, lineNumber: number, config?: LintConfig) => Diagnostic[]
+  test: (
+    value: string,
+    lineNumber: number,
+    config?: LintConfig,
+    options?: LineLintRuleOptions
+  ) => Diagnostic[]
  fix?: (value: string, config?: LintConfig) => string
 }

@@ -36,5 +46,5 @@ export interface FileLintRule extends LintRule {
 */
 export interface PathLintRule extends LintRule {
  type: LintRuleType.Path
-  test: (value: string) => Diagnostic[]
+  test: (value: string, config?: LintConfig) => Diagnostic[]
 }
--- a/src/utils/getDataSectionDetail.spec.ts
+++ b/src/utils/getDataSectionDetail.spec.ts
@@ -0,0 +1,113 @@
+import { LintConfig } from '../types'
+import { getDataSectionsDetail, checkIsDataLine } from './getDataSectionsDetail'
+import { DefaultLintConfiguration } from './getLintConfig'
+
+const datalines = `GROUP_LOGIC:$3. SUBGROUP_LOGIC:$3. SUBGROUP_ID:8. VARIABLE_NM:$32. OPERATOR_NM:$10. RAW_VALUE:$4000.
+AND,AND,1,LIBREF,CONTAINS,"'DC'"
+AND,OR,2,DSN,=,"'MPE_LOCK_ANYTABLE'"`
+
+const datalinesBeginPattern1 = `datalines;`
+const datalinesBeginPattern2 = `datalines4;`
+const datalinesBeginPattern3 = `cards;`
+const datalinesBeginPattern4 = `cards4;`
+const datalinesBeginPattern5 = `parmcards;`
+const datalinesBeginPattern6 = `parmcards4;`
+
+const datalinesEndPattern1 = `;`
+const datalinesEndPattern2 = `;;;;`
+
+describe('getDataSectionsDetail', () => {
+  const config = new LintConfig(DefaultLintConfiguration)
+  it(`should return the detail of data section when it begins and ends with '${datalinesBeginPattern1}' and '${datalinesEndPattern1}' markers`, () => {
+    const text = `%put  hello\n${datalinesBeginPattern1}\n${datalines}\n${datalinesEndPattern1}\n%put world;`
+    expect(getDataSectionsDetail(text, config)).toEqual([
+      {
+        start: 1,
+        end: 5
+      }
+    ])
+  })
+
+  it(`should return the detail of data section when it begins and ends with '${datalinesBeginPattern2}' and '${datalinesEndPattern2}' markers`, () => {
+    const text = `%put  hello\n${datalinesBeginPattern2}\n${datalines}\n${datalinesEndPattern2}\n%put world;`
+    expect(getDataSectionsDetail(text, config)).toEqual([
+      {
+        start: 1,
+        end: 5
+      }
+    ])
+  })
+
+  it(`should return the detail of data section when it begins and ends with '${datalinesBeginPattern3}' and '${datalinesEndPattern1}' markers`, () => {
+    const text = `%put  hello\n${datalinesBeginPattern3}\n${datalines}\n${datalinesEndPattern1}\n%put world;`
+    expect(getDataSectionsDetail(text, config)).toEqual([
+      {
+        start: 1,
+        end: 5
+      }
+    ])
+  })
+
+  it(`should return the detail of data section when it begins and ends with '${datalinesBeginPattern4}' and '${datalinesEndPattern2}' markers`, () => {
+    const text = `%put  hello\n${datalinesBeginPattern4}\n${datalines}\n${datalinesEndPattern2}\n%put world;`
+    expect(getDataSectionsDetail(text, config)).toEqual([
+      {
+        start: 1,
+        end: 5
+      }
+    ])
+  })
+
+  it(`should return the detail of data section when it begins and ends with '${datalinesBeginPattern5}' and '${datalinesEndPattern1}' markers`, () => {
+    const text = `%put  hello\n${datalinesBeginPattern5}\n${datalines}\n${datalinesEndPattern1}\n%put world;`
+    expect(getDataSectionsDetail(text, config)).toEqual([
+      {
+        start: 1,
+        end: 5
+      }
+    ])
+  })
+
+  it(`should return the detail of data section when it begins and ends with '${datalinesBeginPattern6}' and '${datalinesEndPattern2}' markers`, () => {
+    const text = `%put  hello\n${datalinesBeginPattern6}\n${datalines}\n${datalinesEndPattern2}\n%put world;`
+    expect(getDataSectionsDetail(text, config)).toEqual([
+      {
+        start: 1,
+        end: 5
+      }
+    ])
+  })
+})
+
+describe('checkIsDataLine', () => {
+  const config = new LintConfig(DefaultLintConfiguration)
+  it(`should return true if a line index is in a range of any data section`, () => {
+    const text = `%put  hello\n${datalinesBeginPattern1}\n${datalines}\n${datalinesEndPattern1}\n%put world;`
+    expect(
+      checkIsDataLine(
+        [
+          {
+            start: 1,
+            end: 5
+          }
+        ],
+        4
+      )
+    ).toBe(true)
+  })
+
+  it(`should return false if a line index is not in a range of any of data sections`, () => {
+    const text = `%put  hello\n${datalinesBeginPattern1}\n${datalines}\n${datalinesEndPattern1}\n%put world;`
+    expect(
+      checkIsDataLine(
+        [
+          {
+            start: 1,
+            end: 5
+          }
+        ],
+        8
+      )
+    ).toBe(false)
+  })
+})
--- a/src/utils/getDataSectionsDetail.ts
+++ b/src/utils/getDataSectionsDetail.ts
@@ -0,0 +1,58 @@
+import { LintConfig } from '../types'
+import { splitText } from './splitText'
+
+interface DataSectionsDetail {
+  start: number
+  end: number
+}
+
+export const getDataSectionsDetail = (text: string, config: LintConfig) => {
+  const dataSections: DataSectionsDetail[] = []
+  const lines = splitText(text, config)
+
+  const dataSectionStartRegex1 = new RegExp(
+    '^(datalines;)|(cards;)|(parmcards;)'
+  )
+  const dataSectionEndRegex1 = new RegExp(';')
+  const dataSectionStartRegex2 = new RegExp(
+    '^(datalines4;)|(cards4;)|(parmcards4;)'
+  )
+  const dataSectionEndRegex2 = new RegExp(';;;;')
+
+  let dataSectionStarted = false
+  let dataSectionStartIndex = -1
+  let dataSectionEndRegex = dataSectionEndRegex1
+
+  lines.forEach((line, index) => {
+    if (dataSectionStarted) {
+      if (dataSectionEndRegex.test(line)) {
+        dataSections.push({ start: dataSectionStartIndex, end: index })
+        dataSectionStarted = false
+      }
+    } else {
+      if (dataSectionStartRegex1.test(line)) {
+        dataSectionStarted = true
+        dataSectionStartIndex = index
+        dataSectionEndRegex = dataSectionEndRegex1
+      } else if (dataSectionStartRegex2.test(line)) {
+        dataSectionStarted = true
+        dataSectionStartIndex = index
+        dataSectionEndRegex = dataSectionEndRegex2
+      }
+    }
+  })
+
+  return dataSections
+}
+
+export const checkIsDataLine = (
+  dataSections: DataSectionsDetail[],
+  lineIndex: number
+) => {
+  for (const dataSection of dataSections) {
+    if (lineIndex >= dataSection.start && lineIndex <= dataSection.end)
+      return true
+  }
+
+  return false
+}
--- a/src/utils/getHeaderLinesCount.spec.ts
+++ b/src/utils/getHeaderLinesCount.spec.ts
@@ -0,0 +1,21 @@
+import { LintConfig } from '../types'
+import { getHeaderLinesCount } from './getHeaderLinesCount'
+import { DefaultLintConfiguration } from './getLintConfig'
+
+const sasCodeWithHeader = `/**
+@file
+@brief <Your brief here>
+<h4> SAS Macros </h4>
+**/
+%put hello world;
+`
+
+const sasCodeWithoutHeader = `%put hello world;`
+
+describe('getHeaderLinesCount', () => {
+  it('should return the number of line header spans upon', () => {
+    const config = new LintConfig(DefaultLintConfiguration)
+    expect(getHeaderLinesCount(sasCodeWithHeader, config)).toEqual(5)
+    expect(getHeaderLinesCount(sasCodeWithoutHeader, config)).toEqual(0)
+  })
+})
--- a/src/utils/getHeaderLinesCount.ts
+++ b/src/utils/getHeaderLinesCount.ts
@@ -0,0 +1,23 @@
+import { LintConfig } from '../types'
+import { splitText } from './splitText'
+
+/**
+ * This function returns the number of lines the header spans upon.
+ * The file must start with "/*" and the header will finish with ⇙
+ */
+export const getHeaderLinesCount = (text: string, config: LintConfig) => {
+  let count = 0
+
+  if (text.trimStart().startsWith('/*')) {
+    const lines = splitText(text, config)
+
+    for (const line of lines) {
+      count++
+      if (line.match(/\*\//)) {
+        break
+      }
+    }
+  }
+
+  return count
+}
--- a/src/utils/getIndicesOf.ts
+++ b/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
+}
--- a/src/utils/getLintConfig.spec.ts
+++ b/src/utils/getLintConfig.spec.ts
@@ -3,7 +3,7 @@ import { LintConfig } from '../types/LintConfig'
 import { getLintConfig } from './getLintConfig'

 const expectedFileLintRulesCount = 5
-const expectedLineLintRulesCount = 5
+const expectedLineLintRulesCount = 6
 const expectedPathLintRulesCount = 2

 describe('getLintConfig', () => {
--- a/src/utils/getLintConfig.ts
+++ b/src/utils/getLintConfig.ts
@@ -1,7 +1,9 @@
 import path from 'path'
+import os from 'os'
 import { LintConfig } from '../types/LintConfig'
 import { readFile } from '@sasjs/utils/file'
 import { getProjectRoot } from './getProjectRoot'
+import { LineEndings } from '../types/LineEndings'

 export const getDefaultHeader = () =>
  `/**{lineEnding}  @file{lineEnding}  @brief <Your brief here>{lineEnding}  <h4> SAS Macros </h4>{lineEnding}**/`
@@ -10,30 +12,35 @@ export const getDefaultHeader = () =>
 * Default configuration that is used when a .sasjslint file is not found
 */
 export const DefaultLintConfiguration = {
+  lineEndings: LineEndings.OFF,
  noTrailingSpaces: true,
  noEncodedPasswords: true,
  hasDoxygenHeader: true,
  noSpacesInFileNames: true,
  lowerCaseFileNames: true,
  maxLineLength: 80,
+  maxHeaderLineLength: 80,
+  maxDataLineLength: 80,
  noTabIndentation: true,
  indentationMultiple: 2,
  hasMacroNameInMend: true,
  noNestedMacros: true,
  hasMacroParentheses: true,
  strictMacroDefinition: true,
+  noGremlins: true,
  defaultHeader: getDefaultHeader()
 }

 /**
- * Fetches the config from the .sasjslint file and creates a LintConfig object.
+ * Fetches the config from the .sasjslint file (at project root or home directory) and creates a LintConfig object.
 * Returns the default configuration when a .sasjslint file is unavailable.
 * @returns {Promise<LintConfig>} resolves with an object representing the current lint configuration.
 */
 export async function getLintConfig(): Promise<LintConfig> {
  const projectRoot = await getProjectRoot()
+  const lintFileLocation = projectRoot || os.homedir()
  const configuration = await readFile(
-    path.join(projectRoot, '.sasjslint')
+    path.join(lintFileLocation, '.sasjslint')
  ).catch((_) => {
    return JSON.stringify(DefaultLintConfiguration)
  })
--- a/src/utils/getProjectRoot.ts
+++ b/src/utils/getProjectRoot.ts
@@ -1,4 +1,5 @@
 import path from 'path'
+import os from 'os'
 import { fileExists } from '@sasjs/utils/file'

 /**
@@ -11,10 +12,11 @@ export async function getProjectRoot(): Promise<string> {
  let rootFound = false
  let i = 1
  let currentLocation = process.cwd()
+  const homeDir = os.homedir()

  const maxLevels = currentLocation.split(path.sep).length

-  while (i <= maxLevels && !rootFound) {
+  while (i <= maxLevels && !rootFound && currentLocation !== homeDir) {
    const isRoot = await fileExists(path.join(currentLocation, '.sasjslint'))

    if (isRoot) {
--- a/src/utils/gremlinCharacters.ts
+++ b/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'
+  }
+}
--- a/src/utils/index.ts
+++ b/src/utils/index.ts
@@ -1,6 +1,10 @@
 export * from './asyncForEach'
 export * from './getLintConfig'
 export * from './getProjectRoot'
+export * from './gremlinCharacters'
 export * from './isIgnored'
 export * from './listSasFiles'
 export * from './splitText'
+export * from './getIndicesOf'
+export * from './getHeaderLinesCount'
+export * from './getDataSectionsDetail'
--- a/src/utils/splitText.ts
+++ b/src/utils/splitText.ts
@@ -8,10 +8,19 @@ import { LineEndings } from '../types/LineEndings'
 */
 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'
-  return text
-    .replace(new RegExp(incorrectLineEndings, 'g'), expectedLineEndings)
-    .split(expectedLineEndings)
+
+  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/)
 }
Author	SHA1	Message	Date
Allan Bowe	04cfa454f8	Merge pull request #210 from sasjs/issue-209 feat: support a user-level ~/.sasjslint	2023-04-13 11:08:32 +01:00
Sabir Hassan	2cb73da0eb	feat: support a user-level ~/.sasjslint	2023-04-12 23:06:08 +05:00
Allan Bowe	22cc42446c	chore(docs): gremlins loc	2023-02-22 14:29:01 +00:00
Allan Bowe	0fe79273e0	chore(docs): update about pre-commit hooks	2023-02-22 14:13:46 +00:00
Allan Bowe	3d7f88aacb	chore(docs): more info in `noSpacesInFileNames` rule	2023-02-22 12:03:31 +00:00
Allan Bowe	1677eca957	chore: typo in readme	2023-02-22 11:25:58 +00:00
Allan Bowe	a1ebb51230	Merge pull request #205 from sasjs/default-line-endings fix: lineEndings should be off by default	2023-02-20 15:50:57 +00:00
Sabir Hassan	496e0bc8fc	fix: lineEndings should be off by default	2023-02-20 20:07:07 +05:00
Allan Bowe	f8b15c7d4d	fix: updating docs to force release	2023-02-20 14:15:22 +00:00
Allan Bowe	74e8df2a7b	Merge pull request #204 from sasjs/issue-17 chore: add documentation for lineEndings rule	2023-02-20 13:31:58 +00:00
Allan Bowe	12e4eeb287	Update README.md	2023-02-20 11:24:20 +00:00
Sabir Hassan	bc7a7a7645	chore: add enum for lineEndings in sasjs-lint-schema.json	2023-02-20 16:10:10 +05:00
Allan Bowe	40e90995f8	chore: change single to double quotes	2023-02-20 09:42:28 +00:00
Allan Bowe	80d0b39637	chore(docs): Added default value in explanatory json	2023-02-20 09:41:31 +00:00
Sabir Hassan	c3a466f485	chore: quick fix	2023-02-20 14:37:04 +05:00
Sabir Hassan	38656e9e89	chore: remove empty header	2023-02-15 21:50:34 +05:00
Sabir Hassan	386d0f5ff3	chore: add documentation for lineEndings rule	2023-02-15 21:34:25 +05:00
Allan Bowe	ad59159b62	Merge pull request #200 from sasjs/issue-47 feat: add new config maxDataLineLength	2023-01-12 17:35:22 +01:00
Allan Bowe	591f498d6d	fix: readme	2023-01-12 09:29:44 +00:00
Sabir Hassan	b5b8e7b00b	chore: quick fix	2023-01-11 21:34:07 +05:00
Sabir Hassan	7a46e9857e	feat: add new config maxDataLineLength	2023-01-11 19:51:07 +05:00
Allan Bowe	985ed41a4b	Merge pull request #199 from sasjs/issue-45 feat: add a new config maxHeaderLineLength	2023-01-11 15:46:01 +01:00
Sabir Hassan	fa07a7789c	chore: quick fix	2023-01-10 22:47:13 +05:00
Sabir Hassan	9a44984264	chore: quick fix	2023-01-10 20:59:00 +05:00
Sabir Hassan	54f887fc6d	fix: maxLineLength rule should be off when non positive number is provided	2023-01-10 20:55:21 +05:00
Allan Bowe	5f0ef8616c	Update getHeaderLinesCount.ts	2023-01-10 15:02:50 +00:00
Allan Bowe	04858eab99	chore(docs): readme	2023-01-10 14:51:44 +00:00
Allan Bowe	86fc4b8718	chore(docs): readme updates	2023-01-10 14:48:40 +00:00
Sabir Hassan	fef3eb5503	chore: bump jest related packages	2023-01-10 18:39:29 +05:00
Sabir Hassan	9dca298a2f	chore: bump all-contributors-cli and @types/node	2023-01-10 18:31:12 +05:00
Sabir Hassan	3ec75cdbfb	chore: bump ignore	2023-01-10 18:20:07 +05:00
Sabir Hassan	20476c557f	chore: bump @sasjs/utils	2023-01-10 18:18:12 +05:00
Sabir Hassan	ed96ba092b	chore: npm audit fix	2023-01-10 18:10:31 +05:00
Allan Bowe	b8b357c514	Update getHeaderLinesCount.ts	2023-01-10 10:39:32 +00:00
Allan Bowe	701c160ec1	fix: support single asterisk comment headers	2023-01-10 10:37:32 +00:00
Sabir Hassan	e6dc319844	chore: quick fix	2023-01-10 15:32:57 +05:00
Sabir Hassan	b6e9ee0825	feat: add a new config maxHeaderLineLength	2023-01-10 14:48:18 +05:00
Allan Bowe	4cb2fe8a69	Merge pull request #198 from sasjs/issue-197 feat: add a new config attribute for allowedGremlins	2023-01-09 14:59:43 +01:00
Allan Bowe	6c3b716988	feat: adding allowedGremlins description to README	2023-01-09 13:15:47 +00:00
Sabir Hassan	844f1ad154	feat: add a new config attribute for allowedGremlins	2023-01-09 17:13:19 +05:00
Allan Bowe	9984a373df	Merge pull request #195 from sasjs/issue-140 fix: update regex to handle single quotes in macro options	2023-01-02 12:21:22 +01:00
Sabir Hassan	0c79a1ef85	fix: update regex to handle single quotes in macro options	2023-01-02 16:11:10 +05:00
Allan Bowe	0bd57489b7	Update README.md	2022-12-30 12:25:45 +00:00
Allan Bowe	f59fd4c3f3	Merge pull request #191 from sasjs/issue-190 fix: added more gremlin characters	2022-12-30 11:49:01 +01:00
Sabir Hassan	5245246818	chore: fix specs	2022-12-29 18:52:21 +05:00
Sabir Hassan	636703b326	chore: specs fix	2022-12-29 00:49:40 +05:00
Sabir Hassan	24fba7867c	fix: update the logic for default values of rules	2022-12-29 00:49:13 +05:00
Sabir Hassan	5c44ec400d	chore: quick fix	2022-12-29 00:47:54 +05:00
Sabir Hassan	c0fdfc6ac9	fix: pass lint config to lintFile calling from formatFile	2022-12-29 00:46:50 +05:00
Sabir Hassan	4b16e0c52a	chore: typo fix	2022-12-27 23:55:36 +05:00
Sabir Hassan	8cf4f34e30	fix: noGremlins should be true by default even though if its not defined in .sasjslint	2022-12-27 23:29:55 +05:00
Sabir Hassan	97e3490a8d	fix: add few more gremlins	2022-12-27 23:22:40 +05:00
Allan Bowe	f6ddfa833d	fix: change type to boolean for noGremlins	2022-12-27 13:32:29 +00:00
Allan Bowe	e227f16f88	Merge pull request #189 from sasjs/no-gremlins feat: add new rule 'noGremlins'	2022-12-27 12:45:49 +01:00
Allan Bowe	7de907057d	feat: updating docs for gremlin capabilities	2022-12-26 19:00:53 +00:00
Sabir Hassan	80c90ebda1	chore: add specs	2022-12-26 22:44:32 +05:00
Sabir Hassan	c5ead229a9	chore: quick fix	2022-12-26 22:35:18 +05:00
Sabir Hassan	7d6fc8eb8c	feat: add new rule noGremlins	2022-12-26 21:14:48 +05:00
Allan Bowe	65772804fe	Merge pull request #188 from sasjs/issue-19 fix: updating noTabs error description to: Line contains a tab charac…	2022-12-13 19:05:47 +01:00
Allan Bowe	48a6628ec5	fix: updating noTabs error description to: Line contains a tab character (09x)	2022-12-13 18:03:18 +00:00
Allan Bowe	4dd25bb232	Merge pull request #187 from sasjs/issue-19 fix: check tab indentation in whole line	2022-12-13 18:33:49 +01:00
Allan Bowe	049aa6bf26	chore: updating README to describe new behaviour for noTabs. BREAKING CHANGE: we now check for ANY tab characters rather than just the tabs at the start of a line.	2022-12-13 17:32:13 +00:00
Sabir Hassan	f36536ba5c	chore: specs fix	2022-12-09 18:53:05 +05:00
Sabir Hassan	382a3cc987	chore: fix specs	2022-12-09 18:25:19 +05:00
Sabir Hassan	3701253302	fix: check tab indentation in whole line	2022-12-09 16:36:09 +05:00
Allan Bowe	8be59ac591	Merge pull request #181 from sasjs/issue-132 feat: add new property severityLevel	2022-11-17 13:44:01 +00:00
Allan Bowe	c6a70a1d1a	chore: docs for severityLevel	2022-11-16 22:12:43 +00:00
Sabir Hassan	75b103003c	chore: quick fix	2022-11-16 22:52:15 +05:00
Sabir Hassan	0cff87fe12	feat: add new property severityLevel	2022-11-16 22:40:17 +05:00
Allan Bowe	8031468926	fix: force bump with README change	2022-11-08 16:53:06 +00:00
Allan Bowe	1e25eab783	Update sasjslint-schema.json	2022-11-08 16:52:20 +00:00