this-me 0.3.3

Rust ground for the modern .me semantic kernel.
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

use this_me::kernel::{Kernel, ParsedPath, PathPart, Selector, Value};

#[test]
fn dotted_paths_parse_to_segments() {
    let path = ParsedPath::parse("apps.fulltrailer.tractos").unwrap();

    assert_eq!(
        path.parts(),
        &[
            PathPart::Segment("apps".to_string()),
            PathPart::Segment("fulltrailer".to_string()),
            PathPart::Segment("tractos".to_string()),
        ]
    );
    assert_eq!(
        path.normalized(),
        vec![
            "apps".to_string(),
            "fulltrailer".to_string(),
            "tractos".to_string(),
        ]
    );
}

#[test]
fn numeric_selector_is_a_literal_member() {
    let path = ParsedPath::parse("items[1]").unwrap();

    assert_eq!(
        path.parts(),
        &[
            PathPart::Segment("items".to_string()),
            PathPart::Selector(Selector::Literal("1".to_string())),
        ]
    );
    assert_eq!(
        path.normalized(),
        vec!["items".to_string(), "1".to_string()]
    );
}

#[test]
fn empty_selector_preserves_plural_shape() {
    let path = ParsedPath::parse("request[]").unwrap();

    assert_eq!(
        path.parts(),
        &[
            PathPart::Segment("request".to_string()),
            PathPart::Selector(Selector::EmptyPlural),
        ]
    );
    assert_eq!(path.normalized(), vec!["request".to_string()]);
}

#[test]
fn quoted_selector_can_contain_dots() {
    let path = ParsedPath::parse(r#"item["hello.world"]"#).unwrap();

    assert_eq!(
        path.parts(),
        &[
            PathPart::Segment("item".to_string()),
            PathPart::Selector(Selector::Literal("hello.world".to_string())),
        ]
    );
    assert_eq!(
        path.normalized(),
        vec!["item".to_string(), "hello.world".to_string()]
    );
}

#[test]
fn filter_selector_is_preserved_as_expression() {
    let path = ParsedPath::parse("friends[age >= 18]").unwrap();

    assert_eq!(
        path.parts(),
        &[
            PathPart::Segment("friends".to_string()),
            PathPart::Selector(Selector::Expression("age >= 18".to_string())),
        ]
    );
    assert_eq!(
        path.normalized(),
        vec!["friends".to_string(), "age >= 18".to_string()]
    );
}

#[test]
fn chained_selectors_normalize_in_order() {
    let path = ParsedPath::parse("matrix[1][2].value").unwrap();

    assert_eq!(
        path.normalized(),
        vec![
            "matrix".to_string(),
            "1".to_string(),
            "2".to_string(),
            "value".to_string(),
        ]
    );
}

#[test]
fn kernel_uses_selector_normalization_for_reads_and_writes() {
    let mut kernel = Kernel::new();

    kernel.postulate(r#"item["hello.world"]"#, "kept").unwrap();

    assert_eq!(
        kernel.read(["item", "hello.world"]),
        Some(&Value::from("kept"))
    );
    assert_eq!(
        kernel.read(r#"item["hello.world"]"#),
        Some(&Value::from("kept"))
    );
}