rumdl 0.1.78

A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use criterion::{Criterion, criterion_group, criterion_main};
use rumdl_lib::utils::range_utils::LineIndex;
use std::hint::black_box;

// Naive implementation that doesn't use the optimized function
fn naive_line_col_to_byte_range(content: &str, line: usize, column: usize) -> std::ops::Range<usize> {
    let lines: Vec<&str> = content.lines().collect();

    // Handle out of bounds
    if line == 0 || line > lines.len() {
        return content.len()..content.len();
    }

    // Manually iterate through each line to find the byte position
    let mut current_pos = 0;
    for i in 0..(line - 1) {
        if i < lines.len() {
            current_pos += lines[i].len() + 1; // +1 for newline
        }
    }

    // Adjust column
    let current_line = lines[line - 1];
    let col = if column == 0 {
        1
    } else if column > current_line.len() + 1 {
        current_line.len() + 1
    } else {
        column
    };

    let start = current_pos + col - 1;
    let safe_start = std::cmp::min(start, content.len());

    safe_start..safe_start
}

fn generate_test_content(line_count: usize) -> String {
    (0..line_count)
        .map(|i| format!("Line {i}: This is a test line with some content."))
        .collect::<Vec<String>>()
        .join("\n")
}

fn bench_range_utils(c: &mut Criterion) {
    let line_count = 10_000;
    let content = generate_test_content(line_count);

    // New cached implementation
    let line_index = LineIndex::new(&content);
    c.bench_function("cached_line_col_to_byte_range", |b| {
        b.iter(|| {
            for line in [1, 100, 1000, 5000, 9999].iter() {
                for col in [1, 10, 20, 40].iter() {
                    black_box(line_index.line_col_to_byte_range(*line, *col));
                }
            }
        })
    });

    // Benchmark the naive implementation
    c.bench_function("naive_line_col_to_byte_range", |b| {
        b.iter(|| {
            // Access the same positions
            for line in [1, 100, 1000, 5000, 9999].iter() {
                for col in [1, 10, 20, 40].iter() {
                    black_box(naive_line_col_to_byte_range(black_box(&content), *line, *col));
                }
            }
        })
    });

    // Benchmark scattered accesses with a deterministic pattern so runs are
    // reproducible (rand would give non-reproducible bench output).
    let scattered: Vec<(usize, usize)> = (0..20)
        .map(|i| {
            let line = 1 + (i * 499) % line_count; // 499 is coprime with line_count, good spread
            let col = 1 + (i * 7) % 40;
            (line, col)
        })
        .collect();

    c.bench_function("scattered_access_optimized", |b| {
        b.iter(|| {
            for (line, col) in &scattered {
                black_box(line_index.line_col_to_byte_range(*line, *col));
            }
        })
    });

    c.bench_function("scattered_access_naive", |b| {
        b.iter(|| {
            for (line, col) in &scattered {
                black_box(naive_line_col_to_byte_range(black_box(&content), *line, *col));
            }
        })
    });
}

criterion_group!(benches, bench_range_utils);
criterion_main!(benches);