Add support for parsing ShellCheck directives

Author: skovhus

server/src/shellcheck/__tests__/directive.test.ts

@@ -0,0 +1,135 @@
+import { parseShellCheckDirective } from '../directive'
+
+describe('parseShellCheckDirective', () => {
+  it('parses a disable directive', () => {
+    expect(parseShellCheckDirective('# shellcheck disable=SC1000')).toEqual([
+      {
+        type: 'disable',
+        rules: ['SC1000'],
+      },
+    ])
+  })
+
+  it('parses a disable directive with multiple args', () => {
+    expect(parseShellCheckDirective('# shellcheck disable=SC1000,SC1001')).toEqual([
+      {
+        type: 'disable',
+        rules: ['SC1000', 'SC1001'],
+      },
+    ])
+
+    expect(
+      parseShellCheckDirective(
+        '# shellcheck disable=SC1000,SC2000-SC2002,SC1001 # this is a comment',
+      ),
+    ).toEqual([
+      {
+        type: 'disable',
+        rules: ['SC1000', 'SC2000', 'SC2001', 'SC2002', 'SC1001'],
+      },
+    ])
+
+    expect(parseShellCheckDirective('# shellcheck disable=SC1000,SC1001')).toEqual([
+      {
+        type: 'disable',
+        rules: ['SC1000', 'SC1001'],
+      },
+    ])
+
+    expect(parseShellCheckDirective('# shellcheck disable=SC1000,SC1001')).toEqual([
+      {
+        type: 'disable',
+        rules: ['SC1000', 'SC1001'],
+      },
+    ])
+  })
+
+  // SC1000-SC9999
+  it('parses a disable directive with a range', () => {
+    expect(parseShellCheckDirective('# shellcheck disable=SC1000-SC1005')).toEqual([
+      {
+        type: 'disable',
+        rules: ['SC1000', 'SC1001', 'SC1002', 'SC1003', 'SC1004', 'SC1005'],
+      },
+    ])
+  })
+
+  it('parses a disable directive with all', () => {
+    expect(parseShellCheckDirective('# shellcheck disable=all')).toEqual([
+      {
+        type: 'disable',
+        rules: ['all'],
+      },
+    ])
+  })
+
+  it('parses an enable directive', () => {
+    expect(
+      parseShellCheckDirective('# shellcheck enable=require-variable-braces'),
+    ).toEqual([
+      {
+        type: 'enable',
+        rules: ['require-variable-braces'],
+      },
+    ])
+  })
+
+  it('parses source directive', () => {
+    expect(parseShellCheckDirective('# shellcheck source=foo.sh')).toEqual([
+      {
+        type: 'source',
+        path: 'foo.sh',
+      },
+    ])
+
+    expect(parseShellCheckDirective('# shellcheck source=/dev/null # a comment')).toEqual(
+      [
+        {
+          type: 'source',
+          path: '/dev/null',
+        },
+      ],
+    )
+  })
+
+  it('parses source-path directive', () => {
+    expect(parseShellCheckDirective('# shellcheck source-path=src/examples')).toEqual([
+      {
+        type: 'source-path',
+        path: 'src/examples',
+      },
+    ])
+
+    expect(parseShellCheckDirective('# shellcheck source-path=SCRIPTDIR')).toEqual([
+      {
+        type: 'source-path',
+        path: 'SCRIPTDIR',
+      },
+    ])
+  })
+
+  it('supports multiple directives on the same line', () => {
+    expect(
+      parseShellCheckDirective(
+        `# shellcheck cats=dogs disable=SC1234,SC2345 enable="foo" shell=bash`,
+      ),
+    ).toEqual([
+      {
+        type: 'disable',
+        rules: ['SC1234', 'SC2345'],
+      },
+      {
+        type: 'enable',
+        rules: ['"foo"'],
+      },
+      {
+        type: 'shell',
+        shell: 'bash',
+      },
+    ])
+  })
+
+  it('parses a line with no directive', () => {
+    expect(parseShellCheckDirective('# foo bar')).toEqual([])
+  })
+})

server/src/shellcheck/directive.ts

@@ -0,0 +1,93 @@
+const DIRECTIVE_TYPES = ['enable', 'disable', 'source', 'source-path', 'shell'] as const
+type DirectiveType = (typeof DIRECTIVE_TYPES)[number]
+
+type Directive =
+  | {
+      type: 'enable'
+      rules: string[]
+    }
+  | {
+      type: 'disable'
+      rules: string[]
+    }
+  | {
+      type: 'source'
+      path: string
+    }
+  | {
+      type: 'source-path'
+      path: string
+    }
+  | {
+      type: 'shell'
+      shell: string
+    }
+
+const DIRECTIVE_REG_EXP = /^(#\s*shellcheck\s+)([^#]*)/
+
+export function parseShellCheckDirective(line: string): Directive[] {
+  const match = line.match(DIRECTIVE_REG_EXP)
+
+  if (!match) {
+    return []
+  }
+
+  const commands = match[2]
+    .split(' ')
+    .map((command) => command.trim())
+    .filter((command) => command !== '')
+
+  const directives: Directive[] = []
+
+  for (const command of commands) {
+    const [typeKey, directiveValue] = command.split('=')
+    const type = DIRECTIVE_TYPES.includes(typeKey as any)
+      ? (typeKey as DirectiveType)
+      : null
+
+    if (!type) {
+      continue
+    }
+
+    if (type === 'source-path' || type === 'source') {
+      directives.push({
+        type,
+        path: directiveValue,
+      })
+    } else if (type === 'shell') {
+      directives.push({
+        type,
+        shell: directiveValue,
+      })
+      continue
+    } else if (type === 'enable' || type === 'disable') {
+      const rules = []
+
+      for (const arg of directiveValue.split(',')) {
+        const ruleRangeMatch = arg.match(/^SC(\d*)-SC(\d*)$/)
+        if (ruleRangeMatch) {
+          for (
+            let i = parseInt(ruleRangeMatch[1], 10);
+            i <= parseInt(ruleRangeMatch[2], 10);
+            i++
+          ) {
+            rules.push(`SC${i}`)
+          }
+        } else {
+          arg
+            .split(',')
+            .map((arg) => arg.trim())
+            .filter((arg) => arg !== '')
+            .forEach((arg) => rules.push(arg))
+        }
+      }
+
+      directives.push({
+        type,
+        rules,
+      })
+    }
+  }
+
+  return directives
+}