webots-proto 0.1.3

Facade crate for parsing, templating, resolving, and validating Webots PROTO.
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
144
145
146
147
148
149
150
151

#[cfg(feature = "validation")]
mod imports;

#[cfg(feature = "validation")]
use std::collections::HashSet;

use thiserror::Error;

pub use webots_proto_ast as ast;
#[cfg(feature = "resolver")]
pub use webots_proto_resolver as resolver;
#[cfg(feature = "schema")]
pub use webots_proto_schema as schema;
#[cfg(feature = "schema")]
pub use webots_proto_schema::types;

pub use webots_proto_ast::{AstNode, FieldValue, Proto};
#[cfg(feature = "resolver")]
pub use webots_proto_resolver::{ProtoResolver, ResolveOptions};
#[cfg(feature = "r2025a")]
pub use webots_proto_schema::r2025a;
#[cfg(feature = "schema")]
pub use webots_proto_schema::{
    Diagnostic, DiagnosticSet, Error as SchemaError, NodeSchema, Result as SchemaResult,
    SchemaField, Severity, ValidationContext, ast_to_r2025a_node, r2025a_node_to_ast,
};
#[cfg(feature = "template")]
pub use webots_proto_template::{
    RenderContext, RenderOptions, RenderWebotsVersion, TemplateContext, TemplateError,
    TemplateEvaluator, TemplateField, TemplateFieldBinding, TemplateWebotsVersion,
};

#[derive(Debug, Error)]
pub enum Error {
    #[error(transparent)]
    Ast(#[from] webots_proto_ast::ProtoError),
    #[cfg(feature = "template")]
    #[error(transparent)]
    Template(#[from] webots_proto_template::TemplateError),
    #[cfg(feature = "resolver")]
    #[error(transparent)]
    Resolver(#[from] webots_proto_resolver::ProtoError),
    #[error(transparent)]
    Io(#[from] std::io::Error),
}

pub type Result<T> = std::result::Result<T, Error>;

#[cfg(feature = "validation")]
#[derive(Debug, Clone, Default)]
pub struct ValidationOptions {
    pub local_externproto_naming: bool,
    pub runtime_semantics: bool,
}

#[cfg(feature = "validation")]
impl ValidationOptions {
    pub fn new() -> Self {
        Self {
            local_externproto_naming: true,
            runtime_semantics: true,
        }
    }

    pub fn with_local_externproto_naming(mut self, enabled: bool) -> Self {
        self.local_externproto_naming = enabled;
        self
    }

    pub fn with_runtime_semantics(mut self, enabled: bool) -> Self {
        self.runtime_semantics = enabled;
        self
    }
}

#[cfg(any(feature = "template", feature = "validation"))]
pub trait ProtoExt {
    #[cfg(feature = "template")]
    fn render(&self, options: &RenderOptions) -> Result<String>;
    #[cfg(feature = "validation")]
    fn validate(&self) -> Result<DiagnosticSet>;
    #[cfg(feature = "validation")]
    fn validate_with_options(&self, options: &ValidationOptions) -> Result<DiagnosticSet>;
}

#[cfg(any(feature = "template", feature = "validation"))]
impl ProtoExt for Proto {
    #[cfg(feature = "template")]
    fn render(&self, options: &RenderOptions) -> Result<String> {
        Ok(webots_proto_template::render(self, options)?)
    }

    #[cfg(feature = "validation")]
    fn validate(&self) -> Result<DiagnosticSet> {
        self.validate_with_options(&ValidationOptions::new())
    }

    #[cfg(feature = "validation")]
    fn validate_with_options(&self, options: &ValidationOptions) -> Result<DiagnosticSet> {
        validate_with_options(self, options)
    }
}

#[cfg(feature = "validation")]
pub fn validate(proto: &Proto) -> Result<DiagnosticSet> {
    validate_with_options(proto, &ValidationOptions::new())
}

#[cfg(feature = "validation")]
pub fn validate_with_options(proto: &Proto, options: &ValidationOptions) -> Result<DiagnosticSet> {
    let mut diagnostics = schema::validate(proto);

    if options.local_externproto_naming
        && let Some(source_path) = &proto.source_path
    {
        diagnostics.extend(imports::validate_local_externproto_naming(
            source_path,
            proto,
        )?);
    }

    if options.runtime_semantics
        && let Some(source_path) = &proto.source_path
    {
        let content = proto
            .source_content
            .clone()
            .map(Ok)
            .unwrap_or_else(|| std::fs::read_to_string(source_path).map_err(Error::from))?;

        if let Some(base_path) = source_path.parent() {
            let expanded_root = ProtoResolver::new(ResolveOptions::new())
                .to_root_node(&content, Some(base_path))?;
            diagnostics.extend(schema::validate_runtime_semantics(&expanded_root));
        }
    }

    Ok(dedupe_diagnostics(diagnostics))
}

#[cfg(feature = "validation")]
fn dedupe_diagnostics(diagnostics: DiagnosticSet) -> DiagnosticSet {
    let mut deduped = DiagnosticSet::new();
    let mut seen = HashSet::new();
    for diagnostic in diagnostics.iter() {
        if seen.insert(diagnostic.clone()) {
            deduped.add(diagnostic.clone());
        }
    }
    deduped
}