harn-rules 0.8.65

Declarative structural rule engine for Harn — rule model, pattern compiler, and matcher built on the harn-hostlib tree-sitter machinery.
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

//! End-to-end acceptance for #2834: `where` constraints, the `transform`
//! pipeline, and `fix` interpolation, applied as a codemod.

use harn_rules::{CompiledRule, Rule};

fn compile(toml: &str) -> CompiledRule {
    CompiledRule::compile(&Rule::from_toml_str(toml).expect("rule parses")).expect("rule compiles")
}

#[test]
fn destructuring_fix_handles_alias_and_shorthand() {
    // The #2824 customer's single-binding fold + alias handling:
    //   `let id = src?.userId`     -> `{ userId: id }`     (aliased)
    //   `let userId = src?.userId` -> `{ userId: userId }` (shorthand once
    //                                  `harn fmt` collapses the duplicate key)
    let rule = compile(
        r#"
        id = "fold-optional-bind"
        language = "typescript"
        fix = "{ $KEY: $NAME }"
        [rule]
        pattern = "let $NAME = $SRC?.$KEY"
        "#,
    );

    let aliased = rule.apply("let id = src?.userId;\n").unwrap();
    assert!(aliased.changed);
    assert!(
        aliased.rewritten.contains("{ userId: id }"),
        "got: {}",
        aliased.rewritten
    );

    let shorthand = rule.apply("let userId = src?.userId;\n").unwrap();
    assert!(
        shorthand.rewritten.contains("{ userId: userId }"),
        "got: {}",
        shorthand.rewritten
    );
}

#[test]
fn fix_uses_a_transform_synthesized_metavar() {
    // Rename a camelCase call to snake_case using a `convert` transform,
    // then interpolate the synthesized metavar into the fix.
    let rule = compile(
        r#"
        id = "snakeify-call"
        language = "typescript"
        fix = "$SNAKE()"
        [rule]
        pattern = "$FN()"
        [transform.SNAKE]
        source = "FN"
        convert = "snake"
        "#,
    );
    let result = rule.apply("getUserId();\n").unwrap();
    assert!(
        result.rewritten.contains("get_user_id()"),
        "got: {}",
        result.rewritten
    );
}

#[test]
fn where_constraint_filters_matches() {
    // Only rewrite calls whose callee matches the constraint regex.
    let rule = compile(
        r#"
        id = "guarded-rename"
        language = "typescript"
        fix = "renamed()"
        [rule]
        pattern = "$FN()"
        [[where]]
        metavar = "FN"
        regex = "^legacy"
        "#,
    );
    let result = rule
        .apply("legacyInit();\nkeepThis();\nlegacyTeardown();\n")
        .unwrap();
    // The two `legacy*` calls are rewritten; `keepThis()` is untouched.
    assert_eq!(result.edits.len(), 2);
    assert!(result.rewritten.contains("keepThis()"));
    assert_eq!(result.rewritten.matches("renamed()").count(), 2);
}

#[test]
fn comparison_constraint_filters_numerically() {
    // Only flag default values greater than 100.
    let rule = compile(
        r#"
        id = "big-default"
        language = "typescript"
        fix = "CAPPED"
        [rule]
        pattern = "$SRC?.$KEY ?? $N"
        [[where]]
        metavar = "N"
        comparison = { op = ">", value = 100 }
        "#,
    );
    let result = rule
        .apply("const a = o?.x ?? 5;\nconst b = o?.y ?? 500;\n")
        .unwrap();
    assert_eq!(result.edits.len(), 1);
    assert!(result.rewritten.contains("?? 5"));
    assert!(result.rewritten.contains("CAPPED"));
}

#[test]
fn apply_without_fix_errors() {
    let rule = compile(
        r#"
        id = "search-only"
        language = "typescript"
        [rule]
        pattern = "$FN()"
        "#,
    );
    assert!(rule.apply("foo();").is_err());
}