Add command and setting to format documents (#244)

* Add command and setting to format documents

Also, readme update

* lint

* lint

Author: apexskier

src/applyLSPEdits.test.ts

@@ -0,0 +1,39 @@
+import { applyLSPEdits } from "./applyLSPEdits";
+
+jest.mock("./novaUtils");
+jest.mock("./lspNovaConversions", () => ({
+  lspRangeToRange(_: unknown, r: unknown) {
+    return r;
+  },
+}));
+
+describe("Apply lsp edits", () => {
+  it("applies changes to files", async () => {
+    const mockEditor = { edit: jest.fn() };
+
+    const edit1 = {
+      range: {
+        start: { line: 1, character: 2 },
+        end: { line: 1, character: 5 },
+      },
+      newText: "newText1",
+    };
+    const edit2 = {
+      range: {
+        start: { line: 4, character: 0 },
+        end: { line: 5, character: 0 },
+      },
+      newText: "newText2",
+    };
+    await applyLSPEdits((mockEditor as unknown) as TextEditor, [edit1, edit2]);
+
+    // file edit callbacks should apply changes
+    const editCB = mockEditor.edit.mock.calls[0][0];
+    const replaceMock = jest.fn();
+    editCB({ replace: replaceMock });
+    expect(replaceMock).toBeCalledTimes(2);
+    // in reverse order
+    expect(replaceMock).toHaveBeenNthCalledWith(1, edit2.range, edit2.newText);
+    expect(replaceMock).toHaveBeenNthCalledWith(2, edit1.range, edit1.newText);
+  });
+});

src/applyLSPEdits.ts

@@ -0,0 +1,15 @@
+// eslint-disable-next-line no-unused-vars
+import type * as lspTypes from "vscode-languageserver-protocol";
+import { lspRangeToRange } from "./lspNovaConversions";
+
+export async function applyLSPEdits(
+  editor: TextEditor,
+  edits: Array<lspTypes.TextEdit>
+) {
+  editor.edit((textEditorEdit) => {
+    for (const change of edits.reverse()) {
+      const range = lspRangeToRange(editor.document, change.range);
+      textEditorEdit.replace(range, change.newText);
+    }
+  });
+}

src/applyWorkspaceEdit.ts

@@ -1,6 +1,6 @@
 // eslint-disable-next-line no-unused-vars
 import type * as lspTypes from "vscode-languageserver-protocol";
-import { lspRangeToRange } from "./lspNovaConversions";
+import { applyLSPEdits } from "./applyLSPEdits";
 import { openFile } from "./novaUtils";
 
 // @Deprecated I want to replace this with a call to Nova's client with workspace/applyEdit, but that's currently not possible.
@@ -23,11 +23,7 @@ export async function applyWorkspaceEdit(
       nova.workspace.showWarningMessage(`Failed to open ${uri}`);
       continue;
     }
-    editor.edit((textEditorEdit) => {
-      for (const change of changes.reverse()) {
-        const range = lspRangeToRange(editor.document, change.range);
-        textEditorEdit.replace(range, change.newText);
-      }
-    });
+
+    applyLSPEdits(editor, changes);
   }
 }

src/commands/formatDocument.test.ts

@@ -0,0 +1,87 @@
+// eslint-disable-next-line no-unused-vars
+import { registerFormatDocument } from "./formatDocument";
+
+class MockRange {
+  // eslint-disable-next-line no-unused-vars
+  constructor(readonly start: number, readonly end: number) {}
+}
+(global as any).Range = MockRange;
+
+describe("formatDocument command", () => {
+  beforeEach(() => {
+    (global as any).nova = Object.assign(nova, {
+      commands: {
+        register: jest.fn(),
+      },
+      workspace: {
+        showErrorMessage(err: Error) {
+          throw err;
+        },
+        showWarningMessage: jest.fn(),
+      },
+    });
+
+    mockEditor.edit.mockClear();
+    mockEditor.scrollToCursorPosition.mockClear();
+    mockEditor.selectWordsContainingCursors.mockClear();
+  });
+
+  const mockEditor = {
+    selectedRanges: [new Range(2, 3)],
+    selectedText: "selectedText",
+    document: {
+      length: 10,
+      uri: "currentDocURI",
+      path: "/path",
+      getTextInRange() {
+        return "";
+      },
+      eol: "\n",
+    },
+    softTabs: true,
+    tabLength: 2,
+    edit: jest.fn(),
+    selectWordsContainingCursors: jest.fn(),
+    scrollToCursorPosition: jest.fn(),
+  };
+
+  function getCommand(
+    languageClient: LanguageClient,
+    // eslint-disable-next-line no-unused-vars
+    register: (client: LanguageClient) => Disposable
+    // eslint-disable-next-line no-unused-vars
+  ): (...args: Array<any>) => Promise<void> {
+    register(languageClient);
+    expect(nova.commands.register).toHaveBeenCalledWith(
+      "apexskier.typescript.commands.formatDocument",
+      expect.any(Function)
+    );
+    const command = (nova.commands.register as jest.Mock).mock.calls[0][1];
+    (nova.commands.register as jest.Mock).mockClear();
+    return command;
+  }
+
+  it("applies changes from server to format document", async () => {
+    const mockLanguageClient = {
+      sendRequest: jest.fn().mockImplementationOnce(() => []),
+    };
+    const command = getCommand(
+      (mockLanguageClient as any) as LanguageClient,
+      registerFormatDocument
+    );
+    await command(mockEditor);
+
+    expect(mockLanguageClient.sendRequest).toBeCalledTimes(1);
+    expect(mockLanguageClient.sendRequest).toHaveBeenCalledWith(
+      "textDocument/formatting",
+      {
+        textDocument: { uri: "currentDocURI" },
+        options: {
+          insertSpaces: true,
+          tabSize: 2,
+        },
+      }
+    );
+    expect(mockEditor.edit).toBeCalledTimes(1);
+  });
+});

src/commands/formatDocument.ts

@@ -0,0 +1,44 @@
+// eslint-disable-next-line no-unused-vars
+import type * as lspTypes from "vscode-languageserver-protocol";
+import { applyLSPEdits } from "../applyLSPEdits";
+import { wrapCommand } from "../novaUtils";
+
+export function registerFormatDocument(client: LanguageClient) {
+  return nova.commands.register(
+    "apexskier.typescript.commands.formatDocument",
+    wrapCommand(formatDocument)
+  );
+
+  // eslint-disable-next-line no-unused-vars
+  async function formatDocument(editor: TextEditor): Promise<void>;
+  async function formatDocument(
+    // eslint-disable-next-line no-unused-vars
+    workspace: Workspace,
+    // eslint-disable-next-line no-unused-vars
+    editor: TextEditor
+  ): Promise<void>;
+  async function formatDocument(
+    editorOrWorkspace: TextEditor | Workspace,
+    maybeEditor?: TextEditor
+  ) {
+    const editor: TextEditor = maybeEditor ?? (editorOrWorkspace as TextEditor);
+
+    const documentFormatting: lspTypes.DocumentFormattingParams = {
+      textDocument: { uri: editor.document.uri },
+      options: {
+        insertSpaces: editor.softTabs,
+        tabSize: editor.tabLength,
+      },
+    };
+    const changes = (await client.sendRequest(
+      "textDocument/formatting",
+      documentFormatting
+    )) as null | Array<lspTypes.TextEdit>;
+
+    if (!changes) {
+      return;
+    }
+
+    applyLSPEdits(editor, changes);
+  }
+}

src/main.test.ts

@@ -118,7 +118,7 @@ describe("test suite", () => {
   });
 
   function assertActivationBehavior() {
-    expect(nova.commands.register).toBeCalledTimes(4);
+    expect(nova.commands.register).toBeCalledTimes(5);
     expect(nova.commands.register).toBeCalledWith(
       "apexskier.typescript.rename",
       expect.any(Function)
@@ -135,6 +135,10 @@ describe("test suite", () => {
       "apexskier.typescript.commands.organizeImports",
       expect.any(Function)
     );
+    expect(nova.commands.register).toBeCalledWith(
+      "apexskier.typescript.commands.formatDocument",
+      expect.any(Function)
+    );
 
     // installs dependencies
 
@@ -292,7 +296,7 @@ describe("test suite", () => {
       assertActivationBehavior();
     });
 
-    test("watches files for import organization", async () => {
+    test("watches files to apply post-save actions", async () => {
       resetMocks();
 
       await activate();
@@ -312,21 +316,71 @@ describe("test suite", () => {
         },
       };
       setupWatcher(mockEditor);
+
       expect(mockEditor.onWillSave).toBeCalledTimes(0);
+      const refreshListener = (nova.config.onDidChange as jest.Mock).mock
+        .calls[0][1];
+
+      const getBoolMock: jest.Mock = require("nova-extension-utils").preferences
+        .getOverridableBoolean;
+
+      getBoolMock.mockReturnValue(false);
+      refreshListener();
 
-      require("nova-extension-utils").preferences.getOverridableBoolean.mockReturnValue(
-        true
+      // eslint-disable-next-line no-unused-vars
+      let saveHandler: (editor: unknown) => Promise<unknown>;
+
+      getBoolMock.mockReset().mockReturnValue(true);
+      refreshListener();
+      saveHandler = mockEditor.onWillSave.mock.calls[0][0];
+      await saveHandler(mockEditor);
+      expect(nova.commands.invoke).toBeCalledTimes(2);
+      expect(nova.commands.invoke).toHaveBeenNthCalledWith(
+        1,
+        "apexskier.typescript.commands.organizeImports",
+        mockEditor
+      );
+      expect(nova.commands.invoke).toHaveBeenNthCalledWith(
+        2,
+        "apexskier.typescript.commands.formatDocument",
+        mockEditor
       );
-      setupWatcher(mockEditor);
-      expect(mockEditor.onWillSave).toBeCalledTimes(1);
 
-      const saveHandler = (mockEditor.onWillSave as jest.Mock).mock.calls[0][0];
+      mockEditor.onWillSave.mockReset();
+      (nova.commands.invoke as jest.Mock).mockReset();
+      getBoolMock
+        .mockReset()
+        .mockImplementation(
+          (test: string) =>
+            test == "apexskier.typescript.config.organizeImportsOnSave"
+        );
+      refreshListener();
+      saveHandler = mockEditor.onWillSave.mock.calls[0][0];
       await saveHandler(mockEditor);
+      expect(nova.commands.invoke).toBeCalledTimes(1);
       expect(nova.commands.invoke).toHaveBeenNthCalledWith(
         1,
         "apexskier.typescript.commands.organizeImports",
         mockEditor
       );
+
+      mockEditor.onWillSave.mockReset();
+      (nova.commands.invoke as jest.Mock).mockReset();
+      getBoolMock
+        .mockReset()
+        .mockImplementation(
+          (test: string) =>
+            test == "apexskier.typescript.config.formatDocumentOnSave"
+        );
+      refreshListener();
+      saveHandler = mockEditor.onWillSave.mock.calls[0][0];
+      await saveHandler(mockEditor);
+      expect(nova.commands.invoke).toBeCalledTimes(1);
+      expect(nova.commands.invoke).toHaveBeenNthCalledWith(
+        1,
+        "apexskier.typescript.commands.formatDocument",
+        mockEditor
+      );
     });
   });
 });

src/main.ts

@@ -2,6 +2,7 @@ import { dependencyManagement, preferences } from "nova-extension-utils";
 import { registerFindReferences } from "./commands/findReferences";
 import { registerFindSymbol } from "./commands/findSymbol";
 import { registerOrganizeImports } from "./commands/organizeImports";
+import { registerFormatDocument } from "./commands/formatDocument";
 import { registerRename } from "./commands/rename";
 import { registerSignatureHelp } from "./commands/signatureHelp";
 import { InformationView } from "./informationView";
@@ -11,6 +12,7 @@ import { getTsLibPath } from "./tsLibPath";
 
 const organizeImportsOnSaveKey =
   "apexskier.typescript.config.organizeImportsOnSave";
+const formatOnSaveKey = "apexskier.typescript.config.formatDocumentOnSave";
 
 nova.commands.register(
   "apexskier.typescript.openWorkspaceConfig",
@@ -159,6 +161,7 @@ async function asyncActivate() {
   compositeDisposable.add(registerFindSymbol(client));
   compositeDisposable.add(registerRename(client));
   compositeDisposable.add(registerOrganizeImports(client));
+  compositeDisposable.add(registerFormatDocument(client));
   if (nova.inDevMode()) {
     compositeDisposable.add(registerSignatureHelp(client));
   }
@@ -211,6 +214,12 @@ async function asyncActivate() {
           refreshListener
         )
       );
+      editorDisposable.add(
+        nova.config.onDidChange(formatOnSaveKey, refreshListener)
+      );
+      editorDisposable.add(
+        nova.workspace.config.onDidChange(formatOnSaveKey, refreshListener)
+      );
 
       let willSaveListener = setupListener();
       compositeDisposable.add({
@@ -226,18 +235,33 @@ async function asyncActivate() {
 
       function setupListener() {
         if (
-          (syntaxes as Array<string | null>).includes(editor.document.syntax) &&
-          preferences.getOverridableBoolean(organizeImportsOnSaveKey)
+          !(syntaxes as Array<string | null>).includes(editor.document.syntax)
         ) {
-          return editor.onWillSave(
-            async (editor) =>
-              nova.commands.invoke(
-                "apexskier.typescript.commands.organizeImports",
-                editor
-              ) as Promise<void>
-          );
+          return;
         }
-        return null;
+        const organizeImportsOnSave = preferences.getOverridableBoolean(
+          organizeImportsOnSaveKey
+        );
+        const formatDocumentOnSave = preferences.getOverridableBoolean(
+          formatOnSaveKey
+        );
+        if (!organizeImportsOnSave && !formatDocumentOnSave) {
+          return;
+        }
+        return editor.onWillSave(async (editor) => {
+          if (organizeImportsOnSave) {
+            await nova.commands.invoke(
+              "apexskier.typescript.commands.organizeImports",
+              editor
+            );
+          }
+          if (formatDocumentOnSave) {
+            await nova.commands.invoke(
+              "apexskier.typescript.commands.formatDocument",
+              editor
+            );
+          }
+        });
       }
     })
   );