links-notation 0.13.0

Rust implementation of the Links Notation parser
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

use links_notation::parse_lino_to_links;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn basic_indented_id_syntax_test() {
        let indented_syntax = "3:\n  papa\n  loves\n  mama";
        let inline_syntax = "(3: papa loves mama)";

        let indented_result = parse_lino_to_links(indented_syntax).unwrap();
        let inline_result = parse_lino_to_links(inline_syntax).unwrap();

        // Both should produce the same structure when formatted
        assert_eq!(indented_result.len(), 1);
        assert_eq!(inline_result.len(), 1);

        println!("Indented result: {:?}", indented_result);
        println!("Inline result: {:?}", inline_result);

        // Both should format to similar structure
        assert_eq!(
            format!("{}", indented_result[0]),
            format!("{}", inline_result[0])
        );
    }

    #[test]
    fn indented_id_syntax_with_single_value_test() {
        let input = "greeting:\n  hello";
        let result = parse_lino_to_links(input).unwrap();

        assert_eq!(result.len(), 1);
        assert_eq!(format!("{}", result[0]), "(greeting: hello)");
    }

    #[test]
    fn indented_id_syntax_with_multiple_values_test() {
        let input = "action:\n  run\n  fast\n  now";
        let result = parse_lino_to_links(input).unwrap();

        assert_eq!(result.len(), 1);
        assert_eq!(format!("{}", result[0]), "(action: run fast now)");
    }

    #[test]
    fn indented_id_syntax_with_numeric_id_test() {
        let input = "42:\n  answer\n  to\n  everything";
        let result = parse_lino_to_links(input).unwrap();

        assert_eq!(result.len(), 1);
        assert_eq!(format!("{}", result[0]), "(42: answer to everything)");
    }

    #[test]
    fn unsupported_colon_only_syntax_should_fail_test() {
        let input = ":\n  papa\n  loves\n  mama";

        // This should fail
        assert!(parse_lino_to_links(input).is_err());
    }

    #[test]
    fn empty_indented_id_should_work_test() {
        let input = "empty:";
        let result = parse_lino_to_links(input).unwrap();

        assert_eq!(result.len(), 1);
        // For empty ID, it shows just the ID as a reference
        assert_eq!(format!("{}", result[0]), "empty");
    }

    #[test]
    fn indented_id_syntax_with_quoted_id_test() {
        let input = "\"complex id\":\n  value1\n  value2";
        let result = parse_lino_to_links(input).unwrap();

        assert_eq!(result.len(), 1);
        let formatted = format!("{}", result[0]);
        assert!(formatted.contains("complex id"));
        assert!(formatted.contains("value1"));
        assert!(formatted.contains("value2"));
    }

    #[test]
    fn multiple_indented_id_links_test() {
        let input = "first:\n  a\n  b\nsecond:\n  c\n  d";
        let result = parse_lino_to_links(input).unwrap();

        assert_eq!(result.len(), 2);
        let formatted1 = format!("{}", result[0]);
        let formatted2 = format!("{}", result[1]);
        assert!(formatted1.contains("first"));
        assert!(formatted2.contains("second"));
    }

    #[test]
    fn mixed_indented_and_regular_syntax_test() {
        let input = "first:\n  a\n  b\n(second: c d)\nthird value";
        let result = parse_lino_to_links(input).unwrap();

        assert_eq!(result.len(), 3);
        // First link should have 'first' with values
        let formatted1 = format!("{}", result[0]);
        assert!(formatted1.contains("first"));
    }

    #[test]
    fn indented_id_with_deeper_nesting_test() {
        let input = "root:\n  child1\n  child2\n    grandchild";
        let result = parse_lino_to_links(input).unwrap();

        assert!(!result.is_empty());
        // The root should exist
        let formatted = format!("{}", result[0]);
        assert!(formatted.contains("root"));
    }

    #[test]
    fn equivalence_test_comprehensive() {
        let test_cases = vec![
            ("test:\n  one", "(test: one)"),
            ("x:\n  a\n  b\n  c", "(x: a b c)"),
        ];

        for (indented, inline) in test_cases {
            let indented_result = parse_lino_to_links(indented).unwrap();
            let inline_result = parse_lino_to_links(inline).unwrap();

            assert_eq!(indented_result.len(), inline_result.len());
            // Both should format to the same output
            assert_eq!(
                format!("{}", indented_result[0]),
                format!("{}", inline_result[0])
            );
        }
    }
}