wyreframe 0.1.0

package/src/parser/Detector/ShapeDetector.res

@@ -0,0 +1,236 @@
+// ShapeDetector.res
+// Main Shape Detector Module - Stage 2 of the parser pipeline
+//
+// Integrates BoxTracer, DividerDetector, and HierarchyBuilder to:
+// 1. Find all boxes in the grid
+// 2. Detect dividers within boxes
+// 3. Build nesting hierarchy
+// 4. Collect all errors without early stopping
+//
+// Requirements:
+// - REQ-28: Reliability - Error Recovery (collect all errors)
+
+open Types
+
+// ============================================================================
+// Type Definitions
+// ============================================================================
+
+/**
+ * Result type for shape detection.
+ * Returns either:
+ * - Ok(boxes): Array of root-level boxes with nested hierarchy
+ * - Error(errors): Array of all errors encountered during detection
+ */
+type detectResult = result<array<BoxTracer.box>, array<ErrorTypes.t>>
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Convert HierarchyBuilder.hierarchyError to ErrorTypes.t
+ */
+let hierarchyErrorToParseError = (error: HierarchyBuilder.hierarchyError): ErrorTypes.t => {
+  switch error {
+  | OverlappingBoxes({box1, box2}) =>
+    ErrorTypes.make(
+      InvalidElement({
+        content: `Overlapping boxes detected at (${Int.toString(box1.bounds.top)},${Int.toString(
+            box1.bounds.left,
+          )}) and (${Int.toString(box2.bounds.top)},${Int.toString(box2.bounds.left)})`,
+        position: {row: box1.bounds.top, col: box1.bounds.left},
+      }),
+      None,
+    )
+  | CircularNesting =>
+    ErrorTypes.make(
+      InvalidElement({
+        content: "Circular nesting detected in box hierarchy",
+        position: {row: 0, col: 0},
+      }),
+      None,
+    )
+  }
+}
+
+// ============================================================================
+// Helper Functions (must be defined before detect)
+// ============================================================================
+
+/**
+ * Remove duplicate boxes that have the same bounds.
+ *
+ * This handles the case where multiple corners might trace the same box.
+ * We keep only the first occurrence of each unique box.
+ *
+ * @param boxes - Array of traced boxes
+ * @return Array of unique boxes (deduplicated by bounds)
+ */
+let deduplicateBoxes = (boxes: array<BoxTracer.box>): array<BoxTracer.box> => {
+  let seen = []
+  let unique = []
+
+  boxes->Array.forEach(box => {
+    // Check if we've seen a box with these bounds before
+    let isDuplicate = seen->Array.some(seenBounds => {
+      Bounds.equals(seenBounds, box.bounds)
+    })
+
+    if !isDuplicate {
+      // New unique box
+      unique->Array.push(box)
+      seen->Array.push(box.bounds)
+    }
+  })
+
+  unique
+}
+
+// ============================================================================
+// Main Detection Function
+// ============================================================================
+
+/**
+ * Detect all shapes (boxes, dividers) in the grid and build hierarchy.
+ *
+ * Algorithm:
+ * 1. Find all '+' corner positions using grid.cornerIndex
+ * 2. For each corner, attempt to trace a box using BoxTracer
+ * 3. Collect all successfully traced boxes
+ * 4. For each box, detect dividers within its bounds
+ * 5. Build parent-child hierarchy using HierarchyBuilder
+ * 6. Return Result with boxes or errors
+ *
+ * IMPORTANT: Not all '+' corners are top-left corners of boxes.
+ * A '+' can be a top-right, bottom-left, bottom-right corner, or
+ * part of nested box structure. traceBox failures for non-top-left
+ * corners are EXPECTED and should NOT be treated as errors.
+ *
+ * @param grid - The 2D character grid from GridScanner
+ * @return detectResult - Ok(root boxes) or Error(all errors)
+ *
+ * Requirements: REQ-28 (Error Recovery - no early stopping)
+ */
+let detect = (grid: Grid.t): detectResult => {
+  // Step 1: Find all '+' corner positions using pre-built index
+  let corners = grid.cornerIndex
+
+  // Step 2: Trace boxes from each corner
+  // Note: Most corners will NOT be valid top-left corners, which is expected.
+  // Only corners that are actually top-left of a box will trace successfully.
+  let boxes = []
+  let traceFailures = [] // Keep track of failures
+
+  corners->Array.forEach(corner => {
+    switch BoxTracer.traceBox(grid, corner) {
+    | Ok(box) => {
+        // Successfully traced a box - add to collection
+        boxes->Array.push(box)
+      }
+    | Error(traceError) => {
+        // This corner failed to trace as a top-left corner.
+        // Could be a non-top-left corner (expected) or a malformed box (error).
+        traceFailures->Array.push(traceError)
+      }
+    }
+  })
+
+  // Step 3: Check if we found any boxes
+  if Array.length(boxes) === 0 {
+    // No boxes traced successfully
+    if Array.length(corners) === 0 {
+      // No corners at all - truly empty wireframe
+      Ok([])
+    } else if Array.length(traceFailures) > 0 {
+      // Had corners but all traces failed - this indicates malformed boxes
+      // Return all trace failures as errors
+      Error(traceFailures)
+    } else {
+      // No corners and no failures - empty result
+      Ok([])
+    }
+  } else {
+    // Step 4: Detect dividers for each successfully traced box
+    // TODO: Implement when DividerDetector module is available
+
+    // Step 5: Remove duplicate boxes (same bounds traced multiple times)
+    let uniqueBoxes = deduplicateBoxes(boxes)
+
+    // Step 6: Build hierarchy using HierarchyBuilder
+    switch HierarchyBuilder.buildHierarchy(uniqueBoxes) {
+    | Ok(rootBoxes) => {
+        // Hierarchy built successfully - return the boxes
+        Ok(rootBoxes)
+      }
+    | Error(hierarchyError) => {
+        // Hierarchy building failed (e.g., overlapping boxes)
+        // This IS a real error that should be reported
+        let parseError = hierarchyErrorToParseError(hierarchyError)
+        Error([parseError])
+      }
+    }
+  }
+}
+
+// ============================================================================
+// Additional Helper Functions
+// ============================================================================
+
+/**
+ * Count total number of boxes including nested children.
+ *
+ * @param boxes - Array of boxes (can include nested children)
+ * @return Total count of all boxes
+ */
+let rec countBoxes = (boxes: array<BoxTracer.box>): int => {
+  boxes->Array.reduce(0, (acc, box) => {
+    1 + acc + countBoxes(box.children)
+  })
+}
+
+/**
+ * Get all boxes as a flat array (including nested children).
+ *
+ * @param boxes - Array of root boxes
+ * @return Flat array of all boxes
+ */
+let rec flattenBoxes = (boxes: array<BoxTracer.box>): array<BoxTracer.box> => {
+  boxes->Array.reduce([], (acc, box) => {
+    let childBoxes = flattenBoxes(box.children)
+    Array.concat(Array.concat(acc, [box]), childBoxes)
+  })
+}
+
+/**
+ * Get statistics about detected shapes for debugging.
+ *
+ * @param result - Detection result
+ * @return String with statistics
+ */
+let getStats = (result: detectResult): string => {
+  switch result {
+  | Ok(boxes) => {
+      let rootCount = Array.length(boxes)
+      let totalCount = countBoxes(boxes)
+      `Shape Detection Success:
+  Root boxes: ${Int.toString(rootCount)}
+  Total boxes (including nested): ${Int.toString(totalCount)}`
+    }
+  | Error(errors) => {
+      let errorCount = Array.length(errors)
+      let warningCount = errors->Array.reduce(0, (acc, err) => {
+        if ErrorTypes.isWarning(err) {
+          acc + 1
+        } else {
+          acc
+        }
+      })
+      let realErrorCount = errorCount - warningCount
+
+      `Shape Detection Failed:
+  Errors: ${Int.toString(realErrorCount)}
+  Warnings: ${Int.toString(warningCount)}`
+    }
+  }
+}

package/src/parser/Detector/__tests__/BoxTracer_test.mjs

@@ -0,0 +1,70 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Grid from "../../Core/Grid.mjs";
+import * as Types from "../../Core/Types.mjs";
+import * as Vitest from "rescript-vitest/src/Vitest.mjs";
+import * as BoxTracer from "../BoxTracer.mjs";
+
+Vitest.describe("BoxTracer - Width Validation", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, () => {
+  Vitest.test("should detect mismatched width between top and bottom edges", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let input = [
+      "+-----+",
+      "|     |",
+      "+-------+"
+    ];
+    let grid = Grid.fromLines(input);
+    let topLeft = Types.Position.make(0, 0);
+    let result = BoxTracer.traceBox(grid, topLeft);
+    if (result.TAG === "Ok") {
+      return t.expect(true).toBe(false);
+    }
+    let match = result._0.code;
+    if (match.TAG !== "MismatchedWidth") {
+      return t.expect(true).toBe(false);
+    }
+    let pos = match.topLeft;
+    t.expect(match.topWidth).toBe(6);
+    t.expect(match.bottomWidth).toBe(8);
+    t.expect(pos.row).toBe(0);
+    t.expect(pos.col).toBe(0);
+  });
+  Vitest.test("should successfully trace box with matching widths", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let input = [
+      "+-----+",
+      "|     |",
+      "+-----+"
+    ];
+    let grid = Grid.fromLines(input);
+    let topLeft = Types.Position.make(0, 0);
+    let result = BoxTracer.traceBox(grid, topLeft);
+    if (result.TAG === "Ok") {
+      let box = result._0;
+      t.expect(box.bounds.top).toBe(0);
+      t.expect(box.bounds.left).toBe(0);
+      t.expect(box.bounds.bottom).toBe(2);
+      t.expect(box.bounds.right).toBe(6);
+      return t.expect(box.name).toBe(undefined);
+    }
+    console.log(result._0);
+    t.expect(true).toBe(false);
+  });
+  Vitest.test("should extract box name and validate width", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, t => {
+    let input = [
+      "+--Login--+",
+      "|         |",
+      "+--Login--+"
+    ];
+    let grid = Grid.fromLines(input);
+    let topLeft = Types.Position.make(0, 0);
+    let result = BoxTracer.traceBox(grid, topLeft);
+    if (result.TAG !== "Ok") {
+      return t.expect(true).toBe(false);
+    }
+    let box = result._0;
+    t.expect(box.name).toBe("Login");
+    t.expect(Types.Bounds.width(box.bounds)).toBe(10);
+    t.expect(Types.Bounds.height(box.bounds)).toBe(2);
+  });
+});
+
+/*  Not a pure module */

package/src/parser/Detector/__tests__/BoxTracer_test.res

@@ -0,0 +1,92 @@
+// BoxTracer_test.res
+// Unit tests for BoxTracer width validation and box tracing
+
+open Vitest
+
+describe("BoxTracer - Width Validation", () => {
+  test("should detect mismatched width between top and bottom edges", t => {
+    // Create a malformed box with different top and bottom widths
+    let input = [
+      "+-----+",  // Top: 7 chars wide (5 dashes + 2 corners)
+      "|     |",
+      "+-------+", // Bottom: 9 chars wide (7 dashes + 2 corners) - MISMATCH!
+    ]
+
+    let grid = Grid.fromLines(input)
+    let topLeft = Types.Position.make(0, 0)
+
+    let result = BoxTracer.traceBox(grid, topLeft)
+
+    switch result {
+    | Error(err) => {
+        // Verify we get a MismatchedWidth error
+        switch err.code {
+        | ErrorTypes.MismatchedWidth({topWidth, bottomWidth, topLeft: pos}) => {
+            t->expect(topWidth)->Expect.toBe(6)  // 0 to 6 = 6 chars
+            t->expect(bottomWidth)->Expect.toBe(8) // 0 to 8 = 8 chars
+            t->expect(pos.row)->Expect.toBe(0)
+            t->expect(pos.col)->Expect.toBe(0)
+          }
+        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected MismatchedWidth error
+        }
+      }
+    | Ok(_) => t->expect(true)->Expect.toBe(false) // fail: Expected error for mismatched width, but got Ok
+    }
+  })
+
+  test("should successfully trace box with matching widths", t => {
+    // Create a well-formed box with matching top and bottom widths
+    let input = [
+      "+-----+",
+      "|     |",
+      "+-----+", // Same width as top
+    ]
+
+    let grid = Grid.fromLines(input)
+    let topLeft = Types.Position.make(0, 0)
+
+    let result = BoxTracer.traceBox(grid, topLeft)
+
+    switch result {
+    | Ok(box) => {
+        // Verify box bounds are correct
+        t->expect(box.bounds.top)->Expect.toBe(0)
+        t->expect(box.bounds.left)->Expect.toBe(0)
+        t->expect(box.bounds.bottom)->Expect.toBe(2)
+        t->expect(box.bounds.right)->Expect.toBe(6)
+
+        // Verify no name (unnamed box)
+        t->expect(box.name)->Expect.toBe(None)
+      }
+    | Error(err) => {
+        Console.log(err)
+        t->expect(true)->Expect.toBe(false) // fail: Expected successful box trace for matching widths
+      }
+    }
+  })
+
+  test("should extract box name and validate width", t => {
+    let input = [
+      "+--Login--+",
+      "|         |",
+      "+--Login--+",
+    ]
+
+    let grid = Grid.fromLines(input)
+    let topLeft = Types.Position.make(0, 0)
+
+    let result = BoxTracer.traceBox(grid, topLeft)
+
+    switch result {
+    | Ok(box) => {
+        // Verify box name extraction
+        t->expect(box.name)->Expect.toBe(Some("Login"))
+
+        // Verify bounds
+        t->expect(Types.Bounds.width(box.bounds))->Expect.toBe(10)
+        t->expect(Types.Bounds.height(box.bounds))->Expect.toBe(2)
+      }
+    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful trace for named box
+    }
+  })
+})