bc-envelope-pattern 0.14.0

Pattern matcher for Gordian Envelope
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

use bc_components::Digest;
use bc_envelope::prelude::*;
use bc_envelope_pattern::Pattern;

#[test]
fn parse_node_patterns() {
    let p = Pattern::parse("node").unwrap();
    assert_eq!(p, Pattern::any_node());
    assert_eq!(p.to_string(), "node");

    let p = Pattern::parse("node({1,3})").unwrap();
    assert_eq!(p, Pattern::node_with_assertions_range(1..=3));
    assert_eq!(p.to_string(), "node({1,3})");
}

#[test]
fn parse_wrapped_pattern() {
    let p = Pattern::parse("wrapped").unwrap();
    assert_eq!(p, Pattern::wrapped());
    assert_eq!(p.to_string(), "wrapped");
}

#[test]
fn parse_unwrap_pattern() {
    let p = Pattern::parse("unwrap").unwrap();
    assert_eq!(p, Pattern::unwrap());
    assert_eq!(p.to_string(), "unwrap");

    let p = Pattern::parse("unwrap(node)").unwrap();
    assert_eq!(p, Pattern::unwrap_matching(Pattern::any_node()));
    assert_eq!(p.to_string(), "unwrap(node)");
}

#[test]
fn parse_subject_patterns() {
    let p = Pattern::parse("subj").unwrap();
    assert_eq!(p, Pattern::any_subject());
    assert_eq!(p.to_string(), "subj");

    let p = Pattern::parse(r#"subj("hi")"#).unwrap();
    assert_eq!(p, Pattern::subject(Pattern::text("hi")));
    assert_eq!(p.to_string(), r#"subj("hi")"#);
}

#[test]
fn parse_assert_patterns() {
    let p = Pattern::parse("assert").unwrap();
    assert_eq!(p, Pattern::any_assertion());
    assert_eq!(p.to_string(), "assert");

    let p = Pattern::parse(r#"assertpred("hi")"#).unwrap();
    assert_eq!(p, Pattern::assertion_with_predicate(Pattern::text("hi")));
    assert_eq!(p.to_string(), r#"assertpred("hi")"#);

    let spaced = r#"assertpred ( "hi" )"#;
    let p_spaced = Pattern::parse(spaced).unwrap();
    assert_eq!(
        p_spaced,
        Pattern::assertion_with_predicate(Pattern::text("hi"))
    );
    assert_eq!(p_spaced.to_string(), r#"assertpred("hi")"#);

    let p = Pattern::parse("assertobj(1)").unwrap();
    assert_eq!(p, Pattern::assertion_with_object(Pattern::number(1)));
    assert_eq!(p.to_string(), "assertobj(1)");
}

#[test]
fn parse_object_patterns() {
    let p = Pattern::parse("obj").unwrap();
    assert_eq!(p, Pattern::any_object());
    assert_eq!(p.to_string(), "obj");

    let p = Pattern::parse(r#"obj("hi")"#).unwrap();
    assert_eq!(p, Pattern::object(Pattern::text("hi")));
    assert_eq!(p.to_string(), r#"obj("hi")"#);

    let spaced = r#"obj ( "hi" )"#;
    let p_spaced = Pattern::parse(spaced).unwrap();
    assert_eq!(p_spaced, Pattern::object(Pattern::text("hi")));
    assert_eq!(p_spaced.to_string(), r#"obj("hi")"#);
}

#[test]
fn parse_predicate_patterns() {
    let p = Pattern::parse("pred").unwrap();
    assert_eq!(p, Pattern::any_predicate());
    assert_eq!(p.to_string(), "pred");

    let p = Pattern::parse("pred(1)").unwrap();
    assert_eq!(p, Pattern::predicate(Pattern::number(1)));
    assert_eq!(p.to_string(), "pred(1)");

    let spaced = "pred ( 1 )";
    let p_spaced = Pattern::parse(spaced).unwrap();
    assert_eq!(p_spaced, Pattern::predicate(Pattern::number(1)));
    assert_eq!(p_spaced.to_string(), "pred(1)");
}

#[test]
fn parse_obscured_patterns() {
    let p = Pattern::parse("obscured").unwrap();
    assert_eq!(p, Pattern::obscured());
    assert_eq!(p.to_string(), "obscured");

    let p = Pattern::parse("elided").unwrap();
    assert_eq!(p, Pattern::elided());
    assert_eq!(p.to_string(), "elided");

    let p = Pattern::parse("encrypted").unwrap();
    assert_eq!(p, Pattern::encrypted());
    assert_eq!(p.to_string(), "encrypted");

    let p = Pattern::parse("compressed").unwrap();
    assert_eq!(p, Pattern::compressed());
    assert_eq!(p.to_string(), "compressed");
}

#[test]
fn parse_digest_patterns() {
    let p = Pattern::parse("digest(a1b2c3)").unwrap();
    assert_eq!(p, Pattern::digest_prefix(hex::decode("a1b2c3").unwrap()));
    assert_eq!(p.to_string(), "digest(a1b2c3)");

    let spaced = "digest ( a1b2c3 )";
    let p_spaced = Pattern::parse(spaced).unwrap();
    assert_eq!(
        p_spaced,
        Pattern::digest_prefix(hex::decode("a1b2c3").unwrap())
    );
    assert_eq!(p_spaced.to_string(), "digest(a1b2c3)");
}

#[test]
fn parse_digest_ur_pattern() {
    bc_envelope::register_tags();
    let digest = Digest::from_image(b"hello world");
    let ur = digest.ur_string();
    let expr = format!("digest({})", ur);
    let p = Pattern::parse(&expr).unwrap();
    assert_eq!(p, Pattern::digest(digest));
    assert_eq!(p.to_string(), format!("digest({})", digest));
}