Fix array rule corner overhang: outer vertical rules flush with horizontal rules (#261)

Fix array rule corner overhang: outer v-rules flush with h-rules

Horizontal rules span the full content box [0, contentWidth], but
columnOffsetsForTable: added padding on *both* sides of every vertical
rule — including outside the outermost rules. That inset the outer
verticals by `padding` from the box edges, so every \hline overhung the
outer `|` by `padding` on each side (visible as horizontal lines poking
past the box corners; MathJax/LaTeX meet flush).

Drop the outside padding on the outer boundaries (i==0, i==numColumns):
padding now lives only between a rule and the cell content, so the
outermost rules sit flush at x==0 / x==contentWidth — the same edges the
horizontal rules span. Interior boundaries keep padding on both sides.
Matrix path is untouched (fires only when verticalLines[i] > 0).

testArrayRuleGeometryIsDeterministic now pins the flush-corner invariant:
the leftmost v-rule stroke edge is at x=0 and each h-rule's ends coincide
with the outer v-rules' stroke edges instead of overhanging.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: kostub

iosMath/render/MTMathListDisplay.m

@@ -799,13 +799,19 @@ - (instancetype)initWithStart:(CGPoint)start length:(CGFloat)length thickness:(C
         _length = length;
         _thickness = thickness;
         _vertical = isVertical;
-        self.position = start;
         self.range = range;
+        // `start` is a point on the stroke's centre-line; a stroked path straddles it by
+        // thickness/2 on each side of the thickness axis. Record `position` as the box's
+        // lower-left origin so the display's bounds exactly cover the drawn stroke (else the
+        // parent over-reports its width/ascent by thickness/2 — see -draw:, which re-derives
+        // the centre-line). The length axis uses a butt cap, so it isn't inset.
         if (isVertical) {
+            self.position = CGPointMake(start.x - thickness / 2, start.y);
             self.width = thickness;
             self.ascent = length;
             self.descent = 0;
         } else {
+            self.position = CGPointMake(start.x, start.y - thickness / 2);
             self.width = length;
             self.ascent = thickness;
             self.descent = 0;
@@ -820,10 +826,15 @@ - (void)draw:(CGContextRef)context
     CGContextSaveGState(context);
     [self.textColor setStroke];
     MTBezierPath* path = [MTBezierPath bezierPath];
-    [path moveToPoint:self.position];
+    // position is the box origin; the stroke runs along the centre-line, offset thickness/2
+    // from the box edge on the thickness axis (the axis init inset when recording position).
+    CGPoint begin = _vertical
+        ? CGPointMake(self.position.x + _thickness / 2, self.position.y)
+        : CGPointMake(self.position.x, self.position.y + _thickness / 2);
+    [path moveToPoint:begin];
     CGPoint end = _vertical
-        ? CGPointMake(self.position.x, self.position.y + _length)
-        : CGPointMake(self.position.x + _length, self.position.y);
+        ? CGPointMake(begin.x, begin.y + _length)
+        : CGPointMake(begin.x + _length, begin.y);
     [path addLineToPoint:end];
     path.lineWidth = _thickness;
     [path stroke];

iosMath/render/internal/MTMathListDisplayInternal.h

@@ -142,9 +142,11 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (instancetype)init NS_UNAVAILABLE;
 
-// `start` is in table-local coordinates. For a horizontal rule `length` extends
-// rightward (+x); for a vertical rule it extends upward (+y). Stroke is centred on
-// the path, so callers offset `start` by thickness/2 where edge alignment matters.
+// `start` is a point on the stroke's centre-line, in table-local coordinates. For a
+// horizontal rule `length` extends rightward (+x); for a vertical rule it extends upward
+// (+y). The stroke straddles the centre-line by thickness/2, so the initializer records
+// `position` as the box's lower-left origin (inset by thickness/2 on the thickness axis);
+// callers pass the raw centre-line and must not pre-offset for edge alignment.
 - (instancetype) initWithStart:(CGPoint) start
                         length:(CGFloat) length
                      thickness:(CGFloat) thickness

iosMath/render/internal/MTTypesetter.m

@@ -2343,8 +2343,12 @@ - (MTDisplay*) makeTable:(MTMathTable*) table
 
 // Compute per-column start x-offsets shared by cells and vertical rules, so they cannot
 // drift. For each vertical boundary i (0..numColumns) with verticalLines[i] > 0, widen the
-// gap by 2·padding + the rule block and record each rule's centre x in vRuleXs[i]. With no
-// rules this reduces to -makeRowWithColumns:'s exact running sum (matrix path unchanged).
+// gap by the rule block plus padding and record each rule's centre x in vRuleXs[i]. Interior
+// boundaries get padding on both sides; the outer boundaries (i==0, i==numColumns) get padding
+// only on the inside so the outermost rules sit flush at x==0 / x==contentWidth — the same box
+// edges the horizontal rules span, so corners meet instead of the h-rules overhanging (LaTeX
+// behaviour). With no rules this reduces to -makeRowWithColumns:'s exact running sum (matrix
+// path unchanged).
 - (NSArray<NSNumber*>*) columnOffsetsForTable:(MTMathTable*) table
                                  columnWidths:(CGFloat[]) columnWidths
                                     thickness:(CGFloat) thickness
@@ -2364,13 +2368,16 @@ - (MTDisplay*) makeTable:(MTMathTable*) table
         NSInteger count = (i < vLines.count) ? vLines[i].integerValue : 0;
         NSMutableArray<NSNumber*>* xs = [NSMutableArray array];
         if (count > 0) {
-            CGFloat ruleAreaStart = x + padding + base / 2;
+            // No padding outside the outermost rules so they sit flush at the box edges.
+            CGFloat padLeft = (i == 0) ? 0 : padding;
+            CGFloat padRight = (i == numColumns) ? 0 : padding;
+            CGFloat ruleAreaStart = x + padLeft + base / 2;
             for (NSInteger k = 0; k < count; k++) {
                 CGFloat cx = ruleAreaStart + k * (thickness + ruleGap) + thickness / 2;
                 [xs addObject:@(cx)];
             }
             CGFloat ruleBlock = count * thickness + (count - 1) * ruleGap;
-            x += base + 2 * padding + ruleBlock;
+            x += base + padLeft + padRight + ruleBlock;
         } else {
             x += base;
         }

iosMathTests/MTTypesetterTest.m

@@ -3441,26 +3441,28 @@ - (void) testAlignedatLayout
 
 - (void)testRuleDisplayHorizontalAndVerticalMetrics
 {
+    // `start` is a point on the stroke's centre-line. The box straddles it by thickness/2
+    // on the thickness axis, so position (the box origin) is inset by thickness/2 there.
     MTRuleDisplay* h = [[MTRuleDisplay alloc] initWithStart:CGPointMake(2, 5)
                                                      length:10
                                                   thickness:0.6
                                                    vertical:NO
                                                       range:NSMakeRange(0, 1)];
-    XCTAssertEqual(h.position.x, 2);
-    XCTAssertEqual(h.position.y, 5);
+    XCTAssertEqual(h.position.x, 2);          // length axis: start unchanged
+    XCTAssertEqual(h.position.y, 5 - 0.3);    // thickness axis: centre-line 5 → box bottom 4.7
     XCTAssertEqual(h.width, 10);
-    XCTAssertEqual(h.ascent, 0.6);
+    XCTAssertEqual(h.ascent, 0.6);            // box spans y ∈ [4.7, 5.3], centred on 5
     XCTAssertEqual(h.descent, 0);
 
     MTRuleDisplay* v = [[MTRuleDisplay alloc] initWithStart:CGPointMake(3, -4)
                                                      length:12
                                                   thickness:0.6
                                                    vertical:YES
                                                       range:NSMakeRange(0, 1)];
-    XCTAssertEqual(v.position.x, 3);
-    XCTAssertEqual(v.position.y, -4);
-    XCTAssertEqual(v.width, 0.6);
-    XCTAssertEqual(v.ascent, 12);   // top end = position.y + ascent
+    XCTAssertEqual(v.position.x, 3 - 0.3);    // thickness axis: centre-line 3 → box left 2.7
+    XCTAssertEqual(v.position.y, -4);         // length axis: start unchanged
+    XCTAssertEqual(v.width, 0.6);             // box spans x ∈ [2.7, 3.3], centred on 3
+    XCTAssertEqual(v.ascent, 12);             // top end = position.y + ascent
     XCTAssertEqual(v.descent, 0);
 }
 
@@ -3568,20 +3570,41 @@ - (void)testArrayRuleGeometryIsDeterministic
     XCTAssertEqual(verticals.count, 2u);
     XCTAssertEqual(horizontals.count, 2u);
 
-    // Leftmost vertical (boundary 0, base 0): x == padding + thickness/2 (edge-centred stroke).
-    CGFloat leftmostX = CGFLOAT_MAX;
-    for (MTRuleDisplay* v in verticals) { leftmostX = MIN(leftmostX, v.position.x); }
-    XCTAssertEqualWithAccuracy(leftmostX, padding + thickness / 2, 0.01);
+    // A rule's box is [position.x, position.x+width] x [position.y, position.y+ascent] and
+    // exactly covers the drawn stroke (position is the box origin, stroke straddles the
+    // centre-line). Outer vertical rules sit flush with the box edges: no padding *outside*
+    // the outer rules, so the leftmost box-left is at x=0 and the rightmost box-right is at
+    // the content edge. Padding lives only *inside*, between rule and content.
+    CGFloat vLeft = CGFLOAT_MAX;
+    CGFloat vRight = -CGFLOAT_MAX;
+    for (MTRuleDisplay* v in verticals) {
+        vLeft = MIN(vLeft, v.position.x);
+        vRight = MAX(vRight, v.position.x + v.width);
+    }
+    XCTAssertEqualWithAccuracy(vLeft, 0, 0.01);
+    // The table's reported width matches the true content edge — no phantom half-thickness
+    // of trailing space (the vertical-rule box straddles its centre-line, so position.x+width
+    // is the real right edge, not centre+thickness).
+    XCTAssertEqualWithAccuracy(vRight, tableDisp.width, 0.01);
+
+    // Corners meet flush: each horizontal rule spans exactly the box edges [0, width], so its
+    // ends coincide with the outer verticals rather than overhanging them (the overhang bug).
+    for (MTRuleDisplay* h in horizontals) {
+        XCTAssertEqualWithAccuracy(h.position.x, vLeft, 0.01);
+        XCTAssertEqualWithAccuracy(h.position.x + h.width, vRight, 0.01);
+    }
 
-    // Top \hline sits padding above the content top; bottom \hline padding below content bottom.
-    CGFloat topY = -CGFLOAT_MAX;
-    CGFloat botY = CGFLOAT_MAX;
+    // Top \hline sits padding above the content top; bottom \hline padding below content
+    // bottom. The stroke centre-line is position.y + thickness/2 (box straddles the line).
+    CGFloat topLine = -CGFLOAT_MAX;
+    CGFloat botLine = CGFLOAT_MAX;
     for (MTRuleDisplay* h in horizontals) {
-        topY = MAX(topY, h.position.y);
-        botY = MIN(botY, h.position.y);
+        CGFloat line = h.position.y + thickness / 2;
+        topLine = MAX(topLine, line);
+        botLine = MIN(botLine, line);
     }
-    XCTAssertEqualWithAccuracy(topY, contentTop + padding, 0.01);
-    XCTAssertEqualWithAccuracy(botY, contentBot - padding, 0.01);
+    XCTAssertEqualWithAccuracy(topLine, contentTop + padding, 0.01);
+    XCTAssertEqualWithAccuracy(botLine, contentBot - padding, 0.01);
 }
 
 @end