use std::{error::Error, fmt};
use r_dcf_syntax::{FieldName, InvalidFieldName, InvalidLogicalValue, LogicalValue, make};
use r_metadata::{Version, VersionParseError};
use crate::{FormatStyle, Packages, validation::valid_package_name};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum BuildError {
FieldName(InvalidFieldName),
Value(InvalidLogicalValue),
PackageName,
Version(VersionParseError),
}
impl fmt::Display for BuildError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::FieldName(error) => error.fmt(formatter),
Self::Value(error) => error.fmt(formatter),
Self::PackageName => formatter.write_str("invalid package name"),
Self::Version(error) => error.fmt(formatter),
}
}
}
impl Error for BuildError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::FieldName(error) => Some(error),
Self::Value(error) => Some(error),
Self::Version(error) => Some(error),
Self::PackageName => None,
}
}
}
#[derive(Debug, Clone)]
pub struct RecordBuilder {
fields: Vec<(FieldName, LogicalValue)>,
}
impl RecordBuilder {
pub fn new(package: &str, version: &str) -> Result<Self, BuildError> {
if !valid_package_name(package) {
return Err(BuildError::PackageName);
}
let version: Version = version.parse().map_err(BuildError::Version)?;
let mut builder = Self { fields: Vec::new() };
builder.push_valid("Package", package)?;
builder.push_valid("Version", version.as_str())?;
Ok(builder)
}
pub fn field(mut self, name: &str, value: &str) -> Result<Self, BuildError> {
self.push_valid(name, value)?;
Ok(self)
}
fn push_valid(&mut self, name: &str, value: &str) -> Result<(), BuildError> {
let name = FieldName::new(name).map_err(BuildError::FieldName)?;
let value = LogicalValue::new(value).map_err(BuildError::Value)?;
self.fields.push((name, value));
Ok(())
}
pub(crate) fn render(&self, style: &FormatStyle) -> String {
let style = clean_style(style);
let fields = self
.fields
.iter()
.map(|(name, value)| make::field(name, value, &style))
.collect::<Vec<_>>();
make::record(&fields, &style)
}
}
#[derive(Debug, Clone, Default)]
pub struct PackagesBuilder {
records: Vec<RecordBuilder>,
style: FormatStyle,
}
impl PackagesBuilder {
pub fn new() -> Self {
Self::default()
}
pub fn format_style(mut self, style: FormatStyle) -> Self {
self.style = style;
self
}
pub fn record(mut self, record: RecordBuilder) -> Self {
self.records.push(record);
self
}
pub fn build(self) -> Packages {
let style = clean_style(&self.style);
let records = self
.records
.iter()
.map(|record| record.render(&style))
.collect::<Vec<_>>();
Packages::parse(&make::document(&records, &style))
}
}
fn clean_style(style: &FormatStyle) -> FormatStyle {
let mut style = style.clone();
if style.continuation_indent.is_empty()
|| !style
.continuation_indent
.bytes()
.all(|byte| matches!(byte, b' ' | b'\t'))
{
" ".clone_into(&mut style.continuation_indent);
}
style
}