graphql_schema_diff/path/
parse.rs

1use super::*;
2
3impl<'a> Path<'a> {
4    pub fn parse(s: &'a str) -> ParseResult<Path<'a>> {
5        let mut segments = s.split('.');
6
7        let first_segment = segments.next().filter(|s| !s.is_empty()).ok_or(ParseError)?;
8
9        // Is it a schema definition or extension?
10        if let Some(suffix) = first_segment.strip_prefix(":schema") {
11            if segments.next().is_some() {
12                return Err(ParseError);
13            }
14
15            if suffix.is_empty() {
16                return Ok(Path::SchemaDefinition);
17            }
18
19            let index = parse_index(suffix)?;
20            return Ok(Path::SchemaExtension(index));
21        }
22
23        // Is it a directive definition?
24        if let Some(name) = first_segment.strip_prefix('@') {
25            if !is_valid_graphql_name(name) {
26                return Err(ParseError);
27            }
28
29            if segments.next().is_some() {
30                return Err(ParseError);
31            }
32
33            return Ok(Path::DirectiveDefinition(name));
34        }
35
36        // The only remaining possibility is a type definition
37        let (name, idx) = parse_name_and_optional_index(first_segment)?;
38
39        if let Some(idx) = idx {
40            Ok(Path::TypeExtension(name, idx, Self::parse_path_in_type(segments)?))
41        } else {
42            Ok(Path::TypeDefinition(name, Self::parse_path_in_type(segments)?))
43        }
44    }
45
46    fn parse_path_in_type(mut segments: impl Iterator<Item = &'a str>) -> ParseResult<Option<PathInType<'a>>> {
47        let segment = match segments.next() {
48            Some("") => return Err(ParseError),
49            Some(segment) => segment,
50            None => return Ok(None),
51        };
52
53        // Is it a directive path?
54        if let Some(suffix) = segment.strip_prefix('@') {
55            let (name, idx) = parse_name_and_optional_index(suffix)?;
56
57            if segments.next().is_some() {
58                return Err(ParseError);
59            }
60
61            let Some(idx) = idx else {
62                return Err(ParseError);
63            };
64
65            return Ok(Some(PathInType::InDirective(name, idx)));
66        }
67
68        // Is it an interface implementation?
69        if let Some(suffix) = segment.strip_prefix('&') {
70            if !is_valid_graphql_name(suffix) {
71                return Err(ParseError);
72            }
73
74            if segments.next().is_some() {
75                return Err(ParseError);
76            }
77
78            return Ok(Some(PathInType::InterfaceImplementation(suffix)));
79        }
80
81        // The only other possibility is that we have a field / union member / enum value name.
82        if !is_valid_graphql_name(segment) {
83            return Err(ParseError);
84        }
85
86        Ok(Some(PathInType::InField(segment, Self::parse_path_in_field(segments)?)))
87    }
88
89    fn parse_path_in_field(mut segments: impl Iterator<Item = &'a str>) -> ParseResult<Option<PathInField<'a>>> {
90        let segment = match segments.next() {
91            Some("") => return Err(ParseError),
92            Some(segment) => segment,
93            None => return Ok(None),
94        };
95
96        // To be implemented.
97        if segments.next().is_some() {
98            return Err(ParseError);
99        }
100
101        // Is it a directive path?
102        if let Some(suffix) = segment.strip_prefix('@') {
103            let (name, Some(idx)) = parse_name_and_optional_index(suffix)? else {
104                return Err(ParseError);
105            };
106
107            if segments.next().is_some() {
108                return Err(ParseError);
109            }
110
111            return Ok(Some(PathInField::InDirective(name, idx)));
112        }
113
114        // The only other possibility is that we have an argument name.
115        if !is_valid_graphql_name(segment) {
116            return Err(ParseError);
117        }
118
119        Ok(Some(PathInField::InArgument(segment)))
120    }
121}
122
123fn parse_name_and_optional_index(s: &str) -> ParseResult<(&str, Option<usize>)> {
124    let bracket_idx = s.chars().position(|c| c == '[');
125
126    let name = bracket_idx.map(|idx| &s[..idx]).unwrap_or(s);
127
128    if !is_valid_graphql_name(name) {
129        return Err(ParseError);
130    }
131
132    let idx = if let Some(bracket_idx) = bracket_idx {
133        Some(parse_index(&s[bracket_idx..])?)
134    } else {
135        None
136    };
137
138    Ok((name, idx))
139}
140
141fn parse_index(s: &str) -> ParseResult<usize> {
142    if !s.starts_with('[') || !s.ends_with(']') {
143        return Err(ParseError);
144    }
145
146    let idx = &s[1..s.len() - 1];
147
148    if !idx.chars().any(|char| char.is_ascii_digit()) {
149        return Err(ParseError);
150    }
151
152    idx.parse::<usize>().map_err(|_| ParseError)
153}
154
155#[cfg(test)]
156mod tests {
157    use super::*;
158
159    #[test]
160    fn parse_index_tests() {
161        assert_eq!(parse_index("[0]").unwrap(), 0);
162        assert_eq!(parse_index("[10]").unwrap(), 10);
163        assert_eq!(parse_index("[1243247]").unwrap(), 1243247);
164        assert_eq!(parse_index("[03]").unwrap(), 3);
165
166        assert!(parse_index("3").is_err());
167        assert!(parse_index("[3").is_err());
168        assert!(parse_index("3]").is_err());
169        assert!(parse_index("[[3]]").is_err());
170        assert!(parse_index("[0x3]").is_err());
171        assert!(parse_index("[-3]").is_err());
172    }
173}
graphql_schema_diff/path/parse.rs

graphql_schema_diff/path/
parse.rs
