Cross chunk matching

src/Verify/Serialization/Scrubbers/CrossChunkMatcher.cs

@@ -0,0 +1,109 @@
+/// <summary>
+/// Helper for matching and replacing patterns in StringBuilder that may span across chunk boundaries.
+/// </summary>
+static class CrossChunkMatcher
+{
+    /// <summary>
+    /// 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="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>
+    public static void ReplaceAll<TContext>(
+        StringBuilder builder,
+        int maxLength,
+        TContext context,
+        CrossChunkHandler<TContext> onCrossChunk,
+        WithinChunkHandler<TContext> onWithinChunk)
+    {
+        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;
+        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 carryoverIndex = 0; carryoverIndex < carryoverLength; carryoverIndex++)
+                {
+                    var remainingInCarryover = carryoverLength - carryoverIndex;
+                    var startPosition = previousChunkAbsoluteEnd - carryoverLength + carryoverIndex;
+
+                    onCrossChunk(
+                        builder,
+                        carryoverBuffer,
+                        buffer,
+                        carryoverIndex,
+                        remainingInCarryover,
+                        chunkSpan,
+                        startPosition,
+                        context,
+                        addMatch);
+                }
+            }
+
+            // Process matches entirely within this chunk
+            var chunkIndex = 0;
+            while (chunkIndex < chunk.Length)
+            {
+                var absoluteIndex = absolutePosition + chunkIndex;
+                var skipAhead = onWithinChunk(chunk, chunkSpan, chunkIndex, absoluteIndex, context, addMatch);
+                chunkIndex += skipAhead > 0 ? skipAhead : 1;
+            }
+
+            // Save last N chars for next iteration
+            carryoverLength = Math.Min(maxLength - 1, chunk.Length);
+            chunkSpan.Slice(chunk.Length - carryoverLength, carryoverLength).CopyTo(carryoverBuffer);
+
+            previousChunkAbsoluteEnd = absolutePosition + chunk.Length;
+            absolutePosition += chunk.Length;
+        }
+
+        // Apply matches in descending position order
+        foreach (var match in matches.OrderByDescending(_ => _.Index))
+        {
+            builder.Overwrite(match.Value, match.Index, match.Length);
+        }
+    }
+
+    /// <summary>
+    /// Callback for processing potential cross-chunk matches.
+    /// </summary>
+    public delegate void CrossChunkHandler<TContext>(
+        StringBuilder builder,
+        Span<char> carryoverBuffer,
+        Span<char> buffer,
+        int carryoverIndex,
+        int remainingInCarryover,
+        CharSpan currentChunkSpan,
+        int absoluteStartPosition,
+        TContext context,
+        Action<Match> addMatch);
+
+    /// <summary>
+    /// Callback for processing positions within a chunk.
+    /// </summary>
+    /// <returns>Number of positions to skip ahead (0 or 1 for normal iteration, more to skip past a match)</returns>
+    public delegate int WithinChunkHandler<TContext>(
+        ReadOnlyMemory<char> chunk,
+        CharSpan chunkSpan,
+        int chunkIndex,
+        int absoluteIndex,
+        TContext context,
+        Action<Match> addMatch);
+}
+
+
+readonly struct Match(int index, int length, string value)
+{
+    public readonly int Index = index;
+    public readonly int Length = length;
+    public readonly string Value = value;
+}

src/Verify/Serialization/Scrubbers/DateScrubber.cs

@@ -1,4 +1,4 @@
-// ReSharper disable ReturnValueOfPureMethodIsNotUsed
+// ReSharper disable ReturnValueOfPureMethodIsNotUsed
 static class DateScrubber
 {
     delegate bool TryConvert(
@@ -192,7 +192,7 @@ static bool TryGetFormatWithUpperMillisecondsTrimmed(string format, [NotNullWhen
         return false;
     }
 
-    static void ReplaceInner(StringBuilder builder, string format, Counter counter, Culture culture, TryConvert tryConvertDate)
+    static void ReplaceInner(StringBuilder builder, string format, Counter counter, Culture culture, TryConvert tryConvert)
     {
         if (!counter.ScrubDateTimes)
         {
@@ -206,69 +206,96 @@ static void ReplaceInner(StringBuilder builder, string format, Counter counter,
             return;
         }
 
-        if (min == max)
-        {
-            ReplaceFixedLength(builder, format, counter, culture, tryConvertDate, max);
-
-            return;
-        }
+        var context = new MatchContext(format, counter, culture, tryConvert, max, min);
 
-        ReplaceVariableLength(builder, format, counter, culture, tryConvertDate, max, min);
+        CrossChunkMatcher.ReplaceAll(
+            builder,
+            maxLength: max,
+            context,
+            OnCrossChunk,
+            OnWithinChunk);
     }
 
-    static void ReplaceVariableLength(StringBuilder builder, string format, Counter counter, Culture culture, TryConvert tryConvertDate, int longest, int shortest)
+    static void OnCrossChunk(
+        StringBuilder builder,
+        Span<char> carryoverBuffer,
+        Span<char> buffer,
+        int carryoverIndex,
+        int remainingInCarryover,
+        CharSpan currentChunkSpan,
+        int absoluteStartPosition,
+        MatchContext context,
+        Action<Match> addMatch)
     {
-        var value = builder.AsSpan();
-        var builderIndex = 0;
-        for (var index = 0; index <= value.Length; index++)
+        // Try lengths from longest to shortest (greedy matching)
+        for (var length = context.MaxLength; length >= context.MinLength; length--)
         {
-            var found = false;
-            for (var length = longest; length >= shortest; length--)
+            var neededFromCurrent = length - remainingInCarryover;
+
+            if (neededFromCurrent <= 0 ||
+                neededFromCurrent > currentChunkSpan.Length)
             {
-                var end = index + length;
-                if (end > value.Length)
-                {
-                    continue;
-                }
-
-                var slice = value.Slice(index, length);
-                if (tryConvertDate(slice, format, counter, culture, out var convert))
-                {
-                    builder.Overwrite(convert, builderIndex, length);
-                    builderIndex += convert.Length;
-                    index += length - 1;
-                    found = true;
-                    break;
-                }
+                continue;
             }
 
-            if (found)
+            // 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;
             }
 
-            builderIndex++;
+            addMatch(new(absoluteStartPosition, length, convert));
+            // Found match at this position
+            return;
         }
     }
 
-    static void ReplaceFixedLength(StringBuilder builder, string format, Counter counter, Culture culture, TryConvert tryConvertDate, int length)
+    static int OnWithinChunk(
+        ReadOnlyMemory<char> chunk,
+        CharSpan chunkSpan,
+        int chunkIndex,
+        int absoluteIndex,
+        MatchContext context,
+        Action<Match> addMatch)
     {
-        var value = builder.AsSpan();
-        var builderIndex = 0;
-        var increment = length - 1;
-        for (var index = 0; index <= value.Length - length; index++)
+        // Try lengths from longest to shortest (greedy matching)
+        for (var length = context.MaxLength; length >= context.MinLength; length--)
         {
-            var slice = value.Slice(index, length);
-            if (tryConvertDate(slice, format, counter, culture, out var convert))
+            if (chunkIndex + length > chunk.Length)
             {
-                builder.Overwrite(convert, builderIndex, length);
-                builderIndex += convert.Length;
-                index += increment;
+                continue;
             }
-            else
+
+            var slice = chunkSpan.Slice(chunkIndex, length);
+
+            if (context.TryConvert(slice, context.Format, context.Counter, context.Culture, out var convert))
             {
-                builderIndex++;
+                addMatch(new(absoluteIndex, length, convert));
+                return length; // Skip past match
             }
         }
+
+        return 1;
+    }
+
+    sealed class MatchContext(
+        string format,
+        Counter counter,
+        Culture culture,
+        TryConvert tryConvert,
+        int maxLength,
+        int minLength)
+    {
+        public string Format { get; } = format;
+        public Counter Counter { get; } = counter;
+        public Culture Culture { get; } = culture;
+        public TryConvert TryConvert { get; } = tryConvert;
+        public int MaxLength { get; } = maxLength;
+        public int MinLength { get; } = minLength;
     }
-}
+}