Merge pull request #135 from atom-community/window/showDocument

Author: aminya

lib/adapters/show-document-adapter.ts

@@ -0,0 +1,57 @@
+import { shell } from "electron"
+import { LanguageClientConnection, ShowDocumentParams, ShowDocumentResult } from "../languageclient"
+import { TextEditor } from "atom"
+import Convert from "../convert"
+
+/** Public: Adapts the window/showDocument command to Atom's text editors or external programs. */
+const ShowDocumentAdapter = {
+  /** {@inheritDoc attach} */
+  attach,
+  /** {@inheritDoc showDocument} */
+  showDocument,
+}
+// for consistency with other adapters
+export default ShowDocumentAdapter
+
+/**
+ * Public: Attach to a {LanguageClientConnection} to recieve requests to show documents.
+ */
+export function attach(connection: LanguageClientConnection): void {
+  connection.onShowDocument(showDocument)
+}
+
+/**
+ * Public: show documents inside Atom text editor or in external programs
+ *
+ * @param params The {ShowDocumentParams} received from the language server
+ *   indicating the document to be displayed as well as other metadata.
+ * @returns {Promise<ShowDocumentResult>} with a `success: boolean` property specifying if the operation was sucessful
+ * {@inheritDoc ShowDocumentParams}
+ */
+export async function showDocument(params: ShowDocumentParams): Promise<ShowDocumentResult> {
+  try {
+    if (!params.external) {
+      // open using atom.workspace
+      const view = await atom.workspace.open(Convert.uriToPath(params.uri), {
+        activateItem: params.takeFocus,
+        activatePane: params.takeFocus,
+        pending: true,
+        initialLine: params.selection?.start.line ?? 0,
+        initialColumn: params.selection?.start.character ?? 0,
+      })
+      if (!view) {
+        return { success: false }
+      }
+      if (view instanceof TextEditor && params.selection !== undefined) {
+        view.selectToBufferPosition(Convert.positionToPoint(params.selection.end))
+      }
+    } else {
+      // open using Electron
+      shell.openExternal(params.uri, { activate: params.takeFocus })
+    }
+    return { success: true }
+  } catch (e) {
+    atom.notifications.addError(e)
+    return { success: false }
+  }
+}

lib/auto-languageclient.ts

@@ -21,6 +21,7 @@ import NotificationsAdapter from "./adapters/notifications-adapter"
 import OutlineViewAdapter from "./adapters/outline-view-adapter"
 import RenameAdapter from "./adapters/rename-adapter"
 import SignatureHelpAdapter from "./adapters/signature-help-adapter"
+import * as ShowDocumentAdapter from "./adapters/show-document-adapter"
 import * as Utils from "./utils"
 import { Socket } from "net"
 import { LanguageClientConnection } from "./languageclient"
@@ -245,6 +246,11 @@ export default class AutoLanguageClient {
           regularExpressions: undefined,
           markdown: undefined,
         },
+        window: {
+          workDoneProgress: false, // TODO: support
+          showMessage: undefined,
+          showDocument: { support: true },
+        },
         experimental: {},
       },
     }
@@ -554,6 +560,8 @@ export default class AutoLanguageClient {
       loggingConsole,
       signatureHelpAdapter,
     })
+
+    ShowDocumentAdapter.attach(server.connection)
   }
 
   public shouldSyncForEditor(editor: TextEditor, projectPath: string): boolean {

lib/languageclient.ts

@@ -15,6 +15,7 @@ export interface KnownNotifications {
 }
 
 export interface KnownRequests {
+  "window/showDocument": [lsp.ShowDocumentParams, lsp.ShowDocumentResult]
   "window/showMessageRequest": [lsp.ShowMessageRequestParams, lsp.MessageActionItem | null]
   "workspace/applyEdit": [lsp.ApplyWorkspaceEditParams, lsp.ApplyWorkspaceEditResponse]
   [custom: string]: [Record<string, any>, Record<string, any> | null]
@@ -166,6 +167,16 @@ export class LanguageClientConnection extends EventEmitter {
     this._onRequest({ method: "window/showMessageRequest" }, callback)
   }
 
+  /**
+   * Public: Register a callback for the `window/showDocument` message.
+   *
+   * @param callback The function to be called when the `window/showDocument` message is
+   *   received with {ShowDocumentParams} being passed.
+   */
+  public onShowDocument(callback: (params: lsp.ShowDocumentParams) => Promise<lsp.ShowDocumentResult>): void {
+    this._onRequest({ method: "window/showDocument" }, callback)
+  }
+
   /**
    * Public: Register a callback for the `window/logMessage` message.
    *

test/adapters/show-document-adapter.test.ts

@@ -0,0 +1,112 @@
+import { TextEditor } from "atom"
+import { shell } from "electron"
+import * as sinon from "sinon"
+import { expect } from "chai"
+import { join, dirname } from "path"
+import * as ShowDocumentAdapter from "../../lib/adapters/show-document-adapter"
+import { LanguageClientConnection, ShowDocumentParams } from "../../lib/languageclient"
+import Convert from "../../lib/convert"
+import { createSpyConnection } from "../helpers"
+
+describe("ShowDocumentAdapter", () => {
+  describe("can attach to a server", () => {
+    it("subscribes to onShowDocument", async () => {
+      const connection = createSpyConnection()
+      const lcc = new LanguageClientConnection(connection)
+
+      const spy = sinon.spy()
+      lcc["_onRequest"] = spy
+
+      ShowDocumentAdapter.attach(lcc)
+      expect((lcc["_onRequest"] as sinon.SinonSpy).calledOnce).to.be.true
+      const spyArgs = spy.firstCall.args
+      expect(spyArgs[0]).to.deep.equal({ method: "window/showDocument" })
+      expect(spyArgs[1]).to.equal(ShowDocumentAdapter.showDocument)
+    })
+
+    it("onRequest connection is called", async () => {
+      const connection = createSpyConnection()
+      const lcc = new LanguageClientConnection(connection)
+
+      const spy = sinon.spy()
+      connection.onRequest = spy
+
+      ShowDocumentAdapter.attach(lcc)
+      expect((connection.onRequest as sinon.SinonSpy).calledOnce).to.be.true
+      const spyArgs = spy.firstCall.args
+      expect(spyArgs[0]).to.equal("window/showDocument")
+      expect(typeof spyArgs[1]).to.equal("function")
+    })
+  })
+  describe("can show documents", () => {
+    describe("shows the document inside Atom", async () => {
+      const helloPath = join(dirname(__dirname), "fixtures", "hello.js")
+
+      async function canShowDocumentInAtom(params: ShowDocumentParams) {
+        const { success } = await ShowDocumentAdapter.showDocument(params)
+        expect(success).to.be.true
+
+        const editor = atom.workspace.getTextEditors()[0]
+        expect(editor instanceof TextEditor).to.be.true
+
+        expect(editor!.getPath()).includes(helloPath)
+        expect(editor!.getText()).includes(`atom.notifications.addSuccess("Hello World")`)
+
+        return editor
+      }
+
+      beforeEach(() => {
+        atom.workspace.getTextEditors().forEach((ed) => {
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          //@ts-ignore
+          ed.destroy()
+        })
+      })
+
+      it("shows the document inside Atom for the given URI", async () => {
+        const params: ShowDocumentParams = {
+          uri: helloPath,
+        }
+        await canShowDocumentInAtom(params)
+      })
+
+      it("takes the focus", async () => {
+        const params: ShowDocumentParams = {
+          uri: helloPath,
+          takeFocus: true,
+        }
+        const editor = await canShowDocumentInAtom(params)
+        expect(atom.workspace.getActivePane()?.getItems()[0]).equal(editor)
+      })
+
+      it("selects the given selection range", async () => {
+        const selectionLSRange = { start: { line: 1, character: 30 }, end: { line: 1, character: 43 } } // `"Hello World"` in JavaScript file
+        const params: ShowDocumentParams = {
+          uri: helloPath,
+          selection: selectionLSRange,
+        }
+        const editor = await canShowDocumentInAtom(params)
+        expect(editor.getSelectedBufferRange()).deep.equal(Convert.lsRangeToAtomRange(selectionLSRange))
+        expect(editor.getSelectedText()).equal(`"Hello World"`)
+      })
+    })
+
+    describe("shows document in external programs", () => {
+      it("shows the document in external programs for the given URI", async () => {
+        const params: ShowDocumentParams = {
+          uri: "http://www.github.com",
+          external: true,
+        }
+        const spy = sinon.spy()
+        shell.openExternal = spy
+
+        const { success } = await ShowDocumentAdapter.showDocument(params)
+        expect(success).to.be.true
+
+        expect((shell.openExternal as sinon.SinonSpy).calledOnce).to.be.true
+        const spyArgs = spy.firstCall.args
+        expect(spyArgs[0]).to.equal("http://www.github.com")
+      })
+    })
+  })
+})

test/fixtures/hello.ts

@@ -0,0 +1 @@
+atom.notifications.addSuccess("Hello World")

typings/electron/index.d.ts

@@ -0,0 +1,10 @@
+interface OpenExternalOptions {
+  activate?: boolean
+  workingDirectory?: string
+}
+
+declare module "electron" {
+  export const shell: {
+    openExternal(url: string, options?: OpenExternalOptions): void
+  }
+}