#![forbid(unsafe_code)]
mod builder;
mod conversion;
mod edit;
mod validation;
use std::{borrow::Borrow, fmt, str::Utf8Error};
use r_dcf_syntax::{Field, Parse, ValueText};
use r_metadata::{
Logical, LogicalParseError, OsType, OsTypeParseError, Priority, PriorityParseError,
RelationList, UrlList, Version, VersionParseError,
};
pub use builder::{BuildError, PackagesBuilder, RecordBuilder};
pub use conversion::RecordConversionError;
pub use edit::EditError;
pub use r_dcf_syntax::{FormatStyle, LineEnding};
pub use validation::{Finding, FindingKind};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Packages {
parse: Parse,
}
impl Packages {
pub fn from_records<R: Borrow<PackageRecord>>(records: impl IntoIterator<Item = R>) -> Self {
Self::builder().records(records).build()
}
pub fn builder() -> PackagesBuilder {
PackagesBuilder::new()
}
pub fn parse(source: &str) -> Self {
Self {
parse: r_dcf_syntax::parse(source),
}
}
pub fn parse_utf8(source: &[u8]) -> Result<Self, Utf8Error> {
std::str::from_utf8(source).map(Self::parse)
}
pub fn len(&self) -> usize {
self.parse.records().count()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn records(&self) -> impl Iterator<Item = PackageRecord> {
self.parse.records().map(|record| PackageRecord { record })
}
pub fn record(&self, index: usize) -> Option<PackageRecord> {
self.records().nth(index)
}
}
impl fmt::Display for Packages {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.parse, formatter)
}
}
pub fn parse(source: &str) -> Packages {
Packages::parse(source)
}
pub fn parse_utf8(source: &[u8]) -> Result<Packages, Utf8Error> {
Packages::parse_utf8(source)
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PackageRecord {
record: r_dcf_syntax::Record,
}
impl fmt::Display for PackageRecord {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.record, formatter)
}
}
impl PackageRecord {
pub fn builder(package: &str, version: &str) -> Result<RecordBuilder, BuildError> {
RecordBuilder::new(package, version)
}
pub fn field(&self, name: &str) -> Option<ValueText> {
self.record.last_field(name).map(|field| field.value())
}
pub fn fields<'a>(&'a self, name: &'a str) -> impl Iterator<Item = ValueText> + 'a {
self.record.fields_named(name).map(|field| field.value())
}
pub fn all_fields(&self) -> impl Iterator<Item = Field> + '_ {
self.record.fields()
}
pub fn parsed_version(&self) -> Option<Result<Version, VersionParseError>> {
self.field("Version").map(|value| value.as_str().parse())
}
pub fn relations(&self, name: &str) -> Option<RelationList> {
self.field(name)
.map(|value| RelationList::parse(value.as_str()))
}
pub fn logical(&self, name: &str) -> Option<Result<Logical, LogicalParseError>> {
self.field(name).map(|value| value.as_str().parse())
}
pub fn urls(&self, name: &str) -> Option<UrlList> {
self.field(name).map(|value| UrlList::parse(value.as_str()))
}
pub fn parsed_priority(&self) -> Option<Result<Priority, PriorityParseError>> {
self.field("Priority").map(|value| value.as_str().parse())
}
pub fn parsed_os_type(&self) -> Option<Result<OsType, OsTypeParseError>> {
self.field("OS_type").map(|value| value.as_str().parse())
}
pub fn parsed_depends(&self) -> Option<RelationList> {
self.relations("Depends")
}
pub fn parsed_imports(&self) -> Option<RelationList> {
self.relations("Imports")
}
pub fn parsed_suggests(&self) -> Option<RelationList> {
self.relations("Suggests")
}
pub fn parsed_enhances(&self) -> Option<RelationList> {
self.relations("Enhances")
}
pub fn parsed_linking_to(&self) -> Option<RelationList> {
self.relations("LinkingTo")
}
pub fn parsed_needs_compilation(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("NeedsCompilation")
}
pub fn parsed_license_is_foss(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("License_is_FOSS")
}
pub fn parsed_license_restricts_use(&self) -> Option<Result<Logical, LogicalParseError>> {
self.logical("License_restricts_use")
}
pub fn parsed_url(&self) -> Option<UrlList> {
self.urls("URL")
}
}
macro_rules! raw_accessors {
($(($method:ident, $name:literal)),+ $(,)?) => {
impl PackageRecord {
$(
#[doc = concat!("Returns the last raw `", $name, "` value.")]
pub fn $method(&self) -> Option<ValueText> {
self.field($name)
}
)+
}
};
}
raw_accessors!(
(package, "Package"),
(version, "Version"),
(priority, "Priority"),
(depends, "Depends"),
(imports, "Imports"),
(suggests, "Suggests"),
(enhances, "Enhances"),
(linking_to, "LinkingTo"),
(license, "License"),
(license_is_foss, "License_is_FOSS"),
(license_restricts_use, "License_restricts_use"),
(os_type, "OS_type"),
(archs, "Archs"),
(md5sum, "MD5sum"),
(needs_compilation, "NeedsCompilation"),
(built, "Built"),
(repository, "Repository"),
(path, "Path"),
(file, "File"),
(packaged, "Packaged"),
(date_publication, "Date/Publication"),
(title, "Title"),
(description, "Description"),
(author, "Author"),
(authors_at_r, "Authors@R"),
(maintainer, "Maintainer"),
(url, "URL"),
(bug_reports, "BugReports"),
(encoding, "Encoding"),
(roxygen_note, "RoxygenNote"),
(system_requirements, "SystemRequirements"),
(additional_repositories, "Additional_repositories")
);
#[cfg(test)]
mod tests;