fix: updating docs to force release

chore: add documentation for lineEndings rule

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

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)
@@ -26,7 +25,10 @@ Configuration is via a `.sasjslint` file with the following structure (these are
   "hasMacroParentheses": true,
   "ignoreList": ["sajsbuild/", "sasjsresults/"],
   "indentationMultiple": 2,
+  "lineEndings": "off",
   "lowerCaseFileNames": true,
+  "maxDataLineLength": 80,
+  "maxHeaderLineLength": 80,
   "maxLineLength": 80,
   "noNestedMacros": true,
   "noGremlins": true,
@@ -47,9 +49,22 @@ Each setting can have three states:
 
 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.
 
+### 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`.
+
+Example:
+
+```json
+{
+  "noGremlins": true,
+  "allowedGremlins": ["0x0080", "0x3000"]
+}
+```
+
 ### defaultHeader
 
-This isn't actually a rule - but rather a formatting setting, which applies to SAS program that do NOT begin with `/**`. It can be triggered by running `sasjs lint fix` in the SASjs CLI, or by hitting "save" when using the SASjs VS Code extension (with "formatOnSave" in place)
+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:
 
@@ -108,6 +123,21 @@ This will check each line to ensure that the count of leading spaces can be divi
 - Default: 2
 - Severity: WARNING
 
+### lineEndings
+
+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).
+
+- 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.
@@ -115,6 +145,45 @@ On *nix systems, it is imperative that autocall macros are in lowercase. When sh
 - 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)
@@ -126,11 +195,16 @@ We strongly recommend a line length limit, and set the bar at 80. To turn this f
 - Default: 80
 - Severity: WARNING
 
+See also:
+
+- [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.
+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/rules/line/noGremlins.ts](https://github.com/sasjs/lint/blob/main/src/rules/line/noGremlins.ts)
+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
@@ -189,11 +263,6 @@ This setting allows the default severity to be adjusted. This is helpful when ru
 - "warn" - show warning in the log (doesn’t affect exit code)
 - "error" - show error in the log (exit code is 1 when triggered)
 
-## Upcoming Linting Rules:
-
-- `noGremlins` -> identifies all invisible characters, other than spaces / tabs / line endings. If you really need that bell character, use a hex literal!
-- `lineEndings` -> set a standard line ending, such as LF or CRLF
-
 # SAS Formatter
 
 A formatter will automatically apply rules when you hit SAVE, which can save a LOT of time.

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"
   }
 }

sasjslint-schema.json

@@ -13,6 +13,8 @@
     "indentationMultiple": 2,
     "lowerCaseFileNames": true,
     "maxLineLength": 80,
+    "maxHeaderLineLength": 80,
+    "maxDataLineLength": 80,
     "noGremlins": true,
     "noNestedMacros": true,
     "noSpacesInFileNames": true,
@@ -30,7 +32,10 @@
       "noSpacesInFileNames": true,
       "lowerCaseFileNames": true,
       "maxLineLength": 80,
+      "maxHeaderLineLength": 80,
+      "maxDataLineLength": 80,
       "noGremlins": true,
+      "allowedGremlins": ["0x0080", "0x3000"],
       "noTabs": true,
       "indentationMultiple": 4,
       "hasMacroNameInMend": true,
@@ -74,6 +79,18 @@
       "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",
@@ -114,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",
@@ -149,6 +182,7 @@
     "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",

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)
 

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 =

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

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

src/rules/file/strictMacroDefinition.ts

@@ -110,7 +110,7 @@ const processOptions = (
   const severity = config?.severityLevel[name] || Severity.Warning
 
   if (optionsPresent) {
-    const regex = new RegExp(/="(.*?)"/, 'g')
+    const regex = new RegExp(/=["|'](.*?)["|']/, 'g')
 
     let result = regex.exec(optionsPresent)
 

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
+      }
+    ])
+  })
 })

src/rules/line/maxLineLength.ts

@@ -1,15 +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 test = (
+  value: string,
+  lineNumber: number,
+  config?: LintConfig,
+  options?: LineLintRuleOptions
+) => {
   const severity = config?.severityLevel[name] || Severity.Warning
-  const maxLineLength = config?.maxLineLength || 80
+  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 [
     {

src/rules/line/noGremlins.spec.ts

@@ -1,5 +1,5 @@
-import { Severity } from '../../types/Severity'
-import { noGremlins } from './noGremlins'
+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', () => {
@@ -8,8 +8,19 @@ describe('noTabs', () => {
   })
 
   it('should return a diagnostic array when the line contains gremlins', () => {
-    const line = "–  ‘ %put 'hello';"
+    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)
+  })
 })

src/rules/line/noGremlins.ts

@@ -2,6 +2,7 @@ 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'
@@ -9,15 +10,18 @@ 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, config] of Object.entries(gremlinCharacters)) {
-    gremlins[charFromHex(hexCode)] = Object.assign({}, config, {
-      hexCode
-    })
+  for (const [hexCode, gremlinConfig] of Object.entries(gremlinCharacters)) {
+    if (!allowedGremlins.includes(hexCode)) {
+      gremlins[charFromHex(hexCode)] = Object.assign({}, gremlinConfig, {
+        hexCode
+      })
+    }
   }
 
   const regexpWithAllChars = new RegExp(
@@ -55,74 +59,5 @@ export const noGremlins: LineLintRule = {
   test
 }
 
-const charFromHex = (hexCode: string) => String.fromCodePoint(parseInt(hexCode))
-
-const gremlinCharacters = {
-  '0x2013': {
-    description: 'en dash'
-  },
-  '0x2018': {
-    description: 'left single quotation mark'
-  },
-  '0x2019': {
-    description: 'right single quotation mark'
-  },
-  '0x2029': {
-    zeroWidth: true,
-    description: 'paragraph separator'
-  },
-  '0x2066': {
-    zeroWidth: true,
-    description: 'Left to right'
-  },
-  '0x2069': {
-    zeroWidth: true,
-    description: 'Pop directional'
-  },
-  '0x0003': {
-    description: 'end of text'
-  },
-  '0x000b': {
-    description: 'line tabulation'
-  },
-  '0x00a0': {
-    description: 'non breaking space'
-  },
-  '0x00ad': {
-    description: 'soft hyphen'
-  },
-  '0x200b': {
-    zeroWidth: true,
-    description: 'zero width space'
-  },
-  '0x200c': {
-    zeroWidth: true,
-    description: 'zero width non-joiner'
-  },
-  '0x200e': {
-    zeroWidth: true,
-    description: 'left-to-right mark'
-  },
-  '0x201c': {
-    description: 'left double quotation mark'
-  },
-  '0x201d': {
-    description: 'right double quotation mark'
-  },
-  '0x202c': {
-    zeroWidth: true,
-    description: 'pop directional formatting'
-  },
-  '0x202d': {
-    zeroWidth: true,
-    description: 'left-to-right override'
-  },
-  '0x202e': {
-    zeroWidth: true,
-    description: 'right-to-left override'
-  },
-  '0xfffc': {
-    zeroWidth: true,
-    description: 'object replacement character'
-  }
-}
+export const charFromHex = (hexCode: string) =>
+  String.fromCodePoint(parseInt(hexCode))

src/types/LineEndings.ts

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

src/types/LintConfig.spec.ts

@@ -4,96 +4,97 @@ 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', () => {
@@ -166,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')
@@ -181,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')

src/types/LintConfig.ts

@@ -29,10 +29,13 @@ import { Severity } from './Severity'
  */
 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()
@@ -53,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?.noTabs || json?.noTabIndentation) {
-      this.lineLintRules.push(noTabs)
+    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
@@ -79,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)
     }
 
@@ -96,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)
     }
 
@@ -108,20 +120,37 @@ 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) {
+    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) {

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
 }
 

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)
+  })
+})

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
+}

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)
+  })
+})

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
+}

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', () => {

src/utils/getLintConfig.ts

@@ -16,12 +16,15 @@ export const DefaultLintConfiguration = {
   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()
 }
 

src/utils/gremlinCharacters.ts

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

src/utils/index.ts

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

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/)
 }