Skip to main content

r_description/
typed.rs

1//! Field-local semantic parsing.
2
3use 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/// One valid collection entry, retaining its declaration and relative spans.
15#[derive(Debug, Clone, PartialEq, Eq)]
16pub struct CollectionEntry<T> {
17    /// Parsed value.
18    pub value: T,
19    /// Span of the complete DCF field declaration.
20    pub field_span: SourceSpan,
21    /// Span relative to the unfolded field value.
22    pub value_span: Span,
23}
24
25/// One collection issue, retaining its declaration and relative spans.
26#[derive(Debug, Clone, PartialEq, Eq)]
27pub struct CollectionIssue<E> {
28    /// Typed parser issue.
29    pub error: E,
30    /// Span of the complete DCF field declaration.
31    pub field_span: SourceSpan,
32    /// Span relative to the unfolded field value.
33    pub value_span: Span,
34}
35
36/// Recovered semantic values merged from duplicate declarations.
37#[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    /// Returns valid entries in declaration and entry source order.
54    pub fn entries(&self) -> &[CollectionEntry<T>] {
55        &self.entries
56    }
57    /// Iterates over parsed values without hiding the separately retained issues.
58    pub fn values(&self) -> impl ExactSizeIterator<Item = &T> + DoubleEndedIterator {
59        self.entries.iter().map(|entry| &entry.value)
60    }
61    /// Returns issues in declaration and issue source order.
62    pub fn issues(&self) -> &[CollectionIssue<E>] {
63        &self.issues
64    }
65    /// Splits the aggregate into valid entries and issues.
66    pub fn into_parts(self) -> (Vec<CollectionEntry<T>>, Vec<CollectionIssue<E>>) {
67        (self.entries, self.issues)
68    }
69}
70
71impl Description {
72    /// Parses the last `Version` declaration.
73    pub fn version_parsed(&self) -> Option<Result<Version, VersionParseError>> {
74        self.version()
75            .map(|value| Version::from_str(value.as_str()))
76    }
77
78    /// Parses and merges all `Depends` declarations.
79    pub fn depends_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
80        self.relations("Depends")
81    }
82    /// Parses and merges all `Imports` declarations.
83    pub fn imports_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
84        self.relations("Imports")
85    }
86    /// Parses and merges all `Suggests` declarations.
87    pub fn suggests_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
88        self.relations("Suggests")
89    }
90    /// Parses and merges all `Enhances` declarations.
91    pub fn enhances_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
92        self.relations("Enhances")
93    }
94    /// Parses and merges all `LinkingTo` declarations.
95    pub fn linking_to_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
96        self.relations("LinkingTo")
97    }
98    /// Parses and merges all `VignetteBuilder` declarations.
99    pub fn vignette_builder_parsed(
100        &self,
101    ) -> CollectionResult<Relation, PositionedRelationParseError> {
102        self.relations("VignetteBuilder")
103    }
104
105    /// Parses and merges all `URL` declarations.
106    pub fn urls_parsed(&self) -> CollectionResult<Url, PositionedUrlParseError> {
107        self.urls("URL", false)
108    }
109    /// Parses and merges all `BugReports` declarations.
110    pub fn bug_reports_parsed(&self) -> CollectionResult<Url, PositionedUrlParseError> {
111        self.urls("BugReports", false)
112    }
113    /// Parses and merges all `Additional_repositories` declarations.
114    pub fn additional_repositories_parsed(&self) -> CollectionResult<Url, PositionedUrlParseError> {
115        self.urls("Additional_repositories", true)
116    }
117    /// Parses and merges all `Remotes` declarations.
118    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    /// Parses the last `NeedsCompilation` declaration.
136    pub fn needs_compilation_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
137        self.logical("NeedsCompilation")
138    }
139    /// Parses the last `Biarch` declaration.
140    pub fn biarch_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
141        self.logical("Biarch")
142    }
143    /// Parses the last `LazyData` declaration.
144    pub fn lazy_data_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
145        self.logical("LazyData")
146    }
147    /// Parses the last `LazyLoad` declaration.
148    pub fn lazy_load_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
149        self.logical("LazyLoad")
150    }
151    /// Parses the last `ByteCompile` declaration.
152    pub fn byte_compile_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
153        self.logical("ByteCompile")
154    }
155    /// Parses the last `KeepSource` declaration.
156    pub fn keep_source_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
157        self.logical("KeepSource")
158    }
159    /// Parses the last `UseLTO` declaration.
160    pub fn use_lto_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
161        self.logical("UseLTO")
162    }
163    /// Parses the last `StagedInstall` declaration.
164    pub fn staged_install_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
165        self.logical("StagedInstall")
166    }
167    /// Parses the last `ZipData` declaration.
168    pub fn zip_data_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
169        self.logical("ZipData")
170    }
171    /// Parses the last `BuildVignettes` declaration.
172    pub fn build_vignettes_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
173        self.logical("BuildVignettes")
174    }
175    /// Parses the last `License_is_FOSS` declaration.
176    pub fn license_is_foss_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
177        self.logical("License_is_FOSS")
178    }
179    /// Parses the last `License_restricts_use` declaration.
180    pub fn license_restricts_use_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
181        self.logical("License_restricts_use")
182    }
183    /// Parses the last `OS_type` declaration.
184    pub fn os_type_parsed(&self) -> Option<Result<OsType, OsTypeParseError>> {
185        self.os_type().map(|value| value.as_str().parse())
186    }
187    /// Parses the last `Priority` declaration.
188    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}