Introduce NotSet alignment

Author: darkriszty

src/modelFactory/alignmentFactory.ts

@@ -1,23 +1,19 @@
 import { Alignment } from "../models/alignment";
 
 export class AlignmentFactory {
+
     public createAlignments(cells: string[]): Alignment[] {
-        let result: Alignment[] = [];
+        return cells.map(this.alignmentOf);
+    }
 
-        const len: number = cells.length;
-        for (let i = 0; i < len; i++) {
-            const cell = cells[i];
-            const left = cell[0] == ":";;
-            const right = cell[cell.length - 1] == ":";
+    private alignmentOf(cell: string): Alignment {
+        const left = cell[0] == ":";
+        const right = cell[cell.length - 1] == ":";
 
-            if (left && right)
-                result.push(Alignment.Center);
-            else if (right)
-                result.push(Alignment.Right);
-            else
-                result.push(Alignment.Left);
-        }
+        if (left && right) return Alignment.Center;
+        if (right) return Alignment.Right;
+        if (left) return Alignment.Left;
 
-        return result;
+        return Alignment.NotSet;
     }
 }

src/modelFactory/tableFactory.ts

@@ -18,9 +18,10 @@ export class TableFactory {
             throw new Error("Can't create table model from null table text.");
 
         const rowsWithoutSeparator = this._selectionInterpreter.allRows(text).filter((v, i) => i != 1);
+        const separator = this._selectionInterpreter.separator(text);
 
-        const alignments: Alignment[] = rowsWithoutSeparator != null && rowsWithoutSeparator.length > 1 
-            ? this._alignmentFactory.createAlignments(rowsWithoutSeparator[1]) 
+        const alignments: Alignment[] = separator != null && separator.length > 0
+            ? this._alignmentFactory.createAlignments(separator) 
             : [];
 
         const cells = rowsWithoutSeparator.map(row => row.map(c  => new Cell(c)));

src/models/alignment.ts

@@ -1,4 +1,5 @@
 export enum Alignment {
+    NotSet,
     Left,
     Center,
     Right

test/unitTests/modelFactory/alignmentFactory.test.ts

@@ -12,15 +12,15 @@ suite("AlignmentFactory tests", () => {
         assert.throws(() => sut.createAlignments(separatorCells))
     });
 
-    test("createAlignments() with separators without alignment defaults to left alignment", () => {
+    test("createAlignments() with separators without alignment defaults to NotSet alignment", () => {
         const separatorCells: string[] = ["---", "--", "-------"];
         const sut = createFactory();
 
         const alignments = sut.createAlignments(separatorCells);
         assert.equal(alignments.length, 3);
-        assert.equal(alignments[0], Alignment.Left);
-        assert.equal(alignments[1], Alignment.Left);
-        assert.equal(alignments[2], Alignment.Left);
+        assert.equal(alignments[0], Alignment.NotSet);
+        assert.equal(alignments[1], Alignment.NotSet);
+        assert.equal(alignments[2], Alignment.NotSet);
     });
 
     test("createAlignments() with separators having mixed alignments returns expected alignments", () => {
@@ -32,7 +32,7 @@ suite("AlignmentFactory tests", () => {
         assert.equal(alignments[0], Alignment.Center);
         assert.equal(alignments[1], Alignment.Left);
         assert.equal(alignments[2], Alignment.Left);
-        assert.equal(alignments[3], Alignment.Left);
+        assert.equal(alignments[3], Alignment.NotSet);
         assert.equal(alignments[4], Alignment.Right);
         assert.equal(alignments[5], Alignment.Center);
     });

test/unitTests/modelFactory/tableFactory.test.ts

@@ -106,11 +106,16 @@ suite("TableFactory tests", () => {
         const transformedTable = new Table([["c1", "c2", "", "c4"], ["a", "b", "", "d"]].map(row => row.map(c  => new Cell(c))), expectedAlignmets);
         _alignmentFactoryMock.setup(m => m.createAlignments(It.isAny())).returns(() => expectedAlignmets);
         _transformer.setup(_ => _.process(It.isAny())).returns(() => transformedTable);
+
         let selectionInterpreter: IMock<SelectionInterpreter> = Mock.ofType<SelectionInterpreter>();
         selectionInterpreter
             .setup(_ => _.allRows(It.isAny()))
             .returns(() => [["c1", "c2", "", "c4"], ["-","-","-","-"], ["a", "b", "", "d"]])
             .verifiable(Times.once());
+        selectionInterpreter
+            .setup(_ => _.separator(It.isAny()))
+            .returns(() => ["-","-","-","-"])
+            .verifiable(Times.once());
         const sut = createFactory(selectionInterpreter.object);
 
         sut.getModel("test");