1use crate::{Span, Spanned, Url};
4
5pub type SpannedUrl = Spanned<Url>;
7
8#[derive(Debug, Clone, PartialEq, Eq, Default)]
10pub struct UrlList {
11 entries: Vec<SpannedUrl>,
12 issues: Vec<PositionedUrlParseError>,
13}
14
15impl UrlList {
16 pub fn parse(input: &str) -> Self {
18 parse_urls(input, true).into()
19 }
20 pub fn entries(&self) -> &[SpannedUrl] {
22 &self.entries
23 }
24 pub fn issues(&self) -> &[PositionedUrlParseError] {
26 &self.issues
27 }
28 pub fn into_parts(self) -> (Vec<SpannedUrl>, Vec<PositionedUrlParseError>) {
30 (self.entries, self.issues)
31 }
32}
33
34#[derive(Debug, Clone, PartialEq, Eq, Default)]
36pub struct AdditionalRepositories {
37 entries: Vec<SpannedUrl>,
38 issues: Vec<PositionedUrlParseError>,
39}
40
41impl AdditionalRepositories {
42 pub fn parse(input: &str) -> Self {
44 parse_urls(input, false).into()
45 }
46 pub fn entries(&self) -> &[SpannedUrl] {
48 &self.entries
49 }
50 pub fn issues(&self) -> &[PositionedUrlParseError] {
52 &self.issues
53 }
54 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#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
73pub enum UrlParseError {
74 #[error("empty URL entry")]
76 Empty,
77 #[error("repository URLs must be separated by commas")]
79 UnexpectedWhitespace,
80 #[error("URL contains a control character")]
82 ControlCharacter,
83 #[error("invalid URL: {0}")]
85 Invalid(#[source] url::ParseError),
86}
87
88#[derive(Debug, Clone, PartialEq, Eq)]
90pub struct PositionedUrlParseError {
91 error: UrlParseError,
92 span: Span,
93}
94impl PositionedUrlParseError {
95 pub const fn error(&self) -> &UrlParseError {
97 &self.error
98 }
99 pub const fn span(&self) -> Span {
101 self.span
102 }
103 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}