sysml-v2-parser 0.20.1

SysML v2 textual notation parser for Rust
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

//! Parser tests: occurrence-style DefinitionBody members on flow/allocation defs.

use sysml_v2_parser::ast::*;

fn parse_package(input: &str) -> Package {
    let result = sysml_v2_parser::parse(input).expect("parse should succeed");
    match result.elements[0].value.clone() {
        RootElement::Package(package) => package.value,
        _ => panic!("expected package"),
    }
}

fn brace_package_elements(pkg: &Package) -> &[Node<PackageBodyElement>] {
    match &pkg.body {
        PackageBody::Brace { elements } => elements,
        _ => panic!("expected brace package body"),
    }
}

fn brace_definition_elements(body: &DefinitionBody) -> &[Node<DefinitionBodyElement>] {
    match body {
        DefinitionBody::Brace { elements } => elements,
        _ => panic!("expected brace definition body"),
    }
}

fn has_occurrence_attribute_member(elements: &[Node<DefinitionBodyElement>], name: &str) -> bool {
    elements.iter().any(|element| {
        matches!(
            &element.value,
            DefinitionBodyElement::OccurrenceMember(member)
                if matches!(
                    &member.value,
                    OccurrenceBodyElement::AttributeUsage(attribute)
                        if attribute.value.name == name
                )
        )
    })
}

fn has_occurrence_part_member(elements: &[Node<DefinitionBodyElement>], name: &str) -> bool {
    elements.iter().any(|element| {
        matches!(
            &element.value,
            DefinitionBodyElement::OccurrenceMember(member)
                if matches!(
                    &member.value,
                    OccurrenceBodyElement::PartUsage(part)
                        if part.value.name == name
                )
        )
    })
}

fn has_occurrence_doc_member(elements: &[Node<DefinitionBodyElement>]) -> bool {
    elements.iter().any(|element| {
        matches!(
            &element.value,
            DefinitionBodyElement::OccurrenceMember(member)
                if matches!(&member.value, OccurrenceBodyElement::Doc(_))
        )
    })
}

#[test]
fn flow_def_body_parses_inner_attribute() {
    let pkg = parse_package("package P { flow def Power { attribute rate : Real; } }");
    let flow = match &brace_package_elements(&pkg)[0].value {
        PackageBodyElement::FlowDef(flow) => flow,
        _ => panic!("expected FlowDef"),
    };
    let elements = brace_definition_elements(&flow.value.body);
    assert!(
        has_occurrence_attribute_member(elements, "rate"),
        "expected attribute rate in flow def body"
    );
}

#[test]
fn flow_def_body_parses_nested_part() {
    let pkg = parse_package("package P { part def Wheel; flow def Event { part wheel : Wheel; } }");
    let elements = brace_package_elements(&pkg);
    let flow = match &elements[1].value {
        PackageBodyElement::FlowDef(flow) => flow,
        _ => panic!("expected FlowDef"),
    };
    let body_elements = brace_definition_elements(&flow.value.body);
    assert!(
        has_occurrence_part_member(body_elements, "wheel"),
        "expected part wheel in flow def body"
    );
}

#[test]
fn flow_usage_brace_body_parses_attribute() {
    let pkg = parse_package("package P { item def Payload; flow cargo : Payload { attribute weight : Real; } }");
    let flow = brace_package_elements(&pkg)
        .iter()
        .find_map(|element| match &element.value {
            PackageBodyElement::FlowUsage(flow) => Some(flow),
            _ => None,
        })
        .expect("expected FlowUsage");
    let elements = brace_definition_elements(&flow.body);
    assert!(
        has_occurrence_attribute_member(elements, "weight"),
        "expected attribute weight in flow usage body"
    );
}

#[test]
fn allocation_def_body_parses_attribute() {
    let pkg = parse_package("package P { allocation def Map { attribute id : String; } }");
    let alloc = match &brace_package_elements(&pkg)[0].value {
        PackageBodyElement::AllocationDef(alloc) => alloc,
        _ => panic!("expected AllocationDef"),
    };
    let elements = brace_definition_elements(&alloc.value.body);
    assert!(
        has_occurrence_attribute_member(elements, "id"),
        "expected attribute id in allocation def body"
    );
}

#[test]
fn flow_def_doc_only_body_regression() {
    let pkg = parse_package("package P { flow def Power { doc /* note */ } }");
    let flow = match &brace_package_elements(&pkg)[0].value {
        PackageBodyElement::FlowDef(flow) => flow,
        _ => panic!("expected FlowDef"),
    };
    let elements = brace_definition_elements(&flow.value.body);
    assert!(
        has_occurrence_doc_member(elements),
        "expected doc member in flow def body"
    );
}