Merge pull request #41 from darkriszty/feature/cli

Feature/cli

Author: darkriszty

CHANGELOG.md

@@ -6,6 +6,11 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## 3.0.0 - 2020-10-06
+### Added
+- Issue #32: Major refactoring to support CLI. Support `npm run prettify-md` and `npm run check-md`.
+- Issue #40: Provide command to run alongside prettier (shortcut `CTRL+ALT+M`).
+
 ## 2.5.0 - 2020-07-04
 ### Added
 - Issue #30: Add configurable text limit for table formatting

Dockerfile

@@ -0,0 +1,10 @@
+FROM node:current
+
+WORKDIR /app
+
+COPY . .
+
+RUN npm ci
+RUN npm run compile
+
+ENTRYPOINT [ "node", "./out/cli/index.js" ]

README.md

@@ -11,12 +11,47 @@ 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 and docker support to prettify files.
 
 ![feature X](assets/animation.gif)
 
+### CLI formatting
+
+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:
+- Locate the installed extension path or download the extension from Github.
+- Go to the extension directory.
+- Run `npm install`.
+- Run `npm run compile`.
+
+The typical location of the installed extension (your actual version might differ):
+- Windows %USERPROFILE%\.vscode\extensions\darkriszty.markdown-table-prettify-3.0.0
+- macOS ~/.vscode/extensions/darkriszty.markdown-table-prettify-3.0.0
+- Linux ~/.vscode/extensions/darkriszty.markdown-table-prettify-3.0.0
+
+Available features from the command line:
+- 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.
+
+### Formatting with docker
+
+Available features from docker:
+- To prettify a file: `docker container run -i darkriszty/prettify-md < input.md`.
+- To prettify a file and save the output: `docker container run -i darkriszty/prettify-md < input.md > output.md`.
+- To check whether a file is prettyfied or not: `docker container run -i darkriszty/prettify-md --check < input.md`. This will fail with an exception and return code `1` if the file is not prettyfied.
+
 ## 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
 

cli/cliPrettify.ts

@@ -0,0 +1,54 @@
+import { MultiTablePrettyfier } from "../src/prettyfiers/multiTablePrettyfier";
+import { TableFinder } from "../src/tableFinding/tableFinder";
+import { TableValidator } from "../src/modelFactory/tableValidator";
+import { SelectionInterpreter } from "../src/modelFactory/selectionInterpreter";
+import { TableFactory } from "../src/modelFactory/tableFactory";
+import { AlignmentFactory } from "../src/modelFactory/alignmentFactory";
+import { TrimmerTransformer } from "../src/modelFactory/transformers/trimmerTransformer";
+import { BorderTransformer } from "../src/modelFactory/transformers/borderTransformer";
+import { ConsoleLogger } from "../src/diagnostics/consoleLogger";
+import { SingleTablePrettyfier } from "../src/prettyfiers/singleTablePrettyfier";
+import { NoSizeLimitChecker } from "../src/prettyfiers/sizeLimit/noSizeLimitChecker";
+import { TableViewModelFactory } from "../src/viewModelFactories/tableViewModelFactory";
+import { RowViewModelFactory } from "../src/viewModelFactories/rowViewModelFactory";
+import { ContentPadCalculator } from "../src/padCalculation/contentPadCalculator";
+import { PadCalculatorSelector } from "../src/padCalculation/padCalculatorSelector";
+import { AlignmentMarkerStrategy } from "../src/viewModelFactories/alignmentMarking";
+import { TableStringWriter } from "../src/writers/tableStringWriter";
+
+export class CliPrettify {
+
+    public static prettify(text: string): string {
+        const prettyfier = this.createPrettyfier();
+        return prettyfier.formatTables(text);
+    }
+
+    public static check(text: string): void {
+        if (this.prettify(text) !== text) {
+            throw new Error("The input file is not prettyfied!");
+        }
+    }
+
+    private static createPrettyfier(): MultiTablePrettyfier {
+        const logger = new ConsoleLogger();
+        return new MultiTablePrettyfier(
+            new TableFinder(new TableValidator(new SelectionInterpreter(true))),
+            new SingleTablePrettyfier(
+                new TableFactory(
+                    new AlignmentFactory(),
+                    new SelectionInterpreter(false),
+                    new TrimmerTransformer(new BorderTransformer(null))
+                ),
+                new TableValidator(new SelectionInterpreter(false)),
+                new TableViewModelFactory(new RowViewModelFactory(
+                    new ContentPadCalculator(new PadCalculatorSelector(), " "), 
+                    new AlignmentMarkerStrategy(":")
+                )),
+                new TableStringWriter(),
+                [ logger ],
+                new NoSizeLimitChecker()
+            ),
+            new NoSizeLimitChecker()
+        );
+    }
+}

cli/index.ts

@@ -0,0 +1,10 @@
+import { CliPrettify } from "./cliPrettify";
+import { InputReader } from "./inputReader";
+
+const checkOnly = process.argv.length > 2 || process.argv.find(arg => arg === "--check");
+
+InputReader.subscribe(input =>
+    checkOnly
+        ? CliPrettify.check(input)
+        : process.stdout.write(CliPrettify.prettify(input))
+);

cli/inputReader.ts

@@ -0,0 +1,22 @@
+export class InputReader {
+    static subscribe(readDone): void {
+        if (process.stdin.isTTY) {
+            readDone(process.argv[2] || "");
+        } else {
+            let data = "";
+            process.stdin.setEncoding("utf-8");
+
+            process.stdin.on("readable", function() {
+                let chunk;
+                while (chunk = process.stdin.read()) {
+                    data += chunk;
+                }
+            });
+
+            process.stdin.on("end", function () {
+                data = data.replace(/\n$/, "");
+                readDone(data);
+            });
+        }
+    }
+}

package.json

@@ -2,7 +2,7 @@
   "name": "markdown-table-prettify",
   "displayName": "Markdown Table Prettifier",
   "description": "Transforms markdown tables to be more readable.",
-  "version": "2.5.0",
+  "version": "3.0.0",
   "publisher": "darkriszty",
   "repository": {
     "type": "git",
@@ -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"
@@ -47,7 +59,9 @@
     "vscode:prepublish": "tsc -p ./",
     "compile": "tsc -p ./",
     "pretest": "npm run compile",
-    "test": "gulp copy-systemTest-resources && node ./out/test/index.js"
+    "test": "gulp copy-systemTest-resources && node ./out/test/index.js",
+    "prettify-md": "node ./out/cli/index.js",
+    "check-md": "node ./out/cli/index.js --check"
   },
   "devDependencies": {
     "@types/mocha": "^7.0.2",

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 { SizeLimitChecker } from './sizeLimitCheker';
+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';
@@ -18,36 +19,56 @@ import { BorderTransformer } from '../modelFactory/transformers/borderTransforme
 import { SelectionInterpreter } from '../modelFactory/selectionInterpreter';
 import { PadCalculatorSelector } from '../padCalculation/padCalculatorSelector';
 import { AlignmentMarkerStrategy } from '../viewModelFactories/alignmentMarking';
+import { MultiTablePrettyfier } from '../prettyfiers/multiTablePrettyfier';
+import { SingleTablePrettyfier } from '../prettyfiers/singleTablePrettyfier';
 
-export function getDocumentRangePrettyfier(strict: boolean = false, sizeLimitCheker: SizeLimitChecker = null, loggers: ILogger[] = null) {
+export function getDocumentRangePrettyfier(strict: boolean = false, sizeLimitCheker: ConfigSizeLimitChecker = null, loggers: ILogger[] = null) {
     loggers = loggers || getLoggers();
     sizeLimitCheker = sizeLimitCheker || getSizeLimitChecker(loggers);
 
-    return new TableDocumentRangePrettyfier(
-        new TableFactory(
-            new AlignmentFactory(), new SelectionInterpreter(strict), 
-            new TrimmerTransformer(new BorderTransformer(null))
-        ),
-        new TableValidator(new SelectionInterpreter(strict)),
-        new TableViewModelFactory(
-            new RowViewModelFactory(
-                new ContentPadCalculator(new PadCalculatorSelector(), " "), 
-                new AlignmentMarkerStrategy(":")
-            )
-        ),
-        new TableStringWriter(),
-        loggers,
-        sizeLimitCheker
-    );
+    return new TableDocumentRangePrettyfier(getSingleTablePrettyfier(loggers, sizeLimitCheker));
 }
 
 export function getDocumentPrettyfier(strict: boolean = true): vscode.DocumentFormattingEditProvider {
     const loggers = getLoggers();
     const sizeLimitCheker = getSizeLimitChecker(loggers);
 
     return new TableDocumentPrettyfier(
-        new TableFinder(new TableValidator(new SelectionInterpreter(strict))), 
-        getDocumentRangePrettyfier(strict, sizeLimitCheker, loggers),
+        new MultiTablePrettyfier(
+            new TableFinder(new TableValidator(new SelectionInterpreter(strict))),
+            getSingleTablePrettyfier(loggers, sizeLimitCheker),
+            sizeLimitCheker
+        )
+    );
+}
+
+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(
+            new AlignmentFactory(),
+            new SelectionInterpreter(false),
+            new TrimmerTransformer(new BorderTransformer(null))
+        ),
+        new TableValidator(new SelectionInterpreter(false)),
+        new TableViewModelFactory(new RowViewModelFactory(
+            new ContentPadCalculator(new PadCalculatorSelector(), " "),
+            new AlignmentMarkerStrategy(":")
+        )),
+        new TableStringWriter(),
+        loggers,
         sizeLimitCheker
     );
 }
@@ -60,9 +81,9 @@ function getLoggers(): ILogger[] {
     ]
 }
 
-function getSizeLimitChecker(loggers: ILogger[]): SizeLimitChecker {
+function getSizeLimitChecker(loggers: ILogger[]): ConfigSizeLimitChecker {
     const maxTextLength = getConfigurationValue<number>("maxTextLength", 1000000);
-    return new SizeLimitChecker(loggers, maxTextLength);
+    return new ConfigSizeLimitChecker(loggers, maxTextLength);
 }
 
 function getConfigurationValue<T>(key: string, defaultValue: T): T {

src/extension/tableDocumentPrettyfier.ts

@@ -1,28 +1,25 @@
 import * as vscode from "vscode";
-import { SizeLimitChecker } from "./sizeLimitCheker";
-import { TableDocumentRangePrettyfier } from "./tableDocumentRangePrettyfier";
-import { TableFinder } from "../tableFinding/tableFinder";
+import { MultiTablePrettyfier } from "../prettyfiers/multiTablePrettyfier";
 
 export class TableDocumentPrettyfier implements vscode.DocumentFormattingEditProvider {
 
     constructor(
-        private readonly _tableFinder: TableFinder,
-        private readonly _tableDocumentRangePrettyfier: TableDocumentRangePrettyfier,
-        private readonly _sizeLimitChecker: SizeLimitChecker
+        private readonly _multiTablePrettyfier: MultiTablePrettyfier
     ) { }
 
     public provideDocumentFormattingEdits(document: vscode.TextDocument, 
         options: vscode.FormattingOptions, token: vscode.CancellationToken): vscode.TextEdit[] 
     {
-        let result: vscode.TextEdit[] = [];
+        const formattedDocument: string = this._multiTablePrettyfier.formatTables(document.getText());
 
-        let tables: vscode.Range[] = this._sizeLimitChecker.isWithinAllowedSizeLimit(document.getText())
-            ? this._tableFinder.getTables(document)
-            : [];
-        for (let tableRange of tables) {
-            let edits = this._tableDocumentRangePrettyfier.provideDocumentRangeFormattingEdits(document, tableRange, options, token);
-            result = result.concat(edits);
-        }
-        return result;
+        return [
+            new vscode.TextEdit(
+                new vscode.Range(
+                    new vscode.Position(0, 0),
+                    new vscode.Position(document.lineCount - 1, Number.MAX_SAFE_INTEGER)
+                ), 
+                formattedDocument
+            )
+        ];
     }
 }