mod read;
mod select;
mod source;
use std::fmt;
use purrdf_lex::allocation::{Admission, Memory, StorageError};
use crate::cost::shared_text;
use crate::meter::{ItemAdmission, Meter};
use crate::{LoadError, LoadErrorKind, LoadOptions, Origin, RelPath, Tree, Usage};
pub use source::{LockedGitReference, LockedSource, LockedSourceKind};
#[derive(Debug, Clone, Copy)]
pub struct RegistryIndex<'a> {
pub(crate) name: Option<&'a str>,
pub(crate) source: &'a str,
}
impl<'a> RegistryIndex<'a> {
#[must_use]
pub const fn new(name: Option<&'a str>, source: &'a str) -> Self {
Self { name, source }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct LockedPackageId(pub(crate) usize);
impl LockedPackageId {
#[must_use]
pub const fn index(self) -> usize {
self.0
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct LockedPackage {
id: LockedPackageId,
name: String,
version: String,
source: Option<LockedSource>,
checksum: Option<[u8; 32]>,
dependencies: Vec<LockedPackageId>,
}
impl LockedPackage {
#[must_use]
pub const fn id(&self) -> LockedPackageId {
self.id
}
#[must_use]
pub fn name(&self) -> &str {
&self.name
}
#[must_use]
pub fn version(&self) -> &str {
&self.version
}
#[must_use]
pub const fn source(&self) -> Option<&LockedSource> {
self.source.as_ref()
}
#[must_use]
pub const fn checksum(&self) -> Option<&[u8; 32]> {
self.checksum.as_ref()
}
#[must_use]
pub fn dependencies(&self) -> &[LockedPackageId] {
&self.dependencies
}
fn key(&self) -> (&str, &str, Option<&LockedSource>) {
(&self.name, &self.version, self.source.as_ref())
}
}
#[derive(Debug)]
pub struct LockedCatalog {
path: RelPath,
packages: Vec<LockedPackage>,
order: Vec<LockedPackageId>,
usage: Usage,
}
impl PartialEq for LockedCatalog {
fn eq(&self, other: &Self) -> bool {
self.path == other.path && self.packages == other.packages && self.order == other.order
}
}
impl Eq for LockedCatalog {}
impl LockedCatalog {
pub fn load(tree: &dyn Tree, path: &RelPath, options: &LoadOptions) -> Result<Self, LoadError> {
let meter = Meter::new(options);
let text = tree
.read(path, options.max_file_bytes)
.map_err(|error| LoadError::tree(path, None, &Origin::Discovery, error))?;
meter.read(path, &text)?;
meter.items(
size_of::<Self>() + shared_text(path.as_str().len()),
path,
None,
)?;
let mut admission = ItemAdmission::new(&meter, path);
let result = {
let mut memory = Memory::new(&mut admission);
read::catalog(&text, &mut memory, &meter, path)
};
let (packages, order) = result.map_err(|error| match error {
BuildError::Storage(error) => admission.error(error),
BuildError::Load(error) => error,
BuildError::Invalid {
field,
message,
source,
} => LoadError::new(
path,
None,
LoadErrorKind::Locked {
field,
message,
source,
},
),
})?;
Ok(Self {
path: path.clone(),
packages,
order,
usage: meter.usage(),
})
}
pub fn packages(&self) -> impl Iterator<Item = &LockedPackage> {
self.packages.iter()
}
#[must_use]
pub fn package(&self, id: LockedPackageId) -> Option<&LockedPackage> {
self.packages.get(id.index())
}
pub fn select_dependency(
&self,
owner: LockedPackageId,
declaration: &crate::DependencyDeclaration,
registry: Option<RegistryIndex<'_>>,
options: &LoadOptions,
) -> Result<LockedPackageId, LoadError> {
let meter = Meter::new(options);
meter.items(self.usage.item_bytes, &self.path, None)?;
self.select_under(owner, declaration, registry, &meter)
}
pub(crate) fn select_under(
&self,
owner: LockedPackageId,
declaration: &crate::DependencyDeclaration,
registry: Option<RegistryIndex<'_>>,
meter: &Meter,
) -> Result<LockedPackageId, LoadError> {
let mut admission = ItemAdmission::new(meter, &self.path);
let result = select::dependency(
self,
owner,
declaration,
registry,
&mut Memory::new(&mut admission),
meter,
);
result.map_err(|error| match error {
BuildError::Storage(error) => admission.error(error),
BuildError::Load(error) => error,
BuildError::Invalid {
field,
message,
source,
} => LoadError::new(
&self.path,
None,
LoadErrorKind::Locked {
field,
message,
source,
},
)
.reached_by(&Origin::ManifestKey {
key: declaration.key.clone(),
}),
})
}
#[must_use]
pub const fn usage(&self) -> Usage {
self.usage
}
}
enum BuildError {
Storage(StorageError),
Load(LoadError),
Invalid {
field: &'static str,
message: String,
source: Option<Box<purrdf_toml::TomlError>>,
},
}
impl From<StorageError> for BuildError {
fn from(error: StorageError) -> Self {
Self::Storage(error)
}
}
impl From<LoadError> for BuildError {
fn from(error: LoadError) -> Self {
Self::Load(error)
}
}
fn invalid<S: Admission + ?Sized>(
memory: &mut Memory<'_, S>,
field: &'static str,
message: fmt::Arguments<'_>,
) -> BuildError {
match memory.format(&message) {
Ok(message) => BuildError::Invalid {
field,
message,
source: None,
},
Err(error) => BuildError::Storage(error),
}
}