1use std::str::FromStr;
4
5use r_metadata::{
6 AdditionalRepositories, Logical, LogicalParseError, OsType, OsTypeParseError,
7 PositionedRelationParseError, PositionedRemoteParseError, PositionedUrlParseError, Priority,
8 PriorityParseError, Relation, RelationList, Remote, RemoteList, Span, Spanned, Url, UrlList,
9 Version, VersionParseError,
10};
11
12use crate::{Description, SourceSpan};
13
14#[derive(Debug, Clone, PartialEq, Eq)]
16pub struct CollectionEntry<T> {
17 pub value: T,
19 pub field_span: SourceSpan,
21 pub value_span: Span,
23}
24
25#[derive(Debug, Clone, PartialEq, Eq)]
27pub struct CollectionIssue<E> {
28 pub error: E,
30 pub field_span: SourceSpan,
32 pub value_span: Span,
34}
35
36#[derive(Debug, Clone, PartialEq, Eq)]
38pub struct CollectionResult<T, E> {
39 entries: Vec<CollectionEntry<T>>,
40 issues: Vec<CollectionIssue<E>>,
41}
42
43impl<T, E> Default for CollectionResult<T, E> {
44 fn default() -> Self {
45 Self {
46 entries: Vec::new(),
47 issues: Vec::new(),
48 }
49 }
50}
51
52impl<T, E> CollectionResult<T, E> {
53 pub fn entries(&self) -> &[CollectionEntry<T>] {
55 &self.entries
56 }
57 pub fn values(&self) -> impl ExactSizeIterator<Item = &T> + DoubleEndedIterator {
59 self.entries.iter().map(|entry| &entry.value)
60 }
61 pub fn issues(&self) -> &[CollectionIssue<E>] {
63 &self.issues
64 }
65 pub fn into_parts(self) -> (Vec<CollectionEntry<T>>, Vec<CollectionIssue<E>>) {
67 (self.entries, self.issues)
68 }
69}
70
71impl Description {
72 pub fn version_parsed(&self) -> Option<Result<Version, VersionParseError>> {
74 self.version()
75 .map(|value| Version::from_str(value.as_str()))
76 }
77
78 pub fn depends_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
80 self.relations("Depends")
81 }
82 pub fn imports_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
84 self.relations("Imports")
85 }
86 pub fn suggests_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
88 self.relations("Suggests")
89 }
90 pub fn enhances_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
92 self.relations("Enhances")
93 }
94 pub fn linking_to_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
96 self.relations("LinkingTo")
97 }
98 pub fn vignette_builder_parsed(
100 &self,
101 ) -> CollectionResult<Relation, PositionedRelationParseError> {
102 self.relations("VignetteBuilder")
103 }
104
105 pub fn urls_parsed(&self) -> CollectionResult<Url, PositionedUrlParseError> {
107 self.urls("URL", false)
108 }
109 pub fn bug_reports_parsed(&self) -> CollectionResult<Url, PositionedUrlParseError> {
111 self.urls("BugReports", false)
112 }
113 pub fn additional_repositories_parsed(&self) -> CollectionResult<Url, PositionedUrlParseError> {
115 self.urls("Additional_repositories", true)
116 }
117 pub fn remotes_parsed(&self) -> CollectionResult<Remote, PositionedRemoteParseError> {
119 let mut result = CollectionResult::default();
120 for field in self.fields("Remotes") {
121 let span = field.source_range();
122 let (entries, issues) = RemoteList::parse(field.value().as_str()).into_parts();
123 append_entries(&mut result.entries, entries, span);
124 result
125 .issues
126 .extend(issues.into_iter().map(|error| CollectionIssue {
127 value_span: error.span(),
128 error,
129 field_span: span,
130 }));
131 }
132 result
133 }
134
135 pub fn needs_compilation_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
137 self.logical("NeedsCompilation")
138 }
139 pub fn biarch_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
141 self.logical("Biarch")
142 }
143 pub fn lazy_data_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
145 self.logical("LazyData")
146 }
147 pub fn lazy_load_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
149 self.logical("LazyLoad")
150 }
151 pub fn byte_compile_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
153 self.logical("ByteCompile")
154 }
155 pub fn keep_source_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
157 self.logical("KeepSource")
158 }
159 pub fn use_lto_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
161 self.logical("UseLTO")
162 }
163 pub fn staged_install_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
165 self.logical("StagedInstall")
166 }
167 pub fn zip_data_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
169 self.logical("ZipData")
170 }
171 pub fn build_vignettes_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
173 self.logical("BuildVignettes")
174 }
175 pub fn license_is_foss_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
177 self.logical("License_is_FOSS")
178 }
179 pub fn license_restricts_use_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
181 self.logical("License_restricts_use")
182 }
183 pub fn os_type_parsed(&self) -> Option<Result<OsType, OsTypeParseError>> {
185 self.os_type().map(|value| value.as_str().parse())
186 }
187 pub fn priority_parsed(&self) -> Option<Result<Priority, PriorityParseError>> {
189 self.priority().map(|value| value.as_str().parse())
190 }
191
192 fn logical(&self, name: &str) -> Option<Result<Logical, LogicalParseError>> {
193 self.raw(name).map(|value| value.as_str().parse())
194 }
195
196 fn relations(&self, name: &str) -> CollectionResult<Relation, PositionedRelationParseError> {
197 let mut result = CollectionResult::default();
198 for field in self.fields(name) {
199 let span = field.source_range();
200 let (entries, issues) = RelationList::parse(field.value().as_str()).into_parts();
201 append_entries(&mut result.entries, entries, span);
202 result
203 .issues
204 .extend(issues.into_iter().map(|error| CollectionIssue {
205 value_span: error.span(),
206 error,
207 field_span: span,
208 }));
209 }
210 result
211 }
212
213 fn urls(
214 &self,
215 name: &str,
216 repositories: bool,
217 ) -> CollectionResult<Url, PositionedUrlParseError> {
218 let mut result = CollectionResult::default();
219 for field in self.fields(name) {
220 let span = field.source_range();
221 let (entries, issues) = if repositories {
222 AdditionalRepositories::parse(field.value().as_str()).into_parts()
223 } else {
224 UrlList::parse(field.value().as_str()).into_parts()
225 };
226 append_entries(&mut result.entries, entries, span);
227 result
228 .issues
229 .extend(issues.into_iter().map(|error| CollectionIssue {
230 value_span: error.span(),
231 error,
232 field_span: span,
233 }));
234 }
235 result
236 }
237}
238
239fn append_entries<T>(
240 target: &mut Vec<CollectionEntry<T>>,
241 entries: Vec<Spanned<T>>,
242 span: SourceSpan,
243) {
244 target.extend(entries.into_iter().map(|entry| CollectionEntry {
245 value: entry.value,
246 value_span: entry.span,
247 field_span: span,
248 }));
249}