drep-ai 2.5.1

A local commit gate: runs the linters your repo configures, and sends changed code to an LLM for review
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

//! Tests for the markdown checks.
//!
//! Every file here must be declared below. Rust silently ignores a test file
//! no `mod` points at, and four such files once held 31 tests that never
//! compiled while the count looked right.

mod analyze;
mod blocks;
mod fence;
mod lines;
mod links;
mod vocabulary;

use std::path::Path;

use crate::analysis::findings::Finding;
use crate::docs::{Check, analyze};

/// Analyze `content` as `doc.md`.
fn run(content: &str) -> Vec<Finding> {
    analyze(Path::new("doc.md"), content)
}

/// Every finding of one kind, in the order `analyze` returned them.
fn of_kind(content: &str, check: Check) -> Vec<Finding> {
    run(content)
        .into_iter()
        .filter(|f| f.kind == check.as_str())
        .collect()
}

/// The `(line, column)` of every finding of one kind.
fn positions(content: &str, check: Check) -> Vec<(u32, u32)> {
    of_kind(content, check)
        .into_iter()
        .map(|f| {
            (
                f.line,
                f.column.expect("every doc finding carries a column"),
            )
        })
        .collect()
}

/// Assert that `check` fires exactly once, at `line`:`column`.
#[track_caller]
fn fires_once_at(content: &str, check: Check, line: u32, column: u32) {
    assert_eq!(
        positions(content, check),
        vec![(line, column)],
        "{} over {content:?}",
        check.as_str()
    );
}

/// Assert that `check` does not fire at all.
#[track_caller]
fn silent(content: &str, check: Check) {
    assert_eq!(
        positions(content, check),
        Vec::new(),
        "{} should not fire over {content:?}",
        check.as_str()
    );
}

/// A line of `n` `x`s - for the length-boundary tests.
fn wide(n: usize) -> String {
    "x".repeat(n)
}