alef 0.84.1

Opinionated polyglot binding generator for Rust libraries
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! `run_validation` must log a matching Starting/Finished pair for whichever codepath a
//! validator actually took -- batched or the per-snippet fallback -- never a silent one.

use super::*;
use crate::snippets::types::{SnippetMetadata, SourceOrigin};
use crate::snippets::validators::SnippetValidator;
use tracing_test::traced_test;

/// A validator that passes but declares a ceiling below `Run`, standing in for the real
/// zig/toml/json/yaml validators whose maximum level is genuinely lower than TypeCheck.
struct CappedValidator {
    language: crate::snippets::types::Language,
    ceiling: ValidationLevel,
}

impl SnippetValidator for CappedValidator {
    fn language(&self) -> crate::snippets::types::Language {
        self.language
    }

    fn is_available(&self) -> bool {
        true
    }

    fn validate(
        &self,
        _snippet: &Snippet,
        _level: ValidationLevel,
        _timeout_secs: u64,
    ) -> Result<(SnippetStatus, Option<String>)> {
        Ok((SnippetStatus::Pass, None))
    }

    fn max_level(&self) -> ValidationLevel {
        self.ceiling
    }
}

fn network_snippet() -> Snippet {
    Snippet {
        id: None,
        path: "example.md".into(),
        language: crate::snippets::types::Language::Rust,
        title: None,
        code: "fn main() {}".into(),
        start_line: 1,
        block_index: 0,
        annotation: None,
        metadata: SnippetMetadata {
            side_effect: Some(SideEffectClass::Network),
            ..SnippetMetadata::default()
        },
        source_origin: SourceOrigin {
            path: "example.md".into(),
            line: 1,
            block_index: 0,
        },
    }
}

/// A validator that doesn't support batching at all (every language but rust) must never log
/// `Starting batched snippet validation` — it never enters that codepath — and its work must
/// still be observable through the per-snippet fallback's own Starting/Finished pair. Before
/// `batch_level` checked `supports_batching`, every language was grouped and logged as a
/// batch regardless, then silently fell through to `validate_one` with no further trace at
/// all: a `Starting` with no matching `Finished`, and the *real* work invisible. ~keep
#[traced_test]
#[test]
fn non_batching_validator_skips_the_batch_log_and_uses_the_fallback_log() {
    let mut registry = ValidatorRegistry::new();
    registry.register(Box::new(CappedValidator {
        language: crate::snippets::types::Language::Rust,
        ceiling: ValidationLevel::Run,
    }));
    let config = RunnerConfig {
        level: ValidationLevel::Syntax,
        parallelism: 1,
        cache_dir: None,
        allowed_side_effects: vec![SideEffectClass::Network],
        ..RunnerConfig::default()
    };

    let summary =
        run_validation(&[network_snippet(), network_snippet()], &registry, &config).expect("validation completes");

    assert_eq!(summary.passed, 2);
    assert!(!logs_contain("Starting batched snippet validation"));
    assert!(logs_contain("Starting per-snippet validation"));
    assert!(logs_contain("Finished per-snippet validation"));
}

/// A validator that supports batching in general (rust) can still decline a specific group —
/// `validate_batch_in_session` returning `None` even though `supports_batching` is `true`,
/// mirroring rust declining to batch `Run`-level snippets. That group's `Starting batched...`
/// must resolve to an explicit fallback notice, not a silent `continue` with no matching
/// `Finished` at all. ~keep
struct DecliningBatchValidator;

impl SnippetValidator for DecliningBatchValidator {
    fn language(&self) -> crate::snippets::types::Language {
        crate::snippets::types::Language::Rust
    }

    fn is_available(&self) -> bool {
        true
    }

    fn validate(
        &self,
        _snippet: &Snippet,
        _level: ValidationLevel,
        _timeout_secs: u64,
    ) -> Result<(SnippetStatus, Option<String>)> {
        Ok((SnippetStatus::Pass, None))
    }

    fn validate_batch_in_session(
        &self,
        _snippets: &[&Snippet],
        _level: ValidationLevel,
        _timeout_secs: u64,
        _session: Option<&crate::snippets::session::ValidationSession>,
    ) -> Option<Result<Vec<(SnippetStatus, Option<String>)>>> {
        None
    }

    fn max_level(&self) -> ValidationLevel {
        ValidationLevel::Run
    }

    fn supports_batching(&self) -> bool {
        true
    }
}

#[traced_test]
#[test]
fn batching_validator_that_declines_a_group_logs_the_fallback_explicitly() {
    let mut registry = ValidatorRegistry::new();
    registry.register(Box::new(DecliningBatchValidator));
    let config = RunnerConfig {
        level: ValidationLevel::Syntax,
        parallelism: 1,
        cache_dir: None,
        allowed_side_effects: vec![SideEffectClass::Network],
        ..RunnerConfig::default()
    };

    let summary = run_validation(&[network_snippet()], &registry, &config).expect("validation completes");

    assert_eq!(summary.results[0].status, SnippetStatus::Pass);
    assert!(logs_contain("Starting batched snippet validation"));
    assert!(logs_contain(
        "Batch validation declined for this group; falling back to per-snippet validation"
    ));
    assert!(logs_contain("Starting per-snippet validation"));
}