hyprlang 0.5.0

A scripting language interpreter and parser for Hyprlang and Hyprland configuration files.
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

use hyprlang::Config;

#[test]
fn test_backslash_escape_expr() {
    let mut config = Config::new();
    config.parse(r"testValue = \{{10 + 5}}").unwrap();

    // Should be literal string, not evaluated
    assert_eq!(config.get_string("testValue").unwrap(), "{{10 + 5}}");
}

#[test]
fn test_brace_escape_expr() {
    let mut config = Config::new();
    config.parse(r"testValue = {\{10 + 5}}").unwrap();

    // Should be literal string, not evaluated
    assert_eq!(config.get_string("testValue").unwrap(), "{{10 + 5}}");
}

#[test]
fn test_double_backslash_brace_escape() {
    let mut config = Config::new();
    config.parse(r"testValue = \{\{10 + 5}}").unwrap();

    // \{\{ should produce literal {{
    assert_eq!(config.get_string("testValue").unwrap(), "{{10 + 5}}");
}

#[test]
fn test_escaped_backslash_with_expr() {
    let mut config = Config::new();
    config.parse(r"testValue = \\{{10 - 5}}").unwrap();

    // Should evaluate the expression but keep one backslash
    assert_eq!(config.get_string("testValue").unwrap(), r"\5");
}

#[test]
fn test_mixed_escaped_and_eval() {
    let mut config = Config::new();
    config
        .parse(r#"testValue = "{{8 - 10}} and \{{literal}}""#)
        .unwrap();

    // First expression evaluates, second is literal
    assert_eq!(
        config.get_string("testValue").unwrap(),
        "\"-2 and {{literal}}\""
    );
}

#[test]
fn test_escaped_expr_in_variable() {
    let mut config = Config::new();
    config
        .parse(
            r#"
        $ESCAPED = \{{10 + 10}}
        testValue = $ESCAPED
    "#,
        )
        .unwrap();

    // Variable should contain literal {{}}
    assert_eq!(config.get_string("testValue").unwrap(), "{{10 + 10}}");
}

#[test]
fn test_complex_mixed_escapes() {
    let mut config = Config::new();
    config
        .parse(r#"testValue = "{{8 - 10}} \{{ literal }} more""#)
        .unwrap();

    // First expression evaluates, escaped part stays literal
    assert_eq!(
        config.get_string("testValue").unwrap(),
        "\"-2 {{ literal }} more\""
    );
}

#[test]
fn test_escaped_with_variables() {
    let mut config = Config::new();
    config
        .parse(
            r#"
        $MOVING_VAR = 500
        $DYNAMIC = moved: {{$MOVING_VAR / 2}} expr: \{{$MOVING_VAR / 2}}
        testValue = \{{ $DYNAMIC }}
    "#,
        )
        .unwrap();

    // The testValue should have escaped outer braces, but DYNAMIC should be expanded
    assert_eq!(
        config.get_string("testValue").unwrap(),
        "{{ moved: 250 expr: {{500 / 2}} }}"
    );
}

#[test]
fn test_no_escape_normal_expr() {
    let mut config = Config::new();
    config.parse(r"testValue = {{10 + 5}}").unwrap();

    // Normal expression should evaluate
    assert_eq!(config.get_int("testValue").unwrap(), 15);
}

#[test]
fn test_escaped_not_expression() {
    let mut config = Config::new();
    config.parse(r"testValue = \{notAnExpression").unwrap();

    // Single brace escape should not be processed
    assert_eq!(
        config.get_string("testValue").unwrap(),
        r"\{notAnExpression"
    );
}

#[test]
fn test_config_file_escapes() {
    // Test the actual patterns from the test config file
    let mut config = Config::new();

    config
        .parse(
            r#"
        testInt = 123
        testEscapedExpr = "\{{testInt + 7}}"
        testEscapedExpr2 = "{\{testInt + 7}}"
        testEscapedExpr3 = "\{\{3 + 8}}"
        testEscapedEscape = "\\{{10 - 5}}"
        testSimpleMix = "{{8 - 10}} and \{{ literal }}"
    "#,
        )
        .unwrap();

    assert_eq!(
        config.get_string("testEscapedExpr").unwrap(),
        "\"{{testInt + 7}}\""
    );
    assert_eq!(
        config.get_string("testEscapedExpr2").unwrap(),
        "\"{{testInt + 7}}\""
    );
    assert_eq!(config.get_string("testEscapedExpr3").unwrap(), "\"{{3 + 8}}\"");
    assert_eq!(config.get_string("testEscapedEscape").unwrap(), r#""\5""#);
    assert_eq!(
        config.get_string("testSimpleMix").unwrap(),
        "\"-2 and {{ literal }}\""
    );
}