harn-lint 0.8.4

Linter for the Harn programming language
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

use super::*;

#[test]
fn persona_body_must_call_step_functions() {
    let source = r#"
@persona(name: "merge_captain")
fn merge_captain(ctx) {
  plan(ctx)
  helper(ctx)
  println("done")
}

@step(name: "plan")
fn plan(ctx) {
  return ctx
}

fn helper(ctx) {
  return ctx
}
"#;

    let diagnostics = lint_source(source);
    let persona_diags: Vec<_> = diagnostics
        .iter()
        .filter(|diag| diag.rule == "persona-body-must-call-steps")
        .collect();
    assert_eq!(persona_diags.len(), 1);
    assert!(persona_diags[0].message.contains("helper"));
}

#[test]
fn persona_body_allowlist_suppresses_step_requirement() {
    let source = r#"
@persona(name: "merge_captain")
fn merge_captain(ctx) {
  helper(ctx)
}

fn helper(ctx) {
  return ctx
}
"#;
    let mut lexer = Lexer::new(source);
    let tokens = lexer.tokenize().unwrap();
    let mut parser = Parser::new(tokens);
    let program = parser.parse().unwrap();
    let allow = vec!["helper".to_string()];
    let options = LintOptions {
        file_path: None,
        require_file_header: false,
        complexity_threshold: None,
        persona_step_allowlist: &allow,
    };
    let diagnostics = lint_with_options(&program, &[], Some(source), &HashSet::new(), &options);
    assert!(!has_rule(&diagnostics, "persona-body-must-call-steps"));
}

#[test]
fn step_hook_target_must_exist_in_matching_persona() {
    let source = r#"
@persona(name: "merge_captain")
fn merge_captain(ctx) {
  plan(ctx)
}

@step(name: "plan")
fn plan(ctx) {
  return ctx
}

pipeline default() {
  register_step_hook("merge_*", "publish", "PreStep", { ctx -> nil })
}
"#;

    let diagnostics = lint_source(source);
    let target_diags: Vec<_> = diagnostics
        .iter()
        .filter(|diag| diag.rule == "persona-hook-target")
        .collect();
    assert_eq!(target_diags.len(), 1);
    assert!(target_diags[0].message.contains("publish"));
}

#[test]
fn step_hook_target_accepts_declared_persona_step() {
    let source = r#"
@persona(name: "merge_captain")
fn merge_captain(ctx) {
  plan(ctx)
}

@step(name: "plan")
fn plan(ctx) {
  return ctx
}

pipeline default() {
  register_step_hook("merge_*", "plan", "PreStep", { ctx -> nil })
}
"#;

    let diagnostics = lint_source(source);
    assert!(!has_rule(&diagnostics, "persona-hook-target"));
}