Merge pull request #48 from darkriszty/feature/indentation

Feature/indentation

Author: darkriszty

CHANGELOG.md

@@ -6,6 +6,10 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## 3.2.0 - 2020-12-14
+### Added
+- Issue #47: Support for indented tables.
+
 ## 3.1.0 - 2020-11-04
 ### Fixed
 - Issue #42: Don't alter selection for invalid range formatting attempt (does not impact CLI).

cli/cliPrettify.ts

@@ -15,6 +15,7 @@ import { ContentPadCalculator } from "../src/padCalculation/contentPadCalculator
 import { PadCalculatorSelector } from "../src/padCalculation/padCalculatorSelector";
 import { AlignmentMarkerStrategy } from "../src/viewModelFactories/alignmentMarking";
 import { TableStringWriter } from "../src/writers/tableStringWriter";
+import { FairTableIndentationDetector } from "../src/modelFactory/tableIndentationDetector";
 
 export class CliPrettify {
 
@@ -37,7 +38,8 @@ export class CliPrettify {
                 new TableFactory(
                     new AlignmentFactory(),
                     new SelectionInterpreter(false),
-                    new TrimmerTransformer(new BorderTransformer(null))
+                    new TrimmerTransformer(new BorderTransformer(null)),
+                    new FairTableIndentationDetector()
                 ),
                 new TableValidator(new SelectionInterpreter(false)),
                 new TableViewModelFactory(new RowViewModelFactory(

package-lock.json

@@ -2,7 +2,7 @@
   "name": "markdown-table-prettify",
   "displayName": "Markdown Table Prettifier",
   "description": "Transforms markdown tables to be more readable.",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "publisher": "darkriszty",
   "repository": {
     "type": "git",
@@ -16,7 +16,12 @@
     "vscode": "^1.50.0"
   },
   "categories": [
-    "Other"
+    "Formatters"
+  ],
+  "keywords": [
+    "markdown",
+    "table",
+    "formatter"
   ],
   "activationEvents": [
     "onLanguage:markdown"

package.json

@@ -21,6 +21,7 @@ import { PadCalculatorSelector } from '../padCalculation/padCalculatorSelector';
 import { AlignmentMarkerStrategy } from '../viewModelFactories/alignmentMarking';
 import { MultiTablePrettyfier } from '../prettyfiers/multiTablePrettyfier';
 import { SingleTablePrettyfier } from '../prettyfiers/singleTablePrettyfier';
+import { FairTableIndentationDetector } from '../modelFactory/tableIndentationDetector';
 
 export function getDocumentRangePrettyfier() {
     return new TableDocumentRangePrettyfier(getMultiTablePrettyfier());
@@ -50,7 +51,8 @@ function getSingleTablePrettyfier(loggers: ILogger[], sizeLimitCheker: ConfigSiz
         new TableFactory(
             new AlignmentFactory(),
             new SelectionInterpreter(false),
-            new TrimmerTransformer(new BorderTransformer(null))
+            new TrimmerTransformer(new BorderTransformer(null)),
+            new FairTableIndentationDetector()
         ),
         new TableValidator(new SelectionInterpreter(false)),
         new TableViewModelFactory(new RowViewModelFactory(

src/extension/prettyfierFactory.ts

@@ -3,6 +3,7 @@ import { AlignmentFactory } from "./alignmentFactory";
 import { Alignment } from "../models/alignment";
 import { Transformer } from "./transformers/transformer";
 import { SelectionInterpreter } from "./selectionInterpreter";
+import { TableIndentationDetector } from "./tableIndentationDetector";
 import { Cell } from "../models/cell";
 import { Line } from "../models/doc/line";
 import { Row } from "../models/row";
@@ -14,11 +15,12 @@ export class TableFactory {
     constructor(
         private _alignmentFactory: AlignmentFactory,
         private _selectionInterpreter: SelectionInterpreter,
-        private _transformer: Transformer)
+        private _transformer: Transformer,
+        private _tableIndentationDetector: TableIndentationDetector)
     { }
 
     public getModel(document: Document, range: Range): Table {
-        const lines = document.getLines(range);
+        const lines: Line[] = document.getLines(range);
         if (lines == null || lines.length == 0)
             throw new Error("Can't create table model from no lines.");
 
@@ -38,6 +40,8 @@ export class TableFactory {
             ? this._alignmentFactory.createAlignments(separator) 
             : [];
 
-        return this._transformer.process(new Table(rowsWithoutSeparator, separatorLine.EOL, alignments));
+        const leftPad: string = this._tableIndentationDetector.getLeftPad(lines.map(l => l.value));
+
+        return this._transformer.process(new Table(rowsWithoutSeparator, separatorLine.EOL, alignments, leftPad));
     }
 }

src/modelFactory/tableFactory.ts

@@ -0,0 +1,45 @@
+export abstract class TableIndentationDetector {
+    protected abstract hasIndentation(leftPadsPerLine: string[]): boolean;
+    protected abstract getIndentationChars(leftPadsPerLine: string[]): string;
+
+    public getLeftPad(lines: string[]): string {
+        const leftPadsPerLine: string[] = lines.map(l => l.match(/^\s*/)[0]);
+
+        return this.hasIndentation(leftPadsPerLine)
+            ? this.getIndentationChars(leftPadsPerLine)
+            : "";
+    }
+}
+
+/**
+ * If more than half of the lines have indentation, assume indentation was intended.
+ * Use the indentation characters used by the majority of the lines.
+ */
+export class FairTableIndentationDetector extends TableIndentationDetector {
+
+    protected hasIndentation(leftPadsPerLine: string[]): boolean {
+        const totalLines: number = leftPadsPerLine.length;
+        const linesWithActualLeftPadding: number = leftPadsPerLine.filter(p => p.length > 0).length;
+
+        return linesWithActualLeftPadding >= totalLines / 2;
+    }
+
+    protected getIndentationChars(leftPadsPerLine: string[]): string {
+        const nonEmptyLeftPads = leftPadsPerLine.filter(l => l.length > 0);
+        let indentCounters: Map<string, number> = new Map();
+
+        for (const leftPad of nonEmptyLeftPads) {
+            let count = 1;
+            if (indentCounters.has(leftPad)) {
+                count += indentCounters.get(leftPad);
+            }
+            indentCounters.set(leftPad, ++count);
+        }
+
+        // if there is an indentation used for at least 2 distinct lines, then use that, otherwise use the first line's indentation
+        const indentWithMostRepeats = [...indentCounters.entries()].reduce((prev, curr) => curr[1] > prev[1] ? curr : prev)
+        return indentWithMostRepeats[1] > 1
+            ? indentWithMostRepeats[0]
+            : indentCounters[0];
+    }
+}

src/modelFactory/tableIndentationDetector.ts

@@ -14,7 +14,10 @@ export class BorderTransformer extends Transformer {
         const rows: Row[] = this.rowsWithoutEmptyFirstAndLastColumn(input.rows, hasLeftBorder, hasRightBorder);
         const alignments = this.alignmentsWithoutEmptyFirstAndLastColumn(input.alignments, hasLeftBorder, hasRightBorder);
 
-        let result = new Table(rows, input.separatorEOL, alignments);
+        const leftPad = hasLeftBorder 
+            ? input.leftPad
+            : "";
+        let result = new Table(rows, input.separatorEOL, alignments, leftPad);
         result.hasLeftBorder = hasLeftBorder;
         result.hasRightBorder = this.hasRightBorder(hasLeftBorder, hasRightBorder);
         return result;

src/modelFactory/transformers/borderTransformer.ts

@@ -7,6 +7,7 @@ export abstract class Transformer {
     protected abstract transform(input: Table): Table;
 
     public process(input: Table): Table {
+        //Note: consider dropping the transformers and moving all table related logic inside the factory.
         if (input == null || input.isEmpty())
             return input;
 

src/modelFactory/transformers/transformer.ts

@@ -6,7 +6,7 @@ import { Table } from "../../models/table";
 export class TrimmerTransformer extends Transformer {
 
     public transform(input: Table): Table {
-        return new Table(this.trimColumnValues(input.rows), input.separatorEOL, input.alignments);
+        return new Table(this.trimColumnValues(input.rows), input.separatorEOL, input.alignments, input.leftPad);
     }
 
     private trimColumnValues(rows: Row[]): Row[] {