thread-language 0.1.1

Language definitions and parsers for Thread
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

// SPDX-FileCopyrightText: 2022 Herrington Darkholme <2883231+HerringtonDarkholme@users.noreply.github.com>
// SPDX-FileCopyrightText: 2025 Knitli Inc. <knitli@knit.li>
// SPDX-FileContributor: Adam Poulemanos <adam@knit.li>
//
// SPDX-License-Identifier: AGPL-3.0-or-later AND MIT
#![cfg(test)]

use super::*;

fn test_match(query: &str, source: &str) {
    use crate::test::test_match_lang;
    test_match_lang(query, source, Elixir);
}

fn test_non_match(query: &str, source: &str) {
    use crate::test::test_non_match_lang;
    test_non_match_lang(query, source, Elixir);
}

#[test]
fn test_elixir_str() {
    test_match("IO.puts(\"$A\")", "IO.puts(\"123\")");
    test_match("IO.puts($A)", "IO.puts(123)");
    test_non_match("IO.puts(123)", "IO.puts(456)");
    test_non_match("\"123\"", "\"456\"");
}

#[test]
fn test_elixir_pattern() {
    test_match("$A", ":ok");
    test_match("$A != nil", "a != nil");
    test_match(
        r#"
    def $FUNC($$$ARGS) when $GUARDS do
      $$$BODY
    end
    "#,
        r#"
    def add(a, b) when is_integer(a) and is_integer(b) do
      a + b
    end
    "#,
    );
}

fn test_replace(src: &str, pattern: &str, replacer: &str) -> String {
    use crate::test::test_replace_lang;
    test_replace_lang(src, pattern, replacer, Elixir)
}

#[test]
fn test_elixir_replace() {
    let ret = test_replace(
        "Stream.map([1, 2, 3], fn x -> x * 2 end)",
        "Stream.map($$$ARGS)",
        "Enum.map($$$ARGS)",
    );
    assert_eq!(ret, "Enum.map([1, 2, 3], fn x -> x * 2 end)");

    let ret = test_replace(
        ":budgie = hd([:budgie, :cat, :dog])",
        "$FIRST = hd($LIST)",
        "[$FIRST | _] = $LIST",
    );
    assert_eq!(ret, "[:budgie | _] = [:budgie, :cat, :dog]");

    let ret = test_replace(
        "opts[:hostname] || \"localhost\"",
        "opts[$KEY] || $DEFAULT",
        "Keyword.get(opts, $KEY, $DEFAULT)",
    );
    assert_eq!(ret, "Keyword.get(opts, :hostname, \"localhost\")");

    let ret = test_replace(
        "Module.function(:a, :b)",
        "Module.function($ARG1, $ARG2)",
        "Module.function($ARG2, $ARG1)",
    );
    assert_eq!(ret, "Module.function(:b, :a)");

    let ret = test_replace(
        "Greeter.greet(:hello, \"human\")",
        "Greeter.greet($ARG1, $ARG2)",
        "Greeter.greet($ARG1, name: $ARG2)",
    );
    assert_eq!(ret, "Greeter.greet(:hello, name: \"human\")");

    let ret = test_replace(
        "for x <- [\"budgie\", \"cat\", \"dog\"], do: String.to_atom(x)",
        "for $I <- $LIST, do: $MODULE.$FUNCTION($I)",
        "Enum.map($LIST, fn $I -> $MODULE.$FUNCTION($I) end)",
    );
    assert_eq!(
        ret,
        "Enum.map([\"budgie\", \"cat\", \"dog\"], fn x -> String.to_atom(x) end)"
    );
}