wyreframe 0.1.0

package/src/parser/Semantic/Elements/__tests__/TextParser_test.res

@@ -0,0 +1,167 @@
+// TextParser_test.res
+// Unit tests for the TextParser fallback module
+
+open Vitest
+
+// Create a test parser instance
+let parser = TextParser.make()
+
+// Helper to create a test position
+let makePosition = (row: int, col: int): Types.Position.t => Types.Position.make(row, col)
+
+// Helper to create test bounds
+let makeBounds = (~top: int, ~left: int, ~bottom: int, ~right: int): Types.Bounds.t => {
+  top: top,
+  left: left,
+  bottom: bottom,
+  right: right,
+}
+
+describe("TextParser", () => {
+  describe("priority", () => {
+    test("should have lowest priority (1)", t => {
+      t->expect(parser.priority)->Expect.toBe(1)
+    })
+  })
+
+  describe("canParse", () => {
+    test("should always return true for any content", t => {
+      t->expect(parser.canParse("hello world"))->Expect.toBe(true)
+    })
+
+    test("should return true for empty string", t => {
+      t->expect(parser.canParse(""))->Expect.toBe(true)
+    })
+
+    test("should return true for special characters", t => {
+      t->expect(parser.canParse("!@#$%^&*()"))->Expect.toBe(true)
+    })
+
+    test("should return true for numbers", t => {
+      t->expect(parser.canParse("12345"))->Expect.toBe(true)
+    })
+
+    test("should return true for content that looks like other elements", t => {
+      // Even if content matches other patterns, TextParser accepts it
+      // (though it would normally be caught by higher-priority parsers first)
+      t->expect(parser.canParse("[ Button ]"))->Expect.toBe(true)
+      t->expect(parser.canParse("#input"))->Expect.toBe(true)
+      t->expect(parser.canParse("\"Link\""))->Expect.toBe(true)
+      t->expect(parser.canParse("[x] Checkbox"))->Expect.toBe(true)
+      t->expect(parser.canParse("* Emphasis"))->Expect.toBe(true)
+    })
+
+    test("should return true for whitespace-only content", t => {
+      t->expect(parser.canParse("   "))->Expect.toBe(true)
+      t->expect(parser.canParse("\t"))->Expect.toBe(true)
+    })
+  })
+
+  describe("parse", () => {
+    let pos = makePosition(5, 10)
+    let bounds = makeBounds(~top=0, ~left=0, ~bottom=10, ~right=20)
+
+    test("should parse plain text content", t => {
+      let result = parser.parse("Hello World", pos, bounds)
+
+      switch result {
+      | Some(Types.Text({content, emphasis, position, align})) => {
+          t->expect(content)->Expect.toBe("Hello World")
+          t->expect(emphasis)->Expect.toBe(false)
+          t->expect(position)->Expect.toEqual(pos)
+          t->expect(align)->Expect.toBe(Types.Left)
+        }
+      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Text element
+      }
+    })
+
+    test("should set emphasis to false by default", t => {
+      let result = parser.parse("Some text", pos, bounds)
+
+      switch result {
+      | Some(Types.Text({emphasis})) => t->expect(emphasis)->Expect.toBe(false)
+      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Text element
+      }
+    })
+
+    test("should preserve the exact content without modification", t => {
+      let testCases = [
+        "plain text",
+        "  whitespace preserved  ",
+        "UPPERCASE",
+        "123numbers",
+        "special!@#chars",
+        "",
+      ]
+
+      testCases->Array.forEach(content => {
+        let result = parser.parse(content, pos, bounds)
+
+        switch result {
+        | Some(Types.Text({content: parsed})) =>
+          t->expect(parsed)->Expect.toBe(content)
+        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Text element
+        }
+      })
+    })
+
+    test("should capture unrecognized patterns", t => {
+      // These patterns don't match standard element syntax
+      let unrecognizedPatterns = [
+        "This is just text",
+        "No special syntax here",
+        "Random content 123",
+        "Unmatched [ bracket",
+        "Partial #",
+        "Quote without end\"",
+      ]
+
+      unrecognizedPatterns->Array.forEach(content => {
+        let result = parser.parse(content, pos, bounds)
+
+        switch result {
+        | Some(Types.Text(_)) => () // Success - pattern matched
+        | _ => t->expect(true)->Expect.toBe(false) // fail: Should parse unrecognized pattern
+        }
+      })
+    })
+
+    test("should use provided position", t => {
+      let customPos = makePosition(42, 17)
+      let result = parser.parse("test", customPos, bounds)
+
+      switch result {
+      | Some(Types.Text({position})) => {
+          t->expect(position.row)->Expect.toBe(42)
+          t->expect(position.col)->Expect.toBe(17)
+        }
+      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Text element
+      }
+    })
+
+    test("should always use Left alignment for fallback text", t => {
+      // TextParser uses Left alignment by default for simplicity
+      // More sophisticated alignment is handled by specific parsers
+      let result = parser.parse("centered text", pos, bounds)
+
+      switch result {
+      | Some(Types.Text({align})) => t->expect(align)->Expect.toBe(Types.Left)
+      | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Text element
+      }
+    })
+  })
+
+  describe("integration with ParserRegistry", () => {
+    test("should act as fallback when no other parser matches", t => {
+      // Simulate content that no specific parser would recognize
+      let unknownContent = "This is completely unstructured text"
+      let result = parser.parse(unknownContent, makePosition(0, 0), makeBounds(~top=0, ~left=0, ~bottom=10, ~right=50))
+
+      switch result {
+      | Some(Types.Text({content})) =>
+        t->expect(content)->Expect.toBe(unknownContent)
+      | _ => t->expect(true)->Expect.toBe(false) // fail: TextParser should catch unrecognized content
+      }
+    })
+  })
+})

package/src/parser/Semantic/ParserRegistry.mjs

@@ -0,0 +1,82 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Types from "../Core/Types.mjs";
+import * as LinkParser from "./Elements/LinkParser.mjs";
+import * as TextParser from "./Elements/TextParser.mjs";
+import * as InputParser from "./Elements/InputParser.mjs";
+import * as ButtonParser from "./Elements/ButtonParser.mjs";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as CheckboxParser from "./Elements/CheckboxParser.mjs";
+import * as CodeTextParser from "./Elements/CodeTextParser.mjs";
+import * as EmphasisParser from "./Elements/EmphasisParser.mjs";
+
+function make() {
+  return {
+    parsers: []
+  };
+}
+
+function register(registry, parser) {
+  registry.parsers.push(parser);
+  registry.parsers = registry.parsers.toSorted((a, b) => Primitive_int.compare(b.priority, a.priority));
+}
+
+function parse(registry, content, position, bounds) {
+  let result;
+  for (let i = 0, i_finish = registry.parsers.length; i < i_finish; ++i) {
+    let match = result;
+    if (match === undefined) {
+      let parser = registry.parsers[i];
+      if (parser.canParse(content)) {
+        let element = parser.parse(content, position, bounds);
+        if (element !== undefined) {
+          result = element;
+        }
+      }
+    }
+  }
+  let element$1 = result;
+  if (element$1 !== undefined) {
+    return element$1;
+  } else {
+    return {
+      TAG: "Text",
+      content: content,
+      emphasis: false,
+      position: Types.Position.make(position.row, position.col),
+      align: "Left"
+    };
+  }
+}
+
+function makeDefault() {
+  let registry = {
+    parsers: []
+  };
+  register(registry, ButtonParser.make());
+  register(registry, InputParser.make());
+  register(registry, CheckboxParser.make());
+  register(registry, LinkParser.make());
+  register(registry, CodeTextParser.make());
+  register(registry, EmphasisParser.make());
+  register(registry, TextParser.make());
+  return registry;
+}
+
+function count(registry) {
+  return registry.parsers.length;
+}
+
+function getParsers(registry) {
+  return registry.parsers;
+}
+
+export {
+  make,
+  register,
+  parse,
+  makeDefault,
+  count,
+  getParsers,
+}
+/* Types Not a pure module */

package/src/parser/Semantic/ParserRegistry.res

@@ -0,0 +1,145 @@
+// ParserRegistry.res
+// Registry for element parsers with priority-based ordering
+
+open Types
+
+/**
+ * The parser registry type.
+ * Contains a mutable array of element parsers sorted by priority (descending).
+ */
+type t = {
+  mutable parsers: array<ElementParser.elementParser>,
+}
+
+/**
+ * Create a new empty parser registry.
+ *
+ * @return A new registry instance with no registered parsers
+ */
+let make = (): t => {
+  {parsers: []}
+}
+
+/**
+ * Register an element parser in the registry.
+ * Parsers are automatically sorted by priority (highest first).
+ *
+ * @param registry - The registry to add the parser to
+ * @param parser - The element parser to register
+ */
+let register = (registry: t, parser: ElementParser.elementParser): unit => {
+  // Add parser to array
+  registry.parsers->Array.push(parser)->ignore
+
+  // Re-sort by priority (descending - highest priority first)
+  registry.parsers = registry.parsers->Array.toSorted((a, b) => {
+    Int.toFloat(compare(b.priority, a.priority))
+  })
+}
+
+/**
+ * Parse content using registered parsers.
+ *
+ * Tries each parser in priority order until one succeeds.
+ * The first parser whose canParse() returns true AND whose parse() returns Some(element)
+ * will be used, and remaining parsers will be skipped.
+ *
+ * If no parser succeeds, returns a default Text element (fallback).
+ *
+ * @param registry - The registry containing registered parsers
+ * @param content - The text content to parse
+ * @param position - Grid position where content appears
+ * @param bounds - Bounding box of containing box
+ * @return A parsed element (never None because of fallback)
+ */
+let parse = (
+  registry: t,
+  content: string,
+  position: Position.t,
+  bounds: Bounds.t,
+): Types.element => {
+  // Try each parser in priority order
+  let result = ref(None)
+
+  for i in 0 to Array.length(registry.parsers) - 1 {
+    switch result.contents {
+    | Some(_) => () // Already found a match, skip remaining
+    | None => {
+        let parser = registry.parsers->Array.getUnsafe(i)
+
+        // First check if parser can handle this content
+        if parser.canParse(content) {
+          // Try to parse
+          switch parser.parse(content, position, bounds) {
+          | Some(element) => result := Some(element)
+          | None => () // This parser couldn't parse it, try next
+          }
+        }
+      }
+    }
+  }
+
+  // Return result or fallback to plain text
+  switch result.contents {
+  | Some(element) => element
+  | None =>
+    // Fallback: create a plain text element if no parser matched
+    // This shouldn't happen if TextParser is registered, but provides safety
+    Types.Text({
+      content: content,
+      emphasis: false,
+      position: Types.Position.make(position.row, position.col),
+      align: Types.Left,
+    })
+  }
+}
+
+/**
+ * Create a registry with all default parsers pre-registered.
+ *
+ * Registers parsers in this priority order:
+ * 1. ButtonParser (priority 100)
+ * 2. InputParser (priority 90)
+ * 3. CheckboxParser (priority 85)
+ * 4. LinkParser (priority 80)
+ * 5. CodeTextParser (priority 75) - backtick-wrapped text with position-based alignment
+ * 6. EmphasisParser (priority 70)
+ * 7. TextParser (priority 1) - fallback
+ *
+ * @return A registry with all standard parsers registered
+ */
+let makeDefault = (): t => {
+  let registry = make()
+
+  // Register all standard parsers
+  // They'll be automatically sorted by priority
+  registry->register(ButtonParser.make())
+  registry->register(InputParser.make())
+  registry->register(CheckboxParser.make())
+  registry->register(LinkParser.make())
+  registry->register(CodeTextParser.make())
+  registry->register(EmphasisParser.make())
+  registry->register(TextParser.make()) // Fallback with priority 1
+
+  registry
+}
+
+/**
+ * Get the number of registered parsers.
+ *
+ * @param registry - The registry to query
+ * @return The number of parsers registered
+ */
+let count = (registry: t): int => {
+  Array.length(registry.parsers)
+}
+
+/**
+ * Get all registered parsers (sorted by priority).
+ *
+ * @param registry - The registry to query
+ * @return Array of registered parsers in priority order
+ */
+let getParsers = (registry: t): array<ElementParser.elementParser> => {
+  registry.parsers
+}