Add basic support for formatting using shfmt

Limited to using shfmt's defaults for now - no way to tweak these.

Author: chris-reeves

server/src/config.ts

@@ -40,6 +40,9 @@ export const ConfigSchema = z.object({
 
   // Controls the executable used for ShellCheck linting information. An empty string will disable linting.
   shellcheckPath: z.string().trim().default('shellcheck'),
+
+  // Controls the executable used for Shfmt formatting. An empty string will disable formatting
+  shfmtPath: z.string().trim().default('shfmt'),
 })
 
 export type Config = z.infer<typeof ConfigSchema>
@@ -57,6 +60,7 @@ export function getConfigFromEnvironmentVariables(): {
     logLevel: process.env[LOG_LEVEL_ENV_VAR],
     shellcheckArguments: process.env.SHELLCHECK_ARGUMENTS,
     shellcheckPath: process.env.SHELLCHECK_PATH,
+    shfmtPath: process.env.SHFMT_PATH,
   }
 
   const environmentVariablesUsed = Object.entries(rawConfig)

server/src/server.ts

@@ -13,6 +13,7 @@ import Executables from './executables'
 import { initializeParser } from './parser'
 import * as ReservedWords from './reserved-words'
 import { Linter, LintingResult } from './shellcheck'
+import { Formatter } from './shfmt'
 import { SNIPPETS } from './snippets'
 import { BashCompletionItem, CompletionItemDataType } from './types'
 import { uniqueBasedOnHash } from './util/array'
@@ -35,6 +36,7 @@ export default class BashServer {
   private documents: LSP.TextDocuments<TextDocument> = new LSP.TextDocuments(TextDocument)
   private executables: Executables
   private linter?: Linter
+  private formatter?: Formatter
   private workspaceFolder: string | null
   private uriToCodeActions: {
     [uri: string]: LintingResult['codeActions'] | undefined
@@ -46,20 +48,23 @@ export default class BashServer {
     connection,
     executables,
     linter,
+    formatter,
     workspaceFolder,
   }: {
     analyzer: Analyzer
     capabilities: LSP.ClientCapabilities
     connection: LSP.Connection
     executables: Executables
     linter?: Linter
+    formatter?: Formatter
     workspaceFolder: string | null
   }) {
     this.analyzer = analyzer
     this.clientCapabilities = capabilities
     this.connection = connection
     this.executables = executables
     this.linter = linter
+    this.formatter = formatter
     this.workspaceFolder = workspaceFolder
     this.config = {} as any // NOTE: configured in updateConfiguration
     this.updateConfiguration(config.getDefaultConfiguration(), true)
@@ -130,6 +135,7 @@ export default class BashServer {
         workDoneProgress: false,
       },
       renameProvider: { prepareProvider: true },
+      documentFormattingProvider: true,
     }
   }
 
@@ -172,6 +178,7 @@ export default class BashServer {
     connection.onWorkspaceSymbol(this.onWorkspaceSymbol.bind(this))
     connection.onPrepareRename(this.onPrepareRename.bind(this))
     connection.onRenameRequest(this.onRenameRequest.bind(this))
+    connection.onDocumentFormatting(this.onDocumentFormatting.bind(this))
 
     /**
      * The initialized notification is sent from the client to the server after
@@ -272,6 +279,14 @@ export default class BashServer {
             this.linter = new Linter({ executablePath: shellcheckPath })
           }
 
+          const { shfmtPath } = this.config
+          if (!shfmtPath) {
+            logger.info('Shfmt formatting is disabled as "shfmtPath" was not set')
+            this.formatter = undefined
+          } else {
+            this.formatter = new Formatter({ executablePath: shfmtPath })
+          }
+
           this.analyzer.setEnableSourceErrorDiagnostics(
             this.config.enableSourceErrorDiagnostics,
           )
@@ -806,6 +821,26 @@ export default class BashServer {
     }
     return edits
   }
+
+  private async onDocumentFormatting(
+    params: LSP.DocumentFormattingParams,
+  ): Promise<LSP.TextEdit[] | null> {
+    if (this.formatter) {
+      try {
+        const document = this.documents.get(params.textDocument.uri)
+        if (!document) {
+          logger.error(`Error getting document: ${params.textDocument.uri}`)
+          return null
+        }
+
+        return await this.formatter.format(document)
+      } catch (err) {
+        logger.error(`Error while formatting: ${err}`)
+      }
+    }
+
+    return null
+  }
 }
 
 /**

server/src/shfmt/index.ts

@@ -0,0 +1,98 @@
+import { spawn } from 'child_process'
+import * as LSP from 'vscode-languageserver/node'
+import { TextDocument, TextEdit } from 'vscode-languageserver-textdocument'
+
+import { logger } from '../util/logger'
+
+type FormatterOptions = {
+  executablePath: string
+  cwd?: string
+}
+
+export class Formatter {
+  private cwd: string
+  public executablePath: string
+  private _canFormat: boolean
+
+  constructor({ cwd, executablePath }: FormatterOptions) {
+    this._canFormat = true
+    this.cwd = cwd || process.cwd()
+    this.executablePath = executablePath
+  }
+
+  public get canFormat(): boolean {
+    return this._canFormat
+  }
+
+  public async format(document: TextDocument): Promise<TextEdit[]> {
+    if (!this._canFormat) {
+      return []
+    }
+
+    return this.executeFormat(document)
+  }
+
+  private async executeFormat(document: TextDocument): Promise<TextEdit[]> {
+    const documentText = document.getText()
+
+    const result = await this.runShfmt(documentText)
+
+    if (!this._canFormat) {
+      return []
+    }
+
+    return [
+      {
+        range: LSP.Range.create(
+          LSP.Position.create(0, 0),
+          LSP.Position.create(Number.MAX_VALUE, Number.MAX_VALUE),
+        ),
+        newText: result,
+      },
+    ]
+  }
+
+  private async runShfmt(documentText: string): Promise<string> {
+    const args: string[] = []
+
+    logger.debug(`Shfmt: running "${this.executablePath} ${args.join(' ')}"`)
+
+    let out = ''
+    let err = ''
+    const proc = new Promise((resolve, reject) => {
+      const proc = spawn(this.executablePath, [...args, '-'], { cwd: this.cwd })
+      proc.on('error', reject)
+      proc.on('close', resolve)
+      proc.stdout.on('data', (data) => (out += data))
+      proc.stderr.on('data', (data) => (err += data))
+      proc.stdin.on('error', () => {
+        // NOTE: Ignore STDIN errors in case the process ends too quickly, before we try to
+        // write. If we write after the process ends without this, we get an uncatchable EPIPE.
+        // This is solved in Node >= 15.1 by the "on('spawn', ...)" event, but we need to
+        // support earlier versions.
+      })
+      proc.stdin.end(documentText)
+    })
+
+    // NOTE: do we care about exit code? 0 means "ok", 1 possibly means "errors",
+    // but the presence of parseable errors in the output is also sufficient to
+    // distinguish.
+    let exit
+    try {
+      exit = await proc
+    } catch (e) {
+      // TODO: we could do this up front?
+      if ((e as any).code === 'ENOENT') {
+        // shfmt path wasn't found, don't try to format any more:
+        logger.warn(
+          `Shfmt: disabling formatting as no executable was found at path '${this.executablePath}'`,
+        )
+        this._canFormat = false
+        return ''
+      }
+      throw new Error(`Shfmt: failed with code ${exit}: ${e}\nout:\n${out}\nerr:\n${err}`)
+    }
+
+    return out
+  }
+}

vscode-client/package.json

@@ -77,6 +77,11 @@
           "type": "string",
           "default": "",
           "description": "Additional ShellCheck arguments. Note that we already add the following arguments: --shell, --format, --external-sources."
+        },
+        "bashIde.shfmtPath": {
+          "type": "string",
+          "default": "shfmt",
+          "description": "Controls the executable used for Shfmt formatting. An empty string will disable formatting."
         }
       }
     }