Add utilities for supporting sourcing

Author: skovhus

server/src/util/__tests__/sourcing.test.ts

@@ -0,0 +1,42 @@
+import { homedir } from 'os'
+
+import { getSourcedUris } from '../sourcing'
+
+const fileDirectory = '/Users/bash'
+const fileUri = `${fileDirectory}/file.sh`
+
+describe('getSourcedUris', () => {
+  it('returns an empty set if no files were sourced', () => {
+    const result = getSourcedUris({ fileContent: '', fileUri })
+    expect(result).toEqual(new Set([]))
+  })
+
+  it('returns an empty set if no files were sourced', () => {
+    const result = getSourcedUris({
+      fileContent: `
+
+      source file-in-path.sh # does not contain a slash (i.e. is maybe somewhere on the path)
+
+      source /bin/f.inc
+
+      source ./x a b c # some arguments
+
+      . ./relative/to-this.sh
+
+      source ~/myscript
+
+      # source ...
+    `,
+      fileUri,
+    })
+    expect(result).toEqual(
+      new Set([
+        `${fileDirectory}/file-in-path.sh`, // as we don't resolve it, we hope it is here
+        `${fileDirectory}/bin/f.inc`,
+        `${fileDirectory}/x`,
+        `${fileDirectory}/relative/to-this.sh`,
+        `${homedir()}/myscript`,
+      ]),
+    )
+  })
+})

server/src/util/sourcing.ts

@@ -0,0 +1,92 @@
+import * as path from 'path'
+import * as LSP from 'vscode-languageserver'
+import * as Parser from 'web-tree-sitter'
+
+import { untildify } from './fs'
+
+// Until the grammar supports sourcing, we use this little regular expression
+const SOURCED_FILES_REG_EXP = /^(?:\t|[ ])*(?:source|[.])\s*(\S*)/gm
+
+export function getSourcedUris({
+  fileContent,
+  fileUri,
+}: {
+  fileContent: string
+  fileUri: string
+}): Set<string> {
+  const uris: Set<string> = new Set([])
+  let match: RegExpExecArray | null
+
+  while ((match = SOURCED_FILES_REG_EXP.exec(fileContent)) !== null) {
+    const relativePath = match[1]
+    const sourcedUri = getSourcedUri({ relativePath, uri: fileUri })
+    if (sourcedUri) {
+      uris.add(sourcedUri)
+    }
+  }
+
+  return uris
+}
+
+/**
+ * Investigates if the given position is a path to a sourced file and maps it
+ * to a location. Useful for jump to definition.
+ * @returns an optional location
+ */
+export function getSourcedLocation({
+  tree,
+  position,
+  uri,
+  word,
+}: {
+  tree: Parser.Tree
+  position: { line: number; character: number }
+  uri: string
+  word: string
+}): LSP.Location | null {
+  // NOTE: when a word is a file path to a sourced file, we return a location to
+  // that file.
+  if (tree.rootNode) {
+    const node = tree.rootNode.descendantForPosition({
+      row: position.line,
+      column: position.character,
+    })
+
+    if (!node || node.text.trim() !== word) {
+      throw new Error('Implementation error: word was not found at the given position')
+    }
+
+    const isSourced = node.previousNamedSibling
+      ? ['.', 'source'].includes(node.previousNamedSibling.text.trim())
+      : false
+
+    const sourcedUri = isSourced ? getSourcedUri({ relativePath: word, uri }) : null
+
+    if (sourcedUri) {
+      return LSP.Location.create(sourcedUri, LSP.Range.create(0, 0, 0, 0))
+    }
+  }
+
+  return null
+}
+
+const mapPathToUri = (path: string): string => path.replace('file:', 'file://')
+
+const getSourcedUri = ({
+  relativePath,
+  uri,
+}: {
+  relativePath: string
+  uri: string
+}): string | null => {
+  // NOTE: improvements:
+  // - we could try to resolve the path
+  // - "If filename does not contain a slash, file names in PATH are used to find
+  //   the directory containing filename." (see https://ss64.com/osx/source.html)
+
+  const resultPath = relativePath.startsWith('~')
+    ? untildify(relativePath)
+    : path.join(path.dirname(uri), relativePath)
+
+  return mapPathToUri(resultPath)
+}