relateby-gram 0.2.8

Bidirectional codec between Gram notation and Pattern data structures
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

//! Node pattern parser for gram notation

use super::combinators::ws;
use super::subject::subject;
use super::types::ParseResult;
use nom::{
    character::complete::char,
    combinator::{cut, map},
    sequence::delimited,
};
use pattern_core::{Pattern, Subject};

/// Parse a node pattern: (subject)
/// Node patterns have 0 elements
pub fn node(input: &str) -> ParseResult<'_, Pattern<Subject>> {
    map(
        delimited(char('('), delimited(ws, subject, ws), cut(char(')'))),
        Pattern::point,
    )(input)
}

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

    #[test]
    fn test_node_simple() {
        let (remaining, pattern) = node("(hello)").unwrap();
        assert_eq!(pattern.value().identity.0, "hello");
        assert_eq!(pattern.elements().len(), 0);
        assert_eq!(remaining, "");
    }

    #[test]
    fn test_node_with_label() {
        let (remaining, pattern) = node("(alice:Person)").unwrap();
        assert_eq!(pattern.value().identity.0, "alice");
        assert!(pattern.value().labels.contains("Person"));
        assert_eq!(pattern.elements().len(), 0);
        assert_eq!(remaining, "");
    }

    #[test]
    fn test_node_with_properties() {
        let (remaining, pattern) = node(r#"(alice {name: "Alice"})"#).unwrap();
        assert_eq!(pattern.value().identity.0, "alice");
        assert_eq!(pattern.value().properties.len(), 1);
        assert_eq!(pattern.elements().len(), 0);
        assert_eq!(remaining, "");
    }

    #[test]
    fn test_node_full() {
        let (remaining, pattern) = node(r#"(alice:Person {name: "Alice", age: 30})"#).unwrap();
        assert_eq!(pattern.value().identity.0, "alice");
        assert!(pattern.value().labels.contains("Person"));
        assert_eq!(pattern.value().properties.len(), 2);
        assert_eq!(pattern.elements().len(), 0);
        assert_eq!(remaining, "");
    }

    #[test]
    fn test_node_empty() {
        let (remaining, pattern) = node("()").unwrap();
        assert_eq!(pattern.value().identity.0, "");
        assert_eq!(pattern.elements().len(), 0);
        assert_eq!(remaining, "");
    }

    #[test]
    fn test_node_with_whitespace() {
        let (remaining, pattern) = node("(  hello  )").unwrap();
        assert_eq!(pattern.value().identity.0, "hello");
        assert_eq!(remaining, "");
    }
}