Skip to main content

r_metadata/
urls.rs

1//! URL collection values.
2
3use crate::{Span, Spanned, Url};
4
5/// A URL and the span of its source entry.
6pub type SpannedUrl = Spanned<Url>;
7
8/// Recovered `URL` field value, where commas or whitespace delimit entries.
9#[derive(Debug, Clone, PartialEq, Eq, Default)]
10pub struct UrlList {
11    entries: Vec<SpannedUrl>,
12    issues: Vec<PositionedUrlParseError>,
13}
14
15impl UrlList {
16    /// Parses a `URL` value and retains valid entries alongside all issues.
17    pub fn parse(input: &str) -> Self {
18        parse_urls(input, true).into()
19    }
20    /// Returns valid URLs in source order.
21    pub fn entries(&self) -> &[SpannedUrl] {
22        &self.entries
23    }
24    /// Returns positioned issues in source order.
25    pub fn issues(&self) -> &[PositionedUrlParseError] {
26        &self.issues
27    }
28    /// Splits this result into owned valid entries and issues.
29    pub fn into_parts(self) -> (Vec<SpannedUrl>, Vec<PositionedUrlParseError>) {
30        (self.entries, self.issues)
31    }
32}
33
34/// Recovered `Additional_repositories` value, where only commas delimit entries.
35#[derive(Debug, Clone, PartialEq, Eq, Default)]
36pub struct AdditionalRepositories {
37    entries: Vec<SpannedUrl>,
38    issues: Vec<PositionedUrlParseError>,
39}
40
41impl AdditionalRepositories {
42    /// Parses an `Additional_repositories` value.
43    pub fn parse(input: &str) -> Self {
44        parse_urls(input, false).into()
45    }
46    /// Returns valid repository URLs in source order.
47    pub fn entries(&self) -> &[SpannedUrl] {
48        &self.entries
49    }
50    /// Returns positioned issues in source order.
51    pub fn issues(&self) -> &[PositionedUrlParseError] {
52        &self.issues
53    }
54    /// Splits this result into owned valid entries and issues.
55    pub fn into_parts(self) -> (Vec<SpannedUrl>, Vec<PositionedUrlParseError>) {
56        (self.entries, self.issues)
57    }
58}
59
60impl From<(Vec<SpannedUrl>, Vec<PositionedUrlParseError>)> for UrlList {
61    fn from((entries, issues): (Vec<SpannedUrl>, Vec<PositionedUrlParseError>)) -> Self {
62        Self { entries, issues }
63    }
64}
65impl From<(Vec<SpannedUrl>, Vec<PositionedUrlParseError>)> for AdditionalRepositories {
66    fn from((entries, issues): (Vec<SpannedUrl>, Vec<PositionedUrlParseError>)) -> Self {
67        Self { entries, issues }
68    }
69}
70
71/// A URL collection syntax error.
72#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
73pub enum UrlParseError {
74    /// A comma-delimited entry is empty.
75    #[error("empty URL entry")]
76    Empty,
77    /// Whitespace was used where only a comma is permitted.
78    #[error("repository URLs must be separated by commas")]
79    UnexpectedWhitespace,
80    /// A control character occurs in an entry.
81    #[error("URL contains a control character")]
82    ControlCharacter,
83    /// The entry is not an absolute URL.
84    #[error("invalid URL: {0}")]
85    Invalid(#[source] url::ParseError),
86}
87
88/// A URL issue paired with its byte span.
89#[derive(Debug, Clone, PartialEq, Eq)]
90pub struct PositionedUrlParseError {
91    error: UrlParseError,
92    span: Span,
93}
94impl PositionedUrlParseError {
95    /// Returns the typed error.
96    pub const fn error(&self) -> &UrlParseError {
97        &self.error
98    }
99    /// Returns the relative input span.
100    pub const fn span(&self) -> Span {
101        self.span
102    }
103    /// Alias for [`Self::span`].
104    pub const fn range(&self) -> Span {
105        self.span
106    }
107}
108impl std::fmt::Display for PositionedUrlParseError {
109    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
110        self.error.fmt(f)
111    }
112}
113impl std::error::Error for PositionedUrlParseError {
114    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
115        Some(&self.error)
116    }
117}
118
119fn parse_urls(input: &str, whitespace: bool) -> (Vec<SpannedUrl>, Vec<PositionedUrlParseError>) {
120    let mut entries = Vec::new();
121    let mut issues = Vec::new();
122    let mut start = 0;
123    let ends = input
124        .match_indices(',')
125        .map(|(i, _)| i)
126        .chain(std::iter::once(input.len()))
127        .collect::<Vec<_>>();
128    for (index, &end) in ends.iter().enumerate() {
129        if input[start..end].trim().is_empty() && (ends.len() == 1 || index == ends.len() - 1) {
130            break;
131        }
132        if whitespace {
133            parse_ws_segment(input, start, end, &mut entries, &mut issues);
134        } else {
135            parse_comma_segment(input, start, end, &mut entries, &mut issues);
136        }
137        start = end.saturating_add(1);
138    }
139    (entries, issues)
140}
141
142fn parse_ws_segment(
143    input: &str,
144    start: usize,
145    end: usize,
146    entries: &mut Vec<SpannedUrl>,
147    issues: &mut Vec<PositionedUrlParseError>,
148) {
149    let mut token = None;
150    for (offset, character) in input[start..end].char_indices() {
151        let position = start + offset;
152        if character.is_whitespace() {
153            if let Some(token_start) = token.take() {
154                parse_token(input, token_start, position, entries, issues);
155            }
156        } else if token.is_none() {
157            token = Some(position);
158        }
159    }
160    if let Some(token_start) = token {
161        parse_token(input, token_start, end, entries, issues);
162    } else if input[start..end].trim().is_empty() {
163        let point = start + input[start..end].len() - input[start..end].trim_start().len();
164        issues.push(url_issue(UrlParseError::Empty, point, point));
165    }
166}
167
168fn parse_comma_segment(
169    input: &str,
170    start: usize,
171    end: usize,
172    entries: &mut Vec<SpannedUrl>,
173    issues: &mut Vec<PositionedUrlParseError>,
174) {
175    let text = &input[start..end];
176    let left = start + text.len() - text.trim_start().len();
177    let right = end - (text.len() - text.trim_end().len());
178    if left == right {
179        issues.push(url_issue(UrlParseError::Empty, left, left));
180        return;
181    }
182    if let Some((offset, c)) = input[left..right]
183        .char_indices()
184        .find(|(_, c)| c.is_whitespace())
185    {
186        let at = left + offset;
187        issues.push(url_issue(
188            UrlParseError::UnexpectedWhitespace,
189            at,
190            at + c.len_utf8(),
191        ));
192        return;
193    }
194    parse_token(input, left, right, entries, issues);
195}
196
197fn parse_token(
198    input: &str,
199    start: usize,
200    end: usize,
201    entries: &mut Vec<SpannedUrl>,
202    issues: &mut Vec<PositionedUrlParseError>,
203) {
204    if let Some((offset, c)) = input[start..end]
205        .char_indices()
206        .find(|(_, c)| c.is_control())
207    {
208        let at = start + offset;
209        issues.push(url_issue(
210            UrlParseError::ControlCharacter,
211            at,
212            at + c.len_utf8(),
213        ));
214        return;
215    }
216    match Url::parse(&input[start..end]) {
217        Ok(value) => entries.push(Spanned {
218            value,
219            span: Span::new(start, end),
220        }),
221        Err(error) => issues.push(url_issue(UrlParseError::Invalid(error), start, end)),
222    }
223}
224fn url_issue(error: UrlParseError, start: usize, end: usize) -> PositionedUrlParseError {
225    PositionedUrlParseError {
226        error,
227        span: Span::new(start, end),
228    }
229}