platform-lino 0.0.2

Rust implementation of the Lino protocol 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

use lino::parse_lino;
use lino::parser::parse_document;

#[test]
fn significant_whitespace_test() {
    let source = r#"
users
    user1
        id
            43
        name
            first
                John
            last
                Williams
        location
            New York
        age
            23
    user2
        id
            56
        name
            first
                Igor
            middle
                Petrovich
            last
                Ivanov
        location
            Moscow
        age
            20"#;

    let target = "(users)\n(users user1)\n((users user1) id)\n(((users user1) id) 43)\n((users user1) name)\n(((users user1) name) first)\n((((users user1) name) first) John)\n(((users user1) name) last)\n((((users user1) name) last) Williams)\n((users user1) location)\n(((users user1) location) (New York))\n((users user1) age)\n(((users user1) age) 23)\n(users user2)\n((users user2) id)\n(((users user2) id) 56)\n((users user2) name)\n(((users user2) name) first)\n((((users user2) name) first) Igor)\n(((users user2) name) middle)\n((((users user2) name) middle) Petrovich)\n(((users user2) name) last)\n((((users user2) name) last) Ivanov)\n((users user2) location)\n(((users user2) location) Moscow)\n((users user2) age)\n(((users user2) age) 20)";
    let parsed = parse_lino(source).unwrap();
    let output = format!("{:#}", parsed);
    assert_eq!(target, output);
}

#[test]
fn simple_significant_whitespace_test() {
    let source = "a\n    b\n    c";
    let target = "(a)\n(a b)\n(a c)";
    let parsed = parse_lino(source).unwrap();
    let output = format!("{:#}", parsed);
    assert_eq!(target, output);
}

#[test]
fn two_spaces_sized_whitespace_test() {
    let source = "\nusers\n  user1";
    let target = "(users)\n(users user1)";
    let parsed = parse_lino(source).unwrap();
    let output = format!("{:#}", parsed);
    assert_eq!(target, output);
}

#[test]
fn parse_nested_structure_with_indentation() {
    let input = "parent\n  child1\n  child2";
    let target = "(parent)\n(parent child1)\n(parent child2)";
    let result = parse_lino(input).unwrap();
    let output = format!("{:#}", result);
    assert_eq!(target, output);
}

#[test]
fn test_indentation_consistency() {
    // Test that indentation must be consistent
    let input = "parent\n  child1\n   child2"; // Inconsistent indentation
    let result = parse_lino(input).unwrap();
    let output = format!("{:#}", result);
    // Should produce at least the parent and child1 as separate links
    assert!(output.contains("(parent)"));
    assert!(output.contains("(parent child1)"));
}

#[test]
fn test_indentation_based_children() {
    // Test indentation-based children
    let input = "parent\n  child1\n  child2\n    grandchild";
    let result = parse_lino(input).unwrap();
    let output = format!("{:#}", result);
    let expected = "(parent)\n(parent child1)\n(parent child2)\n((parent child2) grandchild)";
    assert_eq!(expected, output);
}

#[test]
fn test_complex_indentation() {
    // Test complex indentation
    let input = r#"root
  level1a
    level2a
    level2b
  level1b
    level2c"#;
    let result = parse_lino(input).unwrap();
    let output = format!("{:#}", result);
    let expected = "(root)\n(root level1a)\n((root level1a) level2a)\n((root level1a) level2b)\n(root level1b)\n((root level1b) level2c)";
    assert_eq!(expected, output);
}

#[test]
fn test_nested_links() {
    let input = "(1: (2: (3: 3)))";
    let parsed = parse_lino(input).expect("Failed to parse input");

    // Validate regular formatting
    let output = parsed.to_string();
    let expected = "((1: (2: (3: 3))))";
    assert_eq!(expected, output);

    // Validate alternate formatting
    let output_alternate = format!("{:#}", parsed);
    assert_eq!(input, output_alternate);
}

// Tests moved from parser.rs

#[test]
fn test_indentation() {
    let input = "parent\n  child1\n  child2";
    let result = parse_document(input).unwrap();
    assert_eq!(result.1.len(), 1);
    assert_eq!(result.1[0].id, Some("parent".to_string()));
    assert_eq!(result.1[0].children.len(), 2);
}

#[test]
fn test_nested_indentation() {
    let input = "parent\n  child\n    grandchild";
    let result = parse_document(input).unwrap();
    assert_eq!(result.1.len(), 1);
    assert_eq!(result.1[0].children.len(), 1);
    assert_eq!(result.1[0].children[0].children.len(), 1);
}