Pass the alignment marker strategy to the RowViewModelFactory

Author: darkriszty

src/extension/extension.ts

@@ -15,6 +15,7 @@ import { BorderTransformer } from '../modelFactory/transformers/borderTransforme
 import { SelectionInterpreter } from '../modelFactory/selectionInterpreter';
 import { SeparatorPadCalculator } from '../padCalculation/separatorPadCalculator';
 import { PadCalculatorSelector } from '../padCalculation/padCalculatorSelector';
+import { AlignmentMarkerStrategy } from '../viewModelFactories/alignmentMarking';
 
 // This method is called when the extension is activated.
 // The extension is activated the very first time the command is executed.
@@ -32,7 +33,8 @@ export function activate(context: vscode.ExtensionContext): void {
             new TableViewModelFactory(
                 new RowViewModelFactory(
                     new ContentPadCalculator(new PadCalculatorSelector(), " "), 
-                    new SeparatorPadCalculator(new PadCalculatorSelector(), "-")
+                    new SeparatorPadCalculator(new PadCalculatorSelector(), "-"),
+                    new AlignmentMarkerStrategy()
                 )
             ),
             new TableStringWriter(),

src/viewModelFactories/alignmentMarking/alignmentMarkerStrategy.ts

@@ -4,7 +4,7 @@ import { IAlignmentMarker, LeftAlignmentMarker, RightAlignmentMarker, CenterAlig
 
 export class AlignmentMarkerStrategy {
 
-    public marker(alignment: Alignment): IAlignmentMarker {
+    public markerFor(alignment: Alignment): IAlignmentMarker {
         switch (alignment) {
             case Alignment.Left: return new LeftAlignmentMarker();
             case Alignment.Right: return new RightAlignmentMarker();

src/viewModelFactories/rowViewModelFactory.ts

@@ -8,7 +8,8 @@ export class RowViewModelFactory {
 
     constructor(
         private _contentPadCalculator: PadCalculator,
-        private _separatorPadCalculator: PadCalculator)
+        private _separatorPadCalculator: PadCalculator,
+        private _alignmentMarkerStrategy: AlignmentMarkerStrategy)
     { }
 
     public buildRow(row: number, table: Table): RowViewModel {
@@ -28,10 +29,8 @@ export class RowViewModelFactory {
     public buildSeparator(table: Table): RowViewModel {
         let resultRow = new Array(table.columnCount);
 
-        //TODO: extract this as constructor param
-        let alignmentMarkerSelector = new AlignmentMarkerStrategy();
         for(let col = 0; col < table.columnCount; col++)
-            resultRow[col] = alignmentMarkerSelector.marker(table.alignments[col]).mark(
+            resultRow[col] = this._alignmentMarkerStrategy.markerFor(table.alignments[col]).mark(
                 this._separatorPadCalculator.getLeftPadding(table, 1, col) +
                 this._separatorPadCalculator.getRightPadding(table, 0, col)
             );

test/systemTests/tableRangePrettyfierFactory.ts

@@ -19,6 +19,7 @@ import { BorderTransformer } from '../../src/modelFactory/transformers/borderTra
 import { SelectionInterpreter } from '../../src/modelFactory/selectionInterpreter';
 import { SeparatorPadCalculator } from '../../src/padCalculation/separatorPadCalculator';
 import { PadCalculatorSelector } from '../../src/padCalculation/padCalculatorSelector';
+import { AlignmentMarkerStrategy } from '../../src/viewModelFactories/alignmentMarking';
 
 export class PrettyfierFromFile {
     private readonly _logger: ILogger;
@@ -62,7 +63,8 @@ export class PrettyfierFromFile {
             new TableValidator(new SelectionInterpreter()),
             new TableViewModelFactory(new RowViewModelFactory(
                 new ContentPadCalculator(new PadCalculatorSelector(), " "), 
-                new SeparatorPadCalculator(new PadCalculatorSelector(), "-")
+                new SeparatorPadCalculator(new PadCalculatorSelector(), "-"),
+                new AlignmentMarkerStrategy()
             )),
             new TableStringWriter(),
             [ this._logger ]

test/unitTests/viewModelFactories/alignmentMarking/alignmentMarkerStrategy.test.ts

@@ -4,11 +4,11 @@ import { Alignment } from '../../../../src/models/alignment';
 
 suite("AlignmentMarkerStrategy tests", () => {
 
-    test("marker() returns a different marker strategy for the different alignemnts", () => {
+    test("markerFor() returns a different marker strategy for the different alignemnts", () => {
         const sut = new AlignmentMarkerStrategy();
         const alignments = [ Alignment.NotSet, Alignment.Left, Alignment.Center, Alignment.Right ];
 
-        const markers: IAlignmentMarker[] = alignments.map(sut.marker);
+        const markers: IAlignmentMarker[] = alignments.map(sut.markerFor);
 
         const distinctMarkers = markers.filter((v, i, a) => a.indexOf(v) == i);
 

test/unitTests/viewModelFactories/rowViewModelFactory.test.ts

@@ -6,6 +6,7 @@ import { RowViewModelFactory } from '../../../src/viewModelFactories/rowViewMode
 import { Table } from '../../../src/models/table';
 import { Alignment } from '../../../src/models/alignment';
 import { Cell } from '../../../src/models/cell';
+import { AlignmentMarkerStrategy, IAlignmentMarker } from '../../../src/viewModelFactories/alignmentMarking';
 
 suite("RowViewModelFactory.buildRow() tests", () => {
     let _contentPadCalculator: IMock<PadCalculator>;
@@ -144,43 +145,23 @@ suite("RowViewModelFactory.buildSeparator() tests", () => {
             assert.equal(separatorRowViewModel.getValueAt(col), "----");
     });
 
-    test("Left aligned column separator starts with :", () => {
-        const sut = createFactory(_contentPadCalculator.object, _separatorPadCalculator.object);
-        const table = threeColumnTable(Alignment.Left);
-
-        _separatorPadCalculator.setup(_ => _.getLeftPadding(It.isAny(), It.isAny(), It.isAny())).returns(() => "--");
-        _separatorPadCalculator.setup(_ => _.getRightPadding(It.isAny(), It.isAny(), It.isAny())).returns(() => "--");
-
-        const separatorRowViewModel = sut.buildSeparator(table);
-
-        for (let col = 0; col < separatorRowViewModel.columnCount; col++)
-            assert.equal(separatorRowViewModel.getValueAt(col), ":---");
-    });
-
-    test("Right aligned column separator ends with :", () => {
-        const sut = createFactory(_contentPadCalculator.object, _separatorPadCalculator.object);
-        const table = threeColumnTable(Alignment.Right);
-
-        _separatorPadCalculator.setup(_ => _.getLeftPadding(It.isAny(), It.isAny(), It.isAny())).returns(() => "--");
-        _separatorPadCalculator.setup(_ => _.getRightPadding(It.isAny(), It.isAny(), It.isAny())).returns(() => "--");
-
-        const separatorRowViewModel = sut.buildSeparator(table);
-
-        for (let col = 0; col < separatorRowViewModel.columnCount; col++)
-            assert.equal(separatorRowViewModel.getValueAt(col), "---:");
-    });
+    test("Calls alignment marker strategy and the marker returned from it", () => {
+        const alignment = Alignment.Left;
+        let marker = Mock.ofType<IAlignmentMarker>();
+        marker.setup(_ => _.mark("abcd")).returns((param) => param).verifiable(Times.exactly(3));
+        let alignmentMarkerStrategy = Mock.ofType<AlignmentMarkerStrategy>();
+        alignmentMarkerStrategy.setup(_ => _.markerFor(alignment)).returns(() => marker.object).verifiable(Times.exactly(3));
 
-    test("Centrally aligned column separator starts and ends with :", () => {
-        const sut = createFactory(_contentPadCalculator.object, _separatorPadCalculator.object);
-        const table = threeColumnTable(Alignment.Center);
+        const sut = createFactory(_contentPadCalculator.object, _separatorPadCalculator.object, alignmentMarkerStrategy.object);
+        const table = threeColumnTable(alignment);
 
-        _separatorPadCalculator.setup(_ => _.getLeftPadding(It.isAny(), It.isAny(), It.isAny())).returns(() => "--");
-        _separatorPadCalculator.setup(_ => _.getRightPadding(It.isAny(), It.isAny(), It.isAny())).returns(() => "--");
+        _separatorPadCalculator.setup(_ => _.getLeftPadding(It.isAny(), It.isAny(), It.isAny())).returns(() => "ab");
+        _separatorPadCalculator.setup(_ => _.getRightPadding(It.isAny(), It.isAny(), It.isAny())).returns(() => "cd");
 
-        const separatorRowViewModel = sut.buildSeparator(table);
+        sut.buildSeparator(table);
 
-        for (let col = 0; col < separatorRowViewModel.columnCount; col++)
-            assert.equal(separatorRowViewModel.getValueAt(col), ":--:");
+        marker.verifyAll();
+        alignmentMarkerStrategy.verifyAll();
     });
 });
 
@@ -204,6 +185,9 @@ function tableFor(rows: string[][], alignment: Alignment) {
     return table;
 }
 
-function createFactory(contentPadCalculator: PadCalculator, separatorPadCalculator: PadCalculator): RowViewModelFactory {
-    return new RowViewModelFactory(contentPadCalculator, separatorPadCalculator);
+function createFactory(contentPadCalculator: PadCalculator, separatorPadCalculator: PadCalculator, 
+    alignmentStrategy: AlignmentMarkerStrategy = null): RowViewModelFactory 
+{
+    alignmentStrategy = alignmentStrategy == null ? new AlignmentMarkerStrategy() : alignmentStrategy;
+    return new RowViewModelFactory(contentPadCalculator, separatorPadCalculator, alignmentStrategy);
 }