.

Author: SimonCropp

src/Verify.Tests/Serialization/CrossChunkMatcherTests.MultipleMatchesAcrossChunks.verified.txt

@@ -0,0 +1,3 @@
+{
+  MatchCount: 2
+}

src/Verify.Tests/Serialization/CrossChunkMatcherTests.PatternSpanningFourChunks.verified.txt

@@ -0,0 +1,5 @@
+{
+  MatchFound: true,
+  OriginalPatternExists: false,
+  Note: Pattern spanning 4 chunks should now be detected
+}

src/Verify.Tests/Serialization/CrossChunkMatcherTests.PatternSpanningThreeChunks.verified.txt

@@ -0,0 +1,5 @@
+{
+  MatchFound: true,
+  OriginalPatternExists: false,
+  Note: Pattern spanning 3 chunks should now be detected
+}

src/Verify.Tests/Serialization/CrossChunkMatcherTests.PatternSpanningThreeChunks_AlternativeLayout.verified.txt

@@ -0,0 +1,5 @@
+{
+  MatchFound: true,
+  OriginalPatternExists: false,
+  Note: Pattern spanning 3 chunks should now be detected
+}

src/Verify.Tests/Serialization/CrossChunkMatcherTests.VariableLengthMatches.verified.txt

@@ -0,0 +1 @@
+animal animal animal animal

src/Verify.Tests/Serialization/CrossChunkMatcherTests.cs

@@ -7,101 +7,146 @@ static class CrossChunkMatcher
     /// Finds all matches in a StringBuilder (handling patterns spanning chunk boundaries) and applies replacements.
     /// </summary>
     /// <param name="builder">The StringBuilder to search and modify</param>
+    /// <param name="maxLength">Maximum pattern length to search for</param>
     /// <param name="context">User context passed to callbacks</param>
-    /// <param name="onCrossChunk">Called for each potential cross-chunk match position</param>
-    /// <param name="onWithinChunk">Called for each position within a chunk</param>
+    /// <param name="matcher">Called for each potential match position with accumulated buffer</param>
     public static void ReplaceAll<TContext>(
         StringBuilder builder,
         int maxLength,
         TContext context,
-        CrossChunkHandler<TContext> onCrossChunk,
-        WithinChunkHandler<TContext> onWithinChunk)
+        MatchHandler<TContext> matcher)
     {
+        if (maxLength <= 0)
+        {
+            throw new ArgumentException("maxLength must be positive", nameof(maxLength));
+        }
+
         Span<char> buffer = stackalloc char[maxLength];
-        Span<char> carryoverBuffer = stackalloc char[maxLength - 1];
-        var carryoverLength = 0;
-        var previousChunkAbsoluteEnd = 0;
-        var absolutePosition = 0;
         List<Match> matches = [];
-        var addMatch = matches.Add;
+        var position = 0;
+
         foreach (var chunk in builder.GetChunks())
         {
-            var chunkSpan = chunk.Span;
-
-            // Check for matches spanning from previous chunk to current chunk
-            if (carryoverLength > 0)
+            for (var chunkIndex = 0; chunkIndex < chunk.Length; chunkIndex++)
             {
-                for (var carryoverIndex = 0; carryoverIndex < carryoverLength; carryoverIndex++)
+                var absolutePosition = position + chunkIndex;
+
+                // Build content window starting at current position
+                var bufferLength = FillBuffer(builder, absolutePosition, buffer);
+
+                // Check for match at this position
+                var windowSlice = buffer[..bufferLength];
+                var result = matcher(windowSlice, absolutePosition, context);
+
+                if (result.IsMatch)
                 {
-                    var remainingInCarryover = carryoverLength - carryoverIndex;
-                    var startPosition = previousChunkAbsoluteEnd - carryoverLength + carryoverIndex;
-
-                    onCrossChunk(
-                        builder,
-                        carryoverBuffer,
-                        buffer,
-                        carryoverIndex,
-                        remainingInCarryover,
-                        chunkSpan,
-                        startPosition,
-                        context,
-                        addMatch);
+                    matches.Add(new Match(absolutePosition, result.MatchLength, result.Replacement));
+
+                    // Skip past the match
+                    var skipAmount = result.MatchLength - 1;
+                    if (skipAmount > 0)
+                    {
+                        var remaining = chunk.Length - chunkIndex - 1;
+                        var toSkip = Math.Min(skipAmount, remaining);
+                        chunkIndex += toSkip;
+                    }
                 }
             }
 
-            // Process matches entirely within this chunk
-            var chunkIndex = 0;
-            while (chunkIndex < chunk.Length)
+            position += chunk.Length;
+        }
+
+        // Apply matches in descending position order to maintain correct indices
+        foreach (var match in matches.OrderByDescending(m => m.Index))
+        {
+            builder.Overwrite(match.Value, match.Index, match.Length);
+        }
+    }
+
+    static int FillBuffer(StringBuilder builder, int startPosition, Span<char> buffer)
+    {
+        var bufferIndex = 0;
+        var currentPosition = 0;
+
+        foreach (var chunk in builder.GetChunks())
+        {
+            var chunkSpan = chunk.Span;
+            var chunkEnd = currentPosition + chunk.Length;
+
+            // Skip chunks before our start position
+            if (chunkEnd <= startPosition)
             {
-                var absoluteIndex = absolutePosition + chunkIndex;
-                var skipAhead = onWithinChunk(chunk, chunkSpan, chunkIndex, absoluteIndex, context, addMatch);
-                chunkIndex += skipAhead > 0 ? skipAhead : 1;
+                currentPosition = chunkEnd;
+                continue;
             }
 
-            // Save last N chars for next iteration
-            carryoverLength = Math.Min(maxLength - 1, chunk.Length);
-            chunkSpan.Slice(chunk.Length - carryoverLength, carryoverLength).CopyTo(carryoverBuffer);
+            // Determine where to start in this chunk
+            var chunkStartIndex = startPosition > currentPosition ? startPosition - currentPosition : 0;
 
-            previousChunkAbsoluteEnd = absolutePosition + chunk.Length;
-            absolutePosition += chunk.Length;
-        }
+            // Copy what we can from this chunk
+            for (var i = chunkStartIndex; i < chunk.Length && bufferIndex < buffer.Length; i++)
+            {
+                buffer[bufferIndex++] = chunkSpan[i];
+            }
 
-        // Apply matches in descending position order
-        foreach (var match in matches.OrderByDescending(_ => _.Index))
-        {
-            builder.Overwrite(match.Value, match.Index, match.Length);
+            // If buffer is full, we're done
+            if (bufferIndex >= buffer.Length)
+            {
+                break;
+            }
+
+            currentPosition = chunkEnd;
         }
+
+        return bufferIndex;
     }
 
     /// <summary>
-    /// Callback for processing potential cross-chunk matches.
+    /// Callback for checking if content matches and should be replaced.
     /// </summary>
-    public delegate void CrossChunkHandler<in TContext>(
-        StringBuilder builder,
-        Span<char> carryoverBuffer,
-        Span<char> buffer,
-        int carryoverIndex,
-        int remainingInCarryover,
-        CharSpan currentChunkSpan,
-        int absoluteStartPosition,
-        TContext context,
-        Action<Match> addMatch);
+    /// <param name="content">The current window content to check</param>
+    /// <param name="absolutePosition">Absolute position in the StringBuilder where this content starts</param>
+    /// <param name="context">User-provided context</param>
+    /// <returns>Match result indicating if a match was found and replacement details</returns>
+    public delegate MatchResult MatchHandler<in TContext>(
+        CharSpan content,
+        int absolutePosition,
+        TContext context);
+}
+
+/// <summary>
+/// Result of a match check operation.
+/// </summary>
+readonly struct MatchResult
+{
+    public readonly bool IsMatch;
+    public readonly int MatchLength;
+    public readonly string Replacement;
+
+    private MatchResult(bool isMatch, int matchLength, string replacement)
+    {
+        IsMatch = isMatch;
+        MatchLength = matchLength;
+        Replacement = replacement;
+    }
 
     /// <summary>
-    /// Callback for processing positions within a chunk.
+    /// Creates a result indicating a match was found.
     /// </summary>
-    /// <returns>
-    /// Number of positions to skip ahead.
-    /// Returning 0 or 1 will both advance by 1 position (normal iteration);
-    /// returning a value greater than 1 will skip past a match.
-    /// </returns>
-    public delegate int WithinChunkHandler<in TContext>(
-        ReadOnlyMemory<char> chunk,
-        CharSpan chunkSpan,
-        int chunkIndex,
-        int absoluteIndex,
-        TContext context,
-        Action<Match> addMatch);
+    public static MatchResult Match(int length, string replacement)
+    {
+        if (length <= 0)
+        {
+            throw new ArgumentException("Match length must be positive", nameof(length));
+        }
+
+        return new MatchResult(true, length, replacement);
+    }
+
+    /// <summary>
+    /// Creates a result indicating no match was found.
+    /// </summary>
+    public static MatchResult NoMatch() => default;
 }
 
 readonly struct Match(int index, int length, string value)

src/Verify/Serialization/Scrubbers/CrossChunkMatcher.cs

@@ -212,75 +212,27 @@ static void ReplaceInner(StringBuilder builder, string format, Counter counter,
             builder,
             maxLength: max,
             context,
-            OnCrossChunk,
-            OnWithinChunk);
-    }
-
-    static void OnCrossChunk(
-        StringBuilder builder,
-        Span<char> carryoverBuffer,
-        Span<char> buffer,
-        int carryoverIndex,
-        int remainingInCarryover,
-        CharSpan currentChunkSpan,
-        int absoluteStartPosition,
-        MatchContext context,
-        Action<Match> addMatch)
-    {
-        // Try lengths from longest to shortest (greedy matching)
-        for (var length = context.MaxLength; length >= context.MinLength; length--)
-        {
-            var neededFromCurrent = length - remainingInCarryover;
-
-            if (neededFromCurrent <= 0 ||
-                neededFromCurrent > currentChunkSpan.Length)
+            matcher: static (content, _, context) =>
             {
-                continue;
-            }
-
-            // Combine carryover and current chunk
-            carryoverBuffer.Slice(carryoverIndex, remainingInCarryover).CopyTo(buffer);
-            currentChunkSpan[..neededFromCurrent].CopyTo(buffer[remainingInCarryover..]);
-
-            var slice = buffer[..length];
-
-            if (!context.TryConvert(slice, context.Format, context.Counter, context.Culture, out var convert))
-            {
-                continue;
-            }
-
-            addMatch(new(absoluteStartPosition, length, convert));
-            // Found match at this position
-            return;
-        }
-    }
-
-    static int OnWithinChunk(
-        ReadOnlyMemory<char> chunk,
-        CharSpan chunkSpan,
-        int chunkIndex,
-        int absoluteIndex,
-        MatchContext context,
-        Action<Match> addMatch)
-    {
-        // Try lengths from longest to shortest (greedy matching)
-        for (var length = context.MaxLength; length >= context.MinLength; length--)
-        {
-            if (chunkIndex + length > chunk.Length)
-            {
-                continue;
-            }
-
-            var slice = chunkSpan.Slice(chunkIndex, length);
-
-            if (context.TryConvert(slice, context.Format, context.Counter, context.Culture, out var convert))
-            {
-                addMatch(new(absoluteIndex, length, convert));
-                return length; // Skip past match
-            }
-        }
-
-        return 1;
+                // Try lengths from longest to shortest (greedy matching)
+                for (var length = context.MaxLength; length >= context.MinLength; length--)
+                {
+                    // Not enough content for this length
+                    if (content.Length < length)
+                    {
+                        continue;
+                    }
+
+                    var slice = content.Slice(0, length);
+
+                    if (context.TryConvert(slice, context.Format, context.Counter, context.Culture, out var converted))
+                    {
+                        return MatchResult.Match(length, converted);
+                    }
+                }
+
+                return MatchResult.NoMatch();
+            });
     }
 
     sealed class MatchContext(
@@ -298,4 +250,4 @@ sealed class MatchContext(
         public int MaxLength { get; } = maxLength;
         public int MinLength { get; } = minLength;
     }
-}
+}