use std::str::FromStr;
use r_metadata::{
AdditionalRepositories, Logical, LogicalParseError, OsType, OsTypeParseError,
PositionedRelationParseError, PositionedRemoteParseError, PositionedUrlParseError, Priority,
PriorityParseError, Relation, RelationList, Remote, RemoteList, Span, Spanned, Url, UrlList,
Version, VersionParseError,
};
use crate::{Description, SourceSpan};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CollectionEntry<T> {
pub value: T,
pub field_span: SourceSpan,
pub value_span: Span,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CollectionIssue<E> {
pub error: E,
pub field_span: SourceSpan,
pub value_span: Span,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CollectionResult<T, E> {
entries: Vec<CollectionEntry<T>>,
issues: Vec<CollectionIssue<E>>,
}
impl<T, E> Default for CollectionResult<T, E> {
fn default() -> Self {
Self {
entries: Vec::new(),
issues: Vec::new(),
}
}
}
impl<T, E> CollectionResult<T, E> {
pub fn entries(&self) -> &[CollectionEntry<T>] {
&self.entries
}
pub fn values(&self) -> impl ExactSizeIterator<Item = &T> + DoubleEndedIterator {
self.entries.iter().map(|entry| &entry.value)
}
pub fn issues(&self) -> &[CollectionIssue<E>] {
&self.issues
}
pub fn into_parts(self) -> (Vec<CollectionEntry<T>>, Vec<CollectionIssue<E>>) {
(self.entries, self.issues)
}
}
impl Description {
pub fn version_parsed(&self) -> Option<Result<Version, VersionParseError>> {
self.version()
.map(|value| Version::from_str(value.as_str()))
}
pub fn depends_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
self.relations("Depends")
}
pub fn imports_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
self.relations("Imports")
}
pub fn suggests_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
self.relations("Suggests")
}
pub fn enhances_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
self.relations("Enhances")
}
pub fn linking_to_parsed(&self) -> CollectionResult<Relation, PositionedRelationParseError> {
self.relations("LinkingTo")
}
pub fn vignette_builder_parsed(
&self,
) -> CollectionResult<Relation, PositionedRelationParseError> {
self.relations("VignetteBuilder")
}
pub fn urls_parsed(&self) -> CollectionResult<Url, PositionedUrlParseError> {
self.urls("URL", false)
}
pub fn bug_reports_parsed(&self) -> CollectionResult<Url, PositionedUrlParseError> {
self.urls("BugReports", false)
}
pub fn additional_repositories_parsed(&self) -> CollectionResult<Url, PositionedUrlParseError> {
self.urls("Additional_repositories", true)
}
pub fn remotes_parsed(&self) -> CollectionResult<Remote, PositionedRemoteParseError> {
let mut result = CollectionResult::default();
for field in self.fields("Remotes") {
let span = field.source_range();
let (entries, issues) = RemoteList::parse(field.value().as_str()).into_parts();
append_entries(&mut result.entries, entries, span);
result
.issues
.extend(issues.into_iter().map(|error| CollectionIssue {
value_span: error.span(),
error,
field_span: span,
}));
}
result
}
pub fn needs_compilation_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("NeedsCompilation")
}
pub fn biarch_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("Biarch")
}
pub fn lazy_data_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("LazyData")
}
pub fn lazy_load_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("LazyLoad")
}
pub fn byte_compile_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("ByteCompile")
}
pub fn keep_source_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("KeepSource")
}
pub fn use_lto_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("UseLTO")
}
pub fn staged_install_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("StagedInstall")
}
pub fn zip_data_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("ZipData")
}
pub fn build_vignettes_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("BuildVignettes")
}
pub fn license_is_foss_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("License_is_FOSS")
}
pub fn license_restricts_use_parsed(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("License_restricts_use")
}
pub fn os_type_parsed(&self) -> Option<Result<OsType, OsTypeParseError>> {
self.os_type().map(|value| value.as_str().parse())
}
pub fn priority_parsed(&self) -> Option<Result<Priority, PriorityParseError>> {
self.priority().map(|value| value.as_str().parse())
}
fn logical(&self, name: &str) -> Option<Result<Logical, LogicalParseError>> {
self.raw(name).map(|value| value.as_str().parse())
}
fn relations(&self, name: &str) -> CollectionResult<Relation, PositionedRelationParseError> {
let mut result = CollectionResult::default();
for field in self.fields(name) {
let span = field.source_range();
let (entries, issues) = RelationList::parse(field.value().as_str()).into_parts();
append_entries(&mut result.entries, entries, span);
result
.issues
.extend(issues.into_iter().map(|error| CollectionIssue {
value_span: error.span(),
error,
field_span: span,
}));
}
result
}
fn urls(
&self,
name: &str,
repositories: bool,
) -> CollectionResult<Url, PositionedUrlParseError> {
let mut result = CollectionResult::default();
for field in self.fields(name) {
let span = field.source_range();
let (entries, issues) = if repositories {
AdditionalRepositories::parse(field.value().as_str()).into_parts()
} else {
UrlList::parse(field.value().as_str()).into_parts()
};
append_entries(&mut result.entries, entries, span);
result
.issues
.extend(issues.into_iter().map(|error| CollectionIssue {
value_span: error.span(),
error,
field_span: span,
}));
}
result
}
}
fn append_entries<T>(
target: &mut Vec<CollectionEntry<T>>,
entries: Vec<Spanned<T>>,
span: SourceSpan,
) {
target.extend(entries.into_iter().map(|entry| CollectionEntry {
value: entry.value,
value_span: entry.span,
field_span: span,
}));
}