Improve docs, and match API of other parsers

2 files changed, 114 insertions, 112 deletions

diff --git a/test/example.wmap b/test/example.wmap
index a238ab1..f090da2 100644
--- a/test/example.wmap
+++ b/test/example.wmap
@@ -59,7 +59,7 @@ OK.
 
 This map so far is fst. asdasd asda
 
-Holy shit, this is still indeed fast. But everything flashes as I type! This is now happening so fast
+Holy moly, this is still indeed fast. But everything flashes as I type! This is now happening so fast
 
 Hello my old friend.
 
@@ -119,4 +119,4 @@ test2asdasa asdasd asd
 [Note] (5, 35) Notes also influence the placement of\n labels.
 
 [Group] Tailor2, Tailor7, Tailor11, Tailor12, Tailor10, Anchor, Tinker
-[Group] Tailor3, Tailor5, Tailor14pr
\ No newline at end of file
+[Group] Tailor3, Tailor5, Tailor14pr
diff --git a/test/parser.test.js b/test/parser.test.js
index 13ddd72..db0f02a 100644
--- a/test/parser.test.js
+++ b/test/parser.test.js
@@ -8,43 +8,47 @@ describe("wmap parser", () => {
             const source = "Dominoes (0.9, 0.5)";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 1);
-            assert.strictEqual(result.entities[0].type, "component");
-            assert.strictEqual(result.entities[0].label, "Dominoes");
-            assert.deepStrictEqual(result.entities[0].coordinates, [0.9, 0.5]);
-            assert.strictEqual(result.entities[0].shape, "circle");
+            assert.strictEqual(result.components.length, 1);
+            assert.strictEqual(result.components[0].label, "Dominoes");
+            assert.deepStrictEqual(
+                result.components[0].coordinates,
+                [0.9, 0.5],
+            );
+            assert.strictEqual(result.components[0].shape, "circle");
         });
 
         it("should parse a component with shape", async () => {
             const source = "Database (0.33, 0.81) [Square]";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 1);
-            assert.strictEqual(result.entities[0].type, "component");
-            assert.strictEqual(result.entities[0].label, "Database");
-            assert.deepStrictEqual(result.entities[0].coordinates, [0.33, 0.81]);
-            assert.strictEqual(result.entities[0].shape, "square");
+            assert.strictEqual(result.components.length, 1);
+            assert.strictEqual(result.components[0].label, "Database");
+            assert.deepStrictEqual(
+                result.components[0].coordinates,
+                [0.33, 0.81],
+            );
+            assert.strictEqual(result.components[0].shape, "square");
         });
 
         it("should parse component with x shape", async () => {
             const source = "API (0.5, 0.6) [x]";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].shape, "x");
+            assert.strictEqual(result.components[0].shape, "x");
         });
 
         it("should parse component with triangle shape", async () => {
             const source = "Service (0.4, 0.7) [Triangle]";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].shape, "triangle");
+            assert.strictEqual(result.components[0].shape, "triangle");
         });
 
         it("should parse component with circle shape", async () => {
             const source = "Process (0.2, 0.9) [CIRCLE]";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].shape, "circle");
+            assert.strictEqual(result.components[0].shape, "circle");
         });
 
         it("should handle decimal numbers", async () => {
@@ -52,7 +56,7 @@ describe("wmap parser", () => {
             const result = parse(source);
 
             assert.deepStrictEqual(
-                result.entities[0].coordinates,
+                result.components[0].coordinates,
                 [0.5, 0.123],
             );
         });
@@ -61,30 +65,33 @@ describe("wmap parser", () => {
             const source = "Item (1, 0)";
             const result = parse(source);
 
-            assert.deepStrictEqual(result.entities[0].coordinates, [1, 0]);
+            assert.deepStrictEqual(result.components[0].coordinates, [1, 0]);
         });
 
         it("should preserve case in component labels", async () => {
             const source = "RubberGaskets (0.5, 0.5)";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].label, "RubberGaskets");
+            assert.strictEqual(result.components[0].label, "RubberGaskets");
         });
 
         it("should handle component labels with spaces", async () => {
             const source = "Big Lawnmowers (0.5, 0.5)";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].label, "Big Lawnmowers");
+            assert.strictEqual(result.components[0].label, "Big Lawnmowers");
         });
 
         it("should handle whitespace around tokens", async () => {
             const source = "  Outer Space  (  0.9  ,  0.5  )  [  Square  ]  ";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].label, "Outer Space");
-            assert.deepStrictEqual(result.entities[0].coordinates, [0.9, 0.5]);
-            assert.strictEqual(result.entities[0].shape, "square");
+            assert.strictEqual(result.components[0].label, "Outer Space");
+            assert.deepStrictEqual(
+                result.components[0].coordinates,
+                [0.9, 0.5],
+            );
+            assert.strictEqual(result.components[0].shape, "square");
         });
     });
 
@@ -93,37 +100,38 @@ describe("wmap parser", () => {
             const source = "Smoke -- Fire";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 1);
-            assert.strictEqual(result.entities[0].type, "dependency");
-            assert.strictEqual(result.entities[0].from, "Smoke");
-            assert.strictEqual(result.entities[0].to, "Fire");
-            assert.strictEqual(result.entities[0].isDirected, false);
+            assert.strictEqual(result.dependencies.length, 1);
+            assert.strictEqual(result.dependencies[0].from, "Smoke");
+            assert.strictEqual(result.dependencies[0].to, "Fire");
+            assert.strictEqual(result.dependencies[0].isDirected, false);
         });
 
         it("should parse directed dependency", async () => {
             const source = "Cool Thing -> Different Cool Thing";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].type, "dependency");
-            assert.strictEqual(result.entities[0].from, "Cool Thing");
-            assert.strictEqual(result.entities[0].to, "Different Cool Thing");
-            assert.strictEqual(result.entities[0].isDirected, true);
+            assert.strictEqual(result.dependencies[0].from, "Cool Thing");
+            assert.strictEqual(
+                result.dependencies[0].to,
+                "Different Cool Thing",
+            );
+            assert.strictEqual(result.dependencies[0].isDirected, true);
         });
 
         it("should preserve case in dependency labels", async () => {
             const source = "SaRcAsM -> Seriousness.";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].from, "SaRcAsM");
-            assert.strictEqual(result.entities[0].to, "Seriousness.");
+            assert.strictEqual(result.dependencies[0].from, "SaRcAsM");
+            assert.strictEqual(result.dependencies[0].to, "Seriousness.");
         });
 
         it("should ignore whitespace in dependencies", async () => {
             const source = "     loose      --TIGHT";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].from, "loose");
-            assert.strictEqual(result.entities[0].to, "TIGHT");
+            assert.strictEqual(result.dependencies[0].from, "loose");
+            assert.strictEqual(result.dependencies[0].to, "TIGHT");
         });
     });
 
@@ -132,31 +140,30 @@ describe("wmap parser", () => {
             const source = "[Note] (0.5, 0.5) This is a note";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 1);
-            assert.strictEqual(result.entities[0].type, "note");
-            assert.deepStrictEqual(result.entities[0].coordinates, [0.5, 0.5]);
-            assert.strictEqual(result.entities[0].text, "This is a note");
+            assert.strictEqual(result.notes.length, 1);
+            assert.deepStrictEqual(result.notes[0].coordinates, [0.5, 0.5]);
+            assert.strictEqual(result.notes[0].text, "This is a note");
         });
 
         it("should handle case insensitive note keyword", async () => {
             const source = "[note] (0.1, 0.2) Text";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].type, "note");
+            assert.strictEqual(result.notes.length, 1);
         });
 
         it("should preserve case in note text", async () => {
             const source = "[NOTE] (0.77, 0.19) Important NOTE";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].text, "Important NOTE");
+            assert.strictEqual(result.notes[0].text, "Important NOTE");
         });
 
         it("should handle empty note text", async () => {
             const source = "[Note] (0.5, 0.5) ";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].text, "");
+            assert.strictEqual(result.notes[0].text, "");
         });
     });
 
@@ -165,41 +172,40 @@ describe("wmap parser", () => {
             const source = "[I] 0.25";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 1);
-            assert.strictEqual(result.entities[0].type, "stage");
-            assert.strictEqual(result.entities[0].stage, "i");
-            assert.strictEqual(result.entities[0].value, 0.25);
+            assert.strictEqual(result.stages.length, 1);
+            assert.strictEqual(result.stages[0].stage, "i");
+            assert.strictEqual(result.stages[0].value, 0.25);
         });
 
         it("should parse stage II", async () => {
             const source = "[ii] 0.5";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].stage, "ii");
-            assert.strictEqual(result.entities[0].value, 0.5);
+            assert.strictEqual(result.stages[0].stage, "ii");
+            assert.strictEqual(result.stages[0].value, 0.5);
         });
 
         it("should parse stage III", async () => {
             const source = "[III] 0.75";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].stage, "iii");
-            assert.strictEqual(result.entities[0].value, 0.75);
+            assert.strictEqual(result.stages[0].stage, "iii");
+            assert.strictEqual(result.stages[0].value, 0.75);
         });
 
         it("should parse stage IV", async () => {
             const source = "[Iv] 1.0";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].stage, "iv");
-            assert.strictEqual(result.entities[0].value, 1.0);
+            assert.strictEqual(result.stages[0].stage, "iv");
+            assert.strictEqual(result.stages[0].value, 1.0);
         });
 
         it("should handle decimal stage values", async () => {
             const source = "[I] .333";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].value, 0.333);
+            assert.strictEqual(result.stages[0].value, 0.333);
         });
     });
 
@@ -208,16 +214,15 @@ describe("wmap parser", () => {
             const source = "[Group] Lonely";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 1);
-            assert.strictEqual(result.entities[0].type, "group");
-            assert.deepStrictEqual(result.entities[0].components, ["Lonely"]);
+            assert.strictEqual(result.groups.length, 1);
+            assert.deepStrictEqual(result.groups[0].components, ["Lonely"]);
         });
 
         it("should parse a group with multiple components", async () => {
             const source = "[Group] Huey, Dewey, Louie";
             const result = parse(source);
 
-            assert.deepStrictEqual(result.entities[0].components, [
+            assert.deepStrictEqual(result.groups[0].components, [
                 "Huey",
                 "Dewey",
                 "Louie",
@@ -228,24 +233,25 @@ describe("wmap parser", () => {
             const source = "[group] Salt, Pepper";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].type, "group");
+            assert.strictEqual(result.groups.length, 1);
         });
 
         it("should preserve case in group component labels", async () => {
             const source = "[GROUP] XML, LaTeX";
             const result = parse(source);
 
-            assert.deepStrictEqual(result.entities[0].components, [
+            assert.deepStrictEqual(result.groups[0].components, [
                 "XML",
                 "LaTeX",
             ]);
         });
 
         it("should handle whitespace around commas", async () => {
-            const source = "[Group]    sky,    is  large,                      emperor";
+            const source =
+                "[Group]    sky,    is  large,                      emperor";
             const result = parse(source);
 
-            assert.deepStrictEqual(result.entities[0].components, [
+            assert.deepStrictEqual(result.groups[0].components, [
                 "sky",
                 "is  large",
                 "emperor",
@@ -258,23 +264,22 @@ describe("wmap parser", () => {
             const source = "[Inertia] Print Media";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 1);
-            assert.strictEqual(result.entities[0].type, "inertia");
-            assert.strictEqual(result.entities[0].component, "Print Media");
+            assert.strictEqual(result.inertias.length, 1);
+            assert.strictEqual(result.inertias[0].component, "Print Media");
         });
 
         it("should handle case insensitive inertia keyword", async () => {
             const source = "[inertia] Yes";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].type, "inertia");
+            assert.strictEqual(result.inertias.length, 1);
         });
 
         it("should preserve case in inertia component label", async () => {
             const source = "[INERTIA] SpOnGeBoB";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].component, "SpOnGeBoB");
+            assert.strictEqual(result.inertias[0].component, "SpOnGeBoB");
         });
     });
 
@@ -283,38 +288,37 @@ describe("wmap parser", () => {
             const source = "[Evolution] Nanomachines + 0.5";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 1);
-            assert.strictEqual(result.entities[0].type, "evolution");
-            assert.strictEqual(result.entities[0].component, "Nanomachines");
-            assert.strictEqual(result.entities[0].value, 0.5);
+            assert.strictEqual(result.evolutions.length, 1);
+            assert.strictEqual(result.evolutions[0].component, "Nanomachines");
+            assert.strictEqual(result.evolutions[0].value, 0.5);
         });
 
         it("should parse evolution with negative sign", async () => {
             const source = "[Evolution] FOXDIE - 0.3";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].value, -0.3);
+            assert.strictEqual(result.evolutions[0].value, -0.3);
         });
 
         it("should handle case insensitive evolution keyword", async () => {
             const source = "[evolution] tamales + 0.73";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].type, "evolution");
+            assert.strictEqual(result.evolutions.length, 1);
         });
 
         it("should preserve case in evolution component label", async () => {
             const source = "[EVOLUTION] iMac - 0.2";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].component, "iMac");
+            assert.strictEqual(result.evolutions[0].component, "iMac");
         });
 
         it("should handle decimal evolution values", async () => {
             const source = "[Evolution] Numerals + .75";
             const result = parse(source);
 
-            assert.strictEqual(result.entities[0].value, 0.75);
+            assert.strictEqual(result.evolutions[0].value, 0.75);
         });
     });
 
@@ -325,31 +329,29 @@ Bucket (0.8, 0.4) [x]
 Water -> Bucket`;
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 3);
-            assert.strictEqual(result.entities[0].type, "component");
-            assert.strictEqual(result.entities[1].type, "component");
-            assert.strictEqual(result.entities[2].type, "dependency");
+            assert.strictEqual(result.components.length, 2);
+            assert.strictEqual(result.dependencies.length, 1);
         });
 
         it("should handle different line endings (LF)", async () => {
             const source = "Penguins (0.9, 0.5)\nI Use Arch BTW (0.8, 0.4)";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 2);
+            assert.strictEqual(result.components.length, 2);
         });
 
         it("should handle different line endings (CRLF)", async () => {
             const source = "Clippy (0.9, 0.5)\r\nSpace Cadet (0.8, 0.4)";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 2);
+            assert.strictEqual(result.components.length, 2);
         });
 
         it("should handle different line endings (CR)", async () => {
             const source = "SE/30 (0.9, 0.5)\rPerforma (0.8, 0.4)";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 2);
+            assert.strictEqual(result.components.length, 2);
         });
 
         it("should handle empty lines", async () => {
@@ -358,21 +360,23 @@ Water -> Bucket`;
 The Abyss (0.8, 0.4)`;
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 2);
+            assert.strictEqual(result.components.length, 2);
         });
 
         it("should ignore invalid lines", async () => {
             const source = `Hello (0.9, 0.5)
 Oh No
 It's OK (0.8, 0.4)
-NO IT ISN'T
+[ijole] NO IT ISN'T
+A--
+B->
 Hello -> It's OK`;
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 3);
-            assert.strictEqual(result.entities[0].label, "Hello");
-            assert.strictEqual(result.entities[1].label, "It's OK");
-            assert.strictEqual(result.entities[2].type, "dependency");
+            assert.strictEqual(result.components.length, 2);
+            assert.strictEqual(result.components[0].label, "Hello");
+            assert.strictEqual(result.components[1].label, "It's OK");
+            assert.strictEqual(result.dependencies.length, 1);
         });
     });
 
@@ -381,21 +385,27 @@ Hello -> It's OK`;
             const source = "";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 0);
+            assert.strictEqual(result.components.length, 0);
+            assert.strictEqual(result.dependencies.length, 0);
+            assert.strictEqual(result.notes.length, 0);
+            assert.strictEqual(result.stages.length, 0);
+            assert.strictEqual(result.groups.length, 0);
+            assert.strictEqual(result.inertias.length, 0);
+            assert.strictEqual(result.evolutions.length, 0);
         });
 
         it("should handle only whitespace", async () => {
             const source = "   \n  \n  ";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 0);
+            assert.strictEqual(result.components.length, 0);
         });
 
         it("should handle only invalid lines", async () => {
             const source = "invalid\nstill invalid";
             const result = parse(source);
 
-            assert.strictEqual(result.entities.length, 0);
+            assert.strictEqual(result.components.length, 0);
         });
 
         it("should handle complex component labels", async () => {
@@ -403,7 +413,7 @@ Hello -> It's OK`;
             const result = parse(source);
 
             assert.strictEqual(
-                result.entities[0].label,
+                result.components[0].label,
                 "My Sü'per Complex Label 123",
             );
         });
@@ -433,30 +443,22 @@ Kettle -> Hot Water
 
             const result = parse(source);
 
-            // 4 stages + 4 components + 3 dependencies + 1 note + 1 group + 1 inertia + 1 evolution = 15
-            assert.strictEqual(result.entities.length, 15);
-
-            assert.strictEqual(result.entities[0].type, "stage");
-            assert.strictEqual(result.entities[1].type, "stage");
-            assert.strictEqual(result.entities[2].type, "stage");
-            assert.strictEqual(result.entities[3].type, "stage");
-
-            assert.strictEqual(result.entities[4].type, "component");
-            assert.strictEqual(result.entities[4].label, "Tea");
-            assert.strictEqual(result.entities[4].shape, "circle");
-
-            assert.strictEqual(result.entities[8].type, "dependency");
-            assert.strictEqual(result.entities[8].from, "Tea");
-            assert.strictEqual(result.entities[8].to, "Cup");
-
-            assert.strictEqual(result.entities[11].type, "note");
+            // 4 stages + 4 components + 3 dependencies + 1 note + 1 group + 1 inertia + 1 evolution
+            assert.strictEqual(result.stages.length, 4);
+            assert.strictEqual(result.components.length, 4);
+            assert.strictEqual(result.dependencies.length, 3);
+            assert.strictEqual(result.notes.length, 1);
+            assert.strictEqual(result.groups.length, 1);
+            assert.strictEqual(result.inertias.length, 1);
+            assert.strictEqual(result.evolutions.length, 1);
 
-            assert.strictEqual(result.entities[12].type, "group");
-            assert.strictEqual(result.entities[12].components.length, 3);
+            assert.strictEqual(result.components[0].label, "Tea");
+            assert.strictEqual(result.components[0].shape, "circle");
 
-            assert.strictEqual(result.entities[13].type, "inertia");
+            assert.strictEqual(result.dependencies[0].from, "Tea");
+            assert.strictEqual(result.dependencies[0].to, "Cup");
 
-            assert.strictEqual(result.entities[14].type, "evolution");
+            assert.strictEqual(result.groups[0].components.length, 3);
         });
     });
 });