< Summary

Information
Class: RoleRadar.Domain.Notes.MarkdownSectionParser
Assembly: RoleRadar.Domain
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Domain/Notes/MarkdownSectionParser.cs
Line coverage
91%
Covered lines: 196
Uncovered lines: 19
Coverable lines: 215
Total lines: 447
Line coverage: 91.1%
Branch coverage
82%
Covered branches: 121
Total branches: 146
Branch coverage: 82.8%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
ReplaceSection(...)75%9876.19%
ParseHeadings(...)94.44%363698.33%
FindMatchingHeadings(...)100%66100%
HeadingPathMatches(...)80%111078.57%
NormalizeMarkerHeading(...)66.66%66100%
StripLeadingHashes(...)75%44100%
BuildReplacementSectionText(...)75%88100%
StartsWithSameHeading(...)80%1010100%
DetectDominantLineEnding(...)83.33%6683.33%
TryUpdateFenceState(...)88.46%262696%
TryParseAtxHeading(...)69.23%292684.21%

File(s)

/home/runner/work/roleradar/roleradar/src/RoleRadar.Domain/Notes/MarkdownSectionParser.cs

#LineLine coverage
 1using System.Text;
 2
 3namespace RoleRadar.Domain.Notes;
 4
 5public enum SectionReplacementStatus
 6{
 7    Success,
 8    SectionNotFound,
 9    AmbiguousHeading
 10}
 11
 12public sealed record SectionReplacementOutcome(
 13    SectionReplacementStatus Status,
 14    string? UpdatedBody,
 15    IReadOnlyList<string> AvailableHeadings,
 16    IReadOnlyList<string> MatchingHeadings);
 17
 18public sealed record ParsedMarkdownHeading(
 19    int Level,
 20    string RawHeadingLine,
 21    string TitleText,
 22    string NormalizedMarkerTitle,
 23    string HeadingPath,
 24    int StartCharIndex,
 25    int HeadingLineEndCharIndex,
 26    int SectionEndCharIndex,
 27    string LineEnding);
 28
 29public static class MarkdownSectionParser
 30{
 31    public static SectionReplacementOutcome ReplaceSection(
 32        string originalBody,
 33        string targetHeading,
 34        string newSectionBody)
 35    {
 2236        ArgumentNullException.ThrowIfNull(originalBody);
 2237        ArgumentNullException.ThrowIfNull(newSectionBody);
 38
 2239        if (string.IsNullOrWhiteSpace(targetHeading))
 40        {
 041            return new SectionReplacementOutcome(
 042                SectionReplacementStatus.SectionNotFound,
 043                null,
 044                [],
 045                []);
 46        }
 47
 2248        var headings = ParseHeadings(originalBody);
 9249        var availablePaths = headings.Select(h => h.HeadingPath).ToArray();
 50
 2251        if (headings.Count == 0)
 52        {
 053            return new SectionReplacementOutcome(
 054                SectionReplacementStatus.SectionNotFound,
 055                null,
 056                availablePaths,
 057                []);
 58        }
 59
 2260        var trimmedTarget = targetHeading.Trim();
 2261        var matches = FindMatchingHeadings(headings, trimmedTarget);
 62
 2263        if (matches.Count == 0)
 64        {
 465            return new SectionReplacementOutcome(
 466                SectionReplacementStatus.SectionNotFound,
 467                null,
 468                availablePaths,
 469                []);
 70        }
 71
 1872        if (matches.Count > 1)
 73        {
 274            return new SectionReplacementOutcome(
 275                SectionReplacementStatus.AmbiguousHeading,
 276                null,
 277                availablePaths,
 678                matches.Select(m => m.HeadingPath).ToArray());
 79        }
 80
 1681        var target = matches[0];
 1682        var dominantNewline = DetectDominantLineEnding(originalBody, target.LineEnding);
 1683        var formattedReplacement = BuildReplacementSectionText(target, newSectionBody, dominantNewline);
 84
 1685        var sb = new StringBuilder(originalBody.Length + formattedReplacement.Length);
 1686        sb.Append(originalBody.AsSpan(0, target.StartCharIndex));
 1687        sb.Append(formattedReplacement);
 1688        sb.Append(originalBody.AsSpan(target.SectionEndCharIndex));
 89
 1690        return new SectionReplacementOutcome(
 1691            SectionReplacementStatus.Success,
 1692            sb.ToString(),
 1693            availablePaths,
 1694            [target.HeadingPath]);
 95    }
 96
 97    public static IReadOnlyList<ParsedMarkdownHeading> ParseHeadings(string markdown)
 98    {
 2299        ArgumentNullException.ThrowIfNull(markdown);
 100
 22101        var rawHeadings = new List<(int Level, string RawLine, string TitleText, int StartIdx, int LineEndIdx, string Li
 22102        var inFence = false;
 22103        var fenceChar = '\0';
 22104        var fenceLen = 0;
 105
 22106        var pos = 0;
 22107        var len = markdown.Length;
 108
 2028109        while (pos < len)
 110        {
 2006111            var lineStart = pos;
 17016980112            while (pos < len && markdown[pos] != '\r' && markdown[pos] != '\n')
 113            {
 17014974114                pos++;
 115            }
 116
 2006117            var contentEnd = pos;
 2006118            var lineEnding = "\n";
 2006119            if (pos < len)
 120            {
 2004121                if (markdown[pos] == '\r' && pos + 1 < len && markdown[pos + 1] == '\n')
 122                {
 1906123                    lineEnding = "\r\n";
 1906124                    pos += 2;
 125                }
 126                else
 127                {
 98128                    lineEnding = markdown[pos].ToString();
 98129                    pos += 1;
 130                }
 131            }
 132
 2006133            var lineSpan = markdown.AsSpan(lineStart, contentEnd - lineStart);
 2006134            if (TryUpdateFenceState(lineSpan, ref inFence, ref fenceChar, ref fenceLen))
 135            {
 136                continue;
 137            }
 138
 2002139            if (inFence)
 140            {
 141                continue;
 142            }
 143
 1998144            if (TryParseAtxHeading(lineSpan, out var level, out var titleText))
 145            {
 70146                rawHeadings.Add((
 70147                    Level: level,
 70148                    RawLine: lineSpan.ToString(),
 70149                    TitleText: titleText,
 70150                    StartIdx: lineStart,
 70151                    LineEndIdx: pos,
 70152                    LineEnding: lineEnding));
 153            }
 154        }
 155
 22156        if (rawHeadings.Count == 0)
 157        {
 0158            return [];
 159        }
 160
 22161        var result = new List<ParsedMarkdownHeading>(rawHeadings.Count);
 22162        var ancestorStack = new List<(int Level, string NormalizedMarkerTitle)>();
 163
 184164        for (var i = 0; i < rawHeadings.Count; i++)
 165        {
 70166            var current = rawHeadings[i];
 70167            var hashes = new string('#', current.Level);
 70168            var normalizedMarkerTitle = string.IsNullOrEmpty(current.TitleText)
 70169                ? hashes
 70170                : $"{hashes} {current.TitleText}";
 171
 96172            while (ancestorStack.Count > 0 && ancestorStack[^1].Level >= current.Level)
 173            {
 26174                ancestorStack.RemoveAt(ancestorStack.Count - 1);
 175            }
 176
 70177            ancestorStack.Add((current.Level, normalizedMarkerTitle));
 186178            var headingPath = string.Join(" / ", ancestorStack.Select(a => a.NormalizedMarkerTitle));
 179
 70180            var sectionEndIdx = len;
 232181            for (var j = i + 1; j < rawHeadings.Count; j++)
 182            {
 72183                if (rawHeadings[j].Level <= current.Level)
 184                {
 26185                    sectionEndIdx = rawHeadings[j].StartIdx;
 26186                    break;
 187                }
 188            }
 189
 70190            result.Add(new ParsedMarkdownHeading(
 70191                Level: current.Level,
 70192                RawHeadingLine: current.RawLine,
 70193                TitleText: current.TitleText,
 70194                NormalizedMarkerTitle: normalizedMarkerTitle,
 70195                HeadingPath: headingPath,
 70196                StartCharIndex: current.StartIdx,
 70197                HeadingLineEndCharIndex: current.LineEndIdx,
 70198                SectionEndCharIndex: sectionEndIdx,
 70199                LineEnding: current.LineEnding));
 200        }
 201
 22202        return result;
 203    }
 204
 205    private static List<ParsedMarkdownHeading> FindMatchingHeadings(
 206        IReadOnlyList<ParsedMarkdownHeading> headings,
 207        string targetHeading)
 208    {
 22209        if (targetHeading.Contains('/', StringComparison.Ordinal))
 210        {
 2211            var normalizedSegments = targetHeading
 2212                .Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
 213
 2214            return headings
 8215                .Where(h => HeadingPathMatches(h.HeadingPath, normalizedSegments))
 2216                .ToList();
 217        }
 218
 20219        var strippedTarget = StripLeadingHashes(targetHeading);
 20220        var hasExplicitHashes = targetHeading.StartsWith('#');
 221
 20222        return headings
 20223            .Where(h =>
 20224            {
 62225                if (hasExplicitHashes)
 20226                {
 6227                    return string.Equals(h.NormalizedMarkerTitle, NormalizeMarkerHeading(targetHeading), StringCompariso
 20228                }
 20229
 56230                return string.Equals(h.TitleText, strippedTarget, StringComparison.OrdinalIgnoreCase) ||
 56231                       string.Equals(h.NormalizedMarkerTitle, targetHeading, StringComparison.OrdinalIgnoreCase);
 20232            })
 20233            .ToList();
 234    }
 235
 236    private static bool HeadingPathMatches(string headingPath, string[] querySegments)
 237    {
 8238        var pathSegments = headingPath.Split(" / ", StringSplitOptions.None);
 8239        if (querySegments.Length > pathSegments.Length)
 240        {
 4241            return false;
 242        }
 243
 4244        var offset = pathSegments.Length - querySegments.Length;
 16245        for (var i = 0; i < querySegments.Length; i++)
 246        {
 6247            var candidate = pathSegments[offset + i];
 6248            var querySeg = querySegments[i];
 6249            if (querySeg.StartsWith('#'))
 250            {
 6251                if (!string.Equals(candidate, NormalizeMarkerHeading(querySeg), StringComparison.OrdinalIgnoreCase))
 252                {
 2253                    return false;
 254                }
 255            }
 256            else
 257            {
 0258                var candidateStripped = StripLeadingHashes(candidate);
 0259                if (!string.Equals(candidateStripped, querySeg, StringComparison.OrdinalIgnoreCase))
 260                {
 0261                    return false;
 262                }
 263            }
 264        }
 265
 2266        return true;
 267    }
 268
 269    private static string NormalizeMarkerHeading(string input)
 270    {
 12271        var trimmed = input.Trim();
 12272        var i = 0;
 32273        while (i < trimmed.Length && trimmed[i] == '#')
 274        {
 20275            i++;
 276        }
 277
 12278        var hashes = trimmed[..i];
 12279        var rest = trimmed[i..].Trim();
 12280        return string.IsNullOrEmpty(rest) ? hashes : $"{hashes} {rest}";
 281    }
 282
 283    private static string StripLeadingHashes(string input)
 284    {
 20285        var trimmed = input.Trim();
 20286        var i = 0;
 24287        while (i < trimmed.Length && trimmed[i] == '#')
 288        {
 4289            i++;
 290        }
 291
 20292        return trimmed[i..].Trim();
 293    }
 294
 295    private static string BuildReplacementSectionText(
 296        ParsedMarkdownHeading target,
 297        string newSectionBody,
 298        string newline)
 299    {
 16300        var startsWithHeading = StartsWithSameHeading(newSectionBody, target);
 16301        var builder = new StringBuilder(newSectionBody.Length + target.RawHeadingLine.Length + 4);
 302
 16303        if (!startsWithHeading)
 304        {
 2305            builder.Append(target.RawHeadingLine).Append(newline);
 306        }
 307
 16308        builder.Append(newSectionBody);
 16309        if (builder.Length > 0 && builder[^1] != '\n' && builder[^1] != '\r')
 310        {
 2311            builder.Append(newline);
 312        }
 313
 16314        return builder.ToString();
 315    }
 316
 317    private static bool StartsWithSameHeading(string newSectionBody, ParsedMarkdownHeading target)
 318    {
 16319        var span = newSectionBody.AsSpan().TrimStart();
 16320        var lineEnd = 0;
 258321        while (lineEnd < span.Length && span[lineEnd] != '\r' && span[lineEnd] != '\n')
 322        {
 242323            lineEnd++;
 324        }
 325
 16326        var firstLine = span[..lineEnd];
 16327        if (!TryParseAtxHeading(firstLine, out var level, out var titleText))
 328        {
 2329            return false;
 330        }
 331
 14332        return level == target.Level &&
 14333               string.Equals(titleText, target.TitleText, StringComparison.OrdinalIgnoreCase);
 334    }
 335
 336    private static string DetectDominantLineEnding(string body, string fallback)
 337    {
 16338        var idx = body.IndexOf('\n');
 16339        if (idx > 0 && body[idx - 1] == '\r')
 340        {
 4341            return "\r\n";
 342        }
 343
 12344        if (idx >= 0)
 345        {
 12346            return "\n";
 347        }
 348
 0349        return fallback;
 350    }
 351
 352    public static bool TryUpdateFenceState(
 353        ReadOnlySpan<char> lineSpan,
 354        ref bool inFence,
 355        ref char fenceChar,
 356        ref int fenceLen)
 357    {
 14976358        var leadingSpaces = 0;
 15176359        while (leadingSpaces < lineSpan.Length && leadingSpaces < 3 && lineSpan[leadingSpaces] == ' ')
 360        {
 200361            leadingSpaces++;
 362        }
 363
 14976364        var trimmed = lineSpan[leadingSpaces..];
 14976365        if (trimmed.Length < 3)
 366        {
 4232367            return false;
 368        }
 369
 10744370        var first = trimmed[0];
 10744371        if (first != '`' && first != '~')
 372        {
 10148373            return false;
 374        }
 375
 596376        var run = 0;
 1520377        while (run < trimmed.Length && trimmed[run] == first)
 378        {
 924379            run++;
 380        }
 381
 596382        if (run < 3)
 383        {
 576384            return false;
 385        }
 386
 20387        if (!inFence)
 388        {
 10389            inFence = true;
 10390            fenceChar = first;
 10391            fenceLen = run;
 10392            return true;
 393        }
 394
 10395        if (first == fenceChar && run >= fenceLen && trimmed[run..].Trim().IsEmpty)
 396        {
 10397            inFence = false;
 10398            fenceChar = '\0';
 10399            fenceLen = 0;
 10400            return true;
 401        }
 402
 0403        return false;
 404    }
 405
 406    public static bool TryParseAtxHeading(
 407        ReadOnlySpan<char> lineSpan,
 408        out int level,
 409        out string titleText)
 410    {
 2014411        level = 0;
 2014412        titleText = string.Empty;
 413
 2014414        var leadingSpaces = 0;
 2014415        while (leadingSpaces < lineSpan.Length && leadingSpaces < 3 && lineSpan[leadingSpaces] == ' ')
 416        {
 0417            leadingSpaces++;
 418        }
 419
 2014420        var span = lineSpan[leadingSpaces..];
 2014421        if (span.IsEmpty || span[0] != '#')
 422        {
 1930423            return false;
 424        }
 425
 84426        var hashes = 0;
 228427        while (hashes < span.Length && span[hashes] == '#')
 428        {
 144429            hashes++;
 430        }
 431
 84432        if (hashes is < 1 or > 6)
 433        {
 0434            return false;
 435        }
 436
 84437        var rest = span[hashes..];
 84438        if (!rest.IsEmpty && rest[0] != ' ' && rest[0] != '\t')
 439        {
 0440            return false;
 441        }
 442
 84443        level = hashes;
 84444        titleText = rest.Trim().ToString();
 84445        return true;
 446    }
 447}