Add command and keyboard shortcut to prettify the current document

Author: darkriszty

README.md

@@ -11,7 +11,7 @@ Makes tables more readable for humans. Compatible with the Markdown writer plugi
 - Save space by not right-padding the last column if the table has no border.
 - Support empty columns inside tables.
 - Support column alignment options with ":".
-- CLI support to format files.
+- CLI support to prettify files.
 
 ![feature X](assets/animation.gif)
 
@@ -20,7 +20,7 @@ Makes tables more readable for humans. Compatible with the Markdown writer plugi
 Formatting files or checking if they're already formatted is possible from the command line. This requires `node` and `npm`.
 
 The extension has to be downloaded and compiled:
-- Download the extension from git or locate your VSCode installed extension path.
+- Locate your VSCode installed extension path or download the extension from Github.
 - Go to the extension directory.
 - Run `npm install`.
 - Run `npm run compile`.
@@ -31,18 +31,20 @@ The tipical location of the installed extension (your actual version might diffe
 - Linux ~/.vscode/extensions/darkriszty.markdown-table-prettify-3.0.0
 
 Available features from the command line:
-- To format a file: `npm run --silent prettify-md < input.md`.
-- To format a file and save the output: `npm run --silent prettify-md < input.md > output.md`.
+- To prettify a file: `npm run --silent prettify-md < input.md`.
+- To prettify a file and save the output: `npm run --silent prettify-md < input.md > output.md`.
 - To check whether a file is prettyfied or not: `npm run --silent check-md < input.md`. This will fail with an exception and return code `1` if the file is not prettyfied.
 
 > Note: the `--silent` switch sets the npm log level to silent, which is useful to hide the executed file name and concentrate on the actual output.
 
 ## Extension Settings
 
-The extension is available for markdown language mode. It can either format a selected table (`Format Selection`) or the entire document (`Format Document`).
+The extension is available for markdown language mode. It can either prettify a selected table (`Format Selection`) or the entire document (`Format Document`).
+A VSCode command called `Prettify markdown tables` is also available to format format the currently opened document. 
 
 Configurable settings:
 - The maximum texth length of a selection/entire document to consider for formatting. Defaults to 1M chars. There is no limit when running from the command line.
+- Keyboard shortcut to prettify the currently opened markdown document. Default: CTRL+ALT+M (CMD+ALT+M on Mac).
 
 ## Known Issues
 

package.json

@@ -38,7 +38,19 @@
           "description": "The maximum text length to apply formatting to."
         }
       }
-    }
+    },
+    "commands": [{
+      "command": "markdownTablePrettify.prettifyTables",
+      "title": "Prettify markdown tables"
+    }],
+    "keybindings": [
+      {
+        "command": "markdownTablePrettify.prettifyTables",
+        "key": "ctrl+alt+m",
+        "mac": "cmd+alt+m",
+        "when": "editorTextFocus && editorLangId == markdown && !editorReadonly && !inCompositeEditor"
+      }
+    ]
   },
   "capabilities": {
     "documentFormattingProvider": "true"

src/extension/extension.ts

@@ -1,15 +1,17 @@
 'use strict';
 import * as vscode from 'vscode';
-import { getDocumentRangePrettyfier, getDocumentPrettyfier } from './prettyfierFactory';
+import { getDocumentRangePrettyfier, getDocumentPrettyfier, getDocumentPrettyfierCommand } from './prettyfierFactory';
 
 // This method is called when the extension is activated.
 // The extension is activated the very first time the command is executed.
 export function activate(context: vscode.ExtensionContext): void {
     const MD_MODE: vscode.DocumentFilter = { language: "markdown" };
+    const command = "markdownTablePrettify.prettifyTables";
 
     context.subscriptions.push(
         vscode.languages.registerDocumentRangeFormattingEditProvider(MD_MODE, getDocumentRangePrettyfier()),
-        vscode.languages.registerDocumentFormattingEditProvider(MD_MODE, getDocumentPrettyfier())
+        vscode.languages.registerDocumentFormattingEditProvider(MD_MODE, getDocumentPrettyfier()),
+        vscode.commands.registerTextEditorCommand(command, textEditor => getDocumentPrettyfierCommand().prettifyDocument(textEditor))
     );
 }
 

src/extension/prettyfierFactory.ts

@@ -1,6 +1,7 @@
 import * as vscode from 'vscode';
 import { ConfigSizeLimitChecker } from '../prettyfiers/sizeLimit/configSizeLimitCheker';
 import { TableDocumentPrettyfier } from './tableDocumentPrettyfier';
+import { TableDocumentPrettyfierCommand } from './tableDocumentPrettyfierCommand';
 import { TableFinder } from '../tableFinding/tableFinder';
 import { TableDocumentRangePrettyfier } from "./tableDocumentRangePrettyfier";
 import { ILogger } from '../diagnostics/logger';
@@ -41,6 +42,19 @@ export function getDocumentPrettyfier(strict: boolean = true): vscode.DocumentFo
     );
 }
 
+export function getDocumentPrettyfierCommand(): TableDocumentPrettyfierCommand {
+    const loggers = getLoggers();
+    const sizeLimitCheker = getSizeLimitChecker(loggers);
+
+    return new TableDocumentPrettyfierCommand(
+        new MultiTablePrettyfier(
+            new TableFinder(new TableValidator(new SelectionInterpreter(true))),
+            getSingleTablePrettyfier(loggers, sizeLimitCheker),
+            sizeLimitCheker
+        )
+    );
+}
+
 function getSingleTablePrettyfier(loggers: ILogger[], sizeLimitCheker: ConfigSizeLimitChecker): SingleTablePrettyfier {
     return new SingleTablePrettyfier(
         new TableFactory(

src/extension/tableDocumentPrettyfierCommand.ts

@@ -0,0 +1,24 @@
+import * as vscode from "vscode";
+import { MultiTablePrettyfier } from "../prettyfiers/multiTablePrettyfier";
+
+export class TableDocumentPrettyfierCommand {
+
+    constructor(
+        private readonly _multiTablePrettyfier: MultiTablePrettyfier
+    ) { }
+
+    public prettifyDocument(editor: vscode.TextEditor) {
+        if (editor.document.languageId !== "markdown") {
+            return;
+        }
+
+        const formattedDocument: string = this._multiTablePrettyfier.formatTables(editor.document.getText());
+
+        editor.edit(textEditorEdit => {
+            textEditorEdit.replace(new vscode.Range(
+                new vscode.Position(0, 0),
+                new vscode.Position(editor.document.lineCount - 1, Number.MAX_SAFE_INTEGER)
+            ), formattedDocument);
+        });
+    }
+}

test/unitTests/extension/tableDocumentPrettyfier.test.ts

@@ -22,12 +22,12 @@ suite("TableDocumentPrettyfier tests", () => {
 
         const result = sut.provideDocumentFormattingEdits(document, null, null);
 
-        assert.equal(result.length, 1);
-        assert.equal(result[0].newText, expectedResult);
-        assert.equal(result[0].range.start.line, 0);
-        assert.equal(result[0].range.start.character, 0);
-        assert.equal(result[0].range.end.line, 9);
-        assert.equal(result[0].range.end.character, Number.MAX_SAFE_INTEGER);
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].newText, expectedResult);
+        assert.strictEqual(result[0].range.start.line, 0);
+        assert.strictEqual(result[0].range.start.character, 0);
+        assert.strictEqual(result[0].range.end.line, 9);
+        assert.strictEqual(result[0].range.end.character, Number.MAX_SAFE_INTEGER);
         _multiTablePrettyfier.verify(multiTablePrettyfier => multiTablePrettyfier.formatTables(It.isAny()), Times.once());
     });
 

test/unitTests/extension/tableDocumentPrettyfierCommand.test.ts

@@ -0,0 +1,50 @@
+import * as vscode from 'vscode';
+import { IMock, Mock, Times, It } from "typemoq";
+import { TableDocumentPrettyfierCommand } from "../../../src/extension/tableDocumentPrettyfierCommand";
+import { MarkdownTextDocumentStub } from "../../stubs/markdownTextDocumentStub";
+import { MultiTablePrettyfier } from "../../../src/prettyfiers/multiTablePrettyfier";
+
+suite("TableDocumentPrettyfierCommand tests", () => {
+
+    let _multiTablePrettyfier: IMock<MultiTablePrettyfier>;
+
+    setup(() => {
+        _multiTablePrettyfier = Mock.ofType<MultiTablePrettyfier>();
+    });
+
+    test("prettifyDocument() calls MultiTablePrettyfier and edit()", () => {
+        const sut = createSut();
+        const input = Array(10).fill("hello world").join("\n");
+        const expectedResult = Array(10).fill("expected result").join("\n");
+        const textEditor = Mock.ofType<vscode.TextEditor>();
+        const document = new MarkdownTextDocumentStub(input);
+        textEditor.setup(e => e.document).returns(() => document);
+        // Note: due to a limitation of the MarkdownTextDocumentStub with OS line endings, we use `It.isAny()` instead of `input`.
+        _multiTablePrettyfier.setup(multiTablePrettyfier => multiTablePrettyfier.formatTables(It.isAny())).returns(() => expectedResult)
+
+        sut.prettifyDocument(textEditor.object);
+
+        textEditor.verify(e => e.edit(It.isAny()), Times.once());
+        _multiTablePrettyfier.verify(multiTablePrettyfier => multiTablePrettyfier.formatTables(It.isAny()), Times.once());
+    });
+
+    test("prettifyDocument() for non-markdown documents doesn't do anything", () => {
+        const sut = createSut();
+        const input = Array(10).fill("hello world").join("\n");
+        const expectedResult = Array(10).fill("expected result").join("\n");
+        const textEditor = Mock.ofType<vscode.TextEditor>();
+        const document = new MarkdownTextDocumentStub(input);
+        document.languageId = "text";
+        textEditor.setup(e => e.document).returns(() => document);
+        _multiTablePrettyfier.setup(multiTablePrettyfier => multiTablePrettyfier.formatTables(It.isAny())).returns(() => expectedResult)
+
+        sut.prettifyDocument(textEditor.object);
+
+        textEditor.verify(e => e.edit(It.isAny()), Times.never());
+        _multiTablePrettyfier.verify(multiTablePrettyfier => multiTablePrettyfier.formatTables(It.isAny()), Times.never());
+    });
+
+    function createSut(): TableDocumentPrettyfierCommand {
+        return new TableDocumentPrettyfierCommand(_multiTablePrettyfier.object);
+    }
+});

test/unitTests/extension/tableDocumentRangePrettyfier.test.ts

@@ -22,8 +22,8 @@ suite("TableDocumentRangePrettyfier tests", () => {
 
         const result = sut.provideDocumentRangeFormattingEdits(document, range, null, null);
 
-        assert.equal(result.length, 1);
-        assert.equal(result[0].range, range);
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].range, range);
         _singleTablePrettyfier.verify(_ => _.prettifyTable(It.isAny(), It.isAny()), Times.once());
     });