use super::super::{Caches, Reader, WorkspaceOf, package_directory_index, workspace_of};
use super::{BindingLoad, Hint, LockedBinding, failure, native, recover};
use crate::meter::{ItemAdmission, Meter};
use crate::{
CommittedGitTree, DependencyDeclaration, LoadError, LoadOptions, LockedCatalog,
LockedPackageId, LockedSource, LockedSourceKind, PackageId, RegistryIndex, RelPath, Tree,
Workspace,
};
use purrdf_lex::allocation::Memory;
fn iri_failure(manifest: &RelPath, error: purrdf_iri::IriReadError) -> LoadError {
match error {
purrdf_iri::IriReadError::Storage(error) => native(error),
purrdf_iri::IriReadError::Lexical(error) => failure(manifest, &error.to_string()),
}
}
fn manifest_image(
tree: &dyn Tree,
manifest: &RelPath,
meter: &Meter,
) -> Result<RelPath, LoadError> {
if !manifest.segments().any(|segment| segment == "..") {
return Ok(manifest.clone());
}
directory_prefixes(tree, manifest, meter)?;
meter.work(
manifest
.as_str()
.len()
.saturating_mul(64)
.saturating_add(128),
manifest,
None,
)?;
let mut admission = ItemAdmission::new(meter, manifest);
let result = (|| {
let mut memory = Memory::new(&mut admission);
let encoded = purrdf_lex::percent::encode_with_memory(
manifest.as_str(),
purrdf_lex::percent::UNRESERVED_SLASH,
&mut memory,
)
.map_err(native)?;
let base = purrdf_iri::parse_with_memory("https://reference.invalid/", &mut memory)
.map_err(|error| iri_failure(manifest, error))?;
let resolved = base
.resolve_with_memory(&encoded, &mut memory)
.map_err(|error| iri_failure(manifest, error))?;
let path = resolved
.path()
.strip_prefix('/')
.ok_or_else(|| failure(manifest, "native manifest image lost its source root"))?;
meter.items(
crate::cost::shared_text(path.len()).saturating_mul(2),
manifest,
None,
)?;
let decoded = purrdf_lex::percent::decode(path)
.map_err(|error| failure(manifest, &error.to_string()))?;
RelPath::new(&decoded)
.map(|path| path.in_source(manifest.authority()))
.map_err(|error| failure(manifest, &error.to_string()))
})();
let image = result.map_err(|error| recover(error, &mut admission))?;
let identity = |path: &RelPath| {
tree.identity(path)
.map_err(|error| LoadError::tree(path, None, &crate::error::Origin::Discovery, error))
};
if identity(manifest)? != identity(&image)? {
return Err(failure(
manifest,
"parent path and native source-relative image name different files; supply an explicit manifest locator",
));
}
Ok(image)
}
fn directory_prefixes(tree: &dyn Tree, manifest: &RelPath, meter: &Meter) -> Result<(), LoadError> {
let directory = manifest
.parent()
.ok_or_else(|| failure(manifest, "manifest has no source directory"))?;
let mut prefix = manifest.source_root();
for segment in directory.segments() {
let bytes = prefix
.as_str()
.len()
.saturating_add(segment.len())
.saturating_add(1);
meter.work(bytes.saturating_mul(2), manifest, None)?;
meter.items(crate::cost::shared_text(bytes), manifest, None)?;
prefix = prefix
.join(segment)
.map_err(|error| failure(manifest, &error.to_string()))?;
match tree.entry(&prefix).map_err(|error| {
LoadError::tree(&prefix, None, &crate::error::Origin::Discovery, error)
})? {
Some(crate::EntryKind::Dir) => {}
Some(crate::EntryKind::Symlink) => {
return Err(failure(
&prefix,
"parent traversal crosses a directory symlink; supply an explicit manifest locator",
));
}
_ => {
return Err(failure(
&prefix,
"original manifest directory prefix is not a real directory",
));
}
}
}
Ok(())
}
pub struct ReferenceRequest<'a> {
catalog: &'a LockedCatalog,
owner: LockedPackageId,
declaration: &'a DependencyDeclaration,
registry: Option<RegistryIndex<'a>>,
}
impl<'a> ReferenceRequest<'a> {
#[must_use]
pub const fn new(
catalog: &'a LockedCatalog,
owner: LockedPackageId,
declaration: &'a DependencyDeclaration,
) -> Self {
Self {
catalog,
owner,
declaration,
registry: None,
}
}
#[must_use]
pub const fn registry(mut self, registry: RegistryIndex<'a>) -> Self {
self.registry = Some(registry);
self
}
pub fn select(&self, options: &LoadOptions) -> Result<LockedPackageId, LoadError> {
self.select_with_usage(options).map(|(row, _)| row)
}
pub fn select_with_usage(
&self,
options: &LoadOptions,
) -> Result<(LockedPackageId, crate::Usage), LoadError> {
let meter = Meter::new(options);
let row = self.select_under(&meter, &RelPath::root())?;
Ok((row, meter.usage()))
}
fn select_under(
&self,
meter: &Meter,
manifest: &RelPath,
) -> Result<LockedPackageId, LoadError> {
meter.items(self.catalog.usage().item_bytes, manifest, None)?;
self.catalog
.select_under(self.owner, self.declaration, self.registry, meter)
}
}
pub struct ReferenceObservation {
workspace: Workspace,
identity: LockedBinding,
checksum: Option<[u8; 32]>,
}
fn declared_version(
tree: &dyn Tree,
meter: &Meter,
discovered: &crate::discovery::Discovered,
manifest: &RelPath,
) -> Result<Option<String>, LoadError> {
let found = &discovered.packages[0];
let dirs = package_directory_index(&discovered.packages, meter)?;
let reader = Reader {
tree,
meter,
dirs: &dirs,
found: &discovered.packages,
};
Ok(match &found.declared.version {
crate::manifest::VersionDecl::Explicit(version) => Some(version.clone()),
crate::manifest::VersionDecl::Inherited => {
match workspace_of(&reader, &found.package.dir, &mut Caches::default())? {
WorkspaceOf::Member {
version: Some(version),
..
} => Some(version.as_str().to_owned()),
_ => {
return Err(failure(
manifest,
"local package version has no admitted workspace value",
));
}
}
}
crate::manifest::VersionDecl::Unset => None,
})
}
impl ReferenceObservation {
pub fn local_root(
catalog: &LockedCatalog,
tree: &dyn Tree,
manifest: &RelPath,
options: &LoadOptions,
) -> Result<Self, LoadError> {
let meter = Meter::new(options);
meter.items(catalog.usage().item_bytes, manifest, None)?;
let image = manifest_image(tree, manifest, &meter)?;
let discovered = crate::discovery::single(tree, &image, &meter)?;
let found = &discovered.packages[0];
let version = declared_version(tree, &meter, &discovered, manifest)?.ok_or_else(|| {
failure(
manifest,
"local package needs explicit or inherited version evidence",
)
})?;
let version = version.as_str();
let mut selected = None;
for row in catalog.packages() {
let comparison = row
.name()
.len()
.saturating_add(found.declared.name.len())
.saturating_add(row.version().len())
.saturating_add(version.len())
.saturating_add(1);
meter.work(comparison, manifest, None)?;
if row.source().is_some()
|| row.name() != found.declared.name
|| row.version() != version
{
continue;
}
if selected.replace(row.id()).is_some() {
return Err(failure(
manifest,
"actual local manifest matches multiple lock rows",
));
}
}
let row = selected.ok_or_else(|| {
failure(
manifest,
"actual local manifest name/version has no matching lock row",
)
})?;
Self::observe_discovered(catalog, row, tree, &meter, &discovered)
}
pub fn load(
request: &ReferenceRequest<'_>,
tree: &dyn Tree,
manifest: &RelPath,
options: &LoadOptions,
) -> Result<Self, LoadError> {
let meter = Meter::new(options);
let row = request.select_under(&meter, manifest)?;
if request
.catalog
.package(row)
.and_then(|row| row.source())
.is_some_and(|source| source.kind() == LockedSourceKind::Git)
{
return Err(failure(
manifest,
"a Git reference requires its sealed committed Tree",
));
}
Self::observe(request.catalog, row, tree, manifest, &meter)
}
pub fn committed(
request: &ReferenceRequest<'_>,
tree: &CommittedGitTree<'_>,
manifest: &RelPath,
options: &LoadOptions,
) -> Result<Self, LoadError> {
let meter = Meter::new(options);
let row = request.select_under(&meter, manifest)?;
if request.catalog.package(row).and_then(|row| row.source()) != Some(tree.source()) {
return Err(failure(
manifest,
"committed reference source differs from its selected lock row",
));
}
let observed = tree.under_meter(&meter)?;
Self::observe(request.catalog, row, &observed, manifest, &meter)
}
fn observe(
catalog: &LockedCatalog,
row: LockedPackageId,
tree: &dyn Tree,
manifest: &RelPath,
meter: &Meter,
) -> Result<Self, LoadError> {
let image = manifest_image(tree, manifest, meter)?;
let discovered = crate::discovery::single(tree, &image, meter)?;
Self::observe_discovered(catalog, row, tree, meter, &discovered)
}
fn observe_discovered(
catalog: &LockedCatalog,
row: LockedPackageId,
tree: &dyn Tree,
meter: &Meter,
discovered: &crate::discovery::Discovered,
) -> Result<Self, LoadError> {
let manifest = discovered.packages[0].package.manifest.clone();
let options = meter.options();
meter.items(crate::index::LOAD_BASE_BYTES, &manifest, None)?;
let mut admission = ItemAdmission::new(meter, &manifest);
let mut hints = Vec::new();
Memory::new(&mut admission)
.push(
&mut hints,
Hint {
row,
manifest: manifest.clone(),
edges: &[],
configuration: None,
},
)
.map_err(|error| admission.error(error))?;
let binding = BindingLoad {
catalog,
hints,
purpose: super::Purpose::Configured,
};
let mut workspace =
Workspace::build_discovered(tree, options, meter, Some(&binding), discovered)?;
let identity = workspace.locked.pop().ok_or_else(|| {
failure(
&manifest,
"reference manifest has no validated package identity",
)
})?;
if !workspace.locked.is_empty() || workspace.packages.len() != 1 {
return Err(failure(
&manifest,
"a reference observation must select exactly one package",
));
}
let checksum = catalog.package(row).and_then(|row| row.checksum()).copied();
Ok(Self {
workspace,
identity,
checksum,
})
}
#[must_use]
pub const fn workspace(&self) -> &Workspace {
&self.workspace
}
#[must_use]
pub const fn package(&self) -> PackageId {
PackageId(0)
}
#[must_use]
pub const fn row(&self) -> LockedPackageId {
self.identity.row
}
#[must_use]
pub fn name(&self) -> &str {
&self.identity.name
}
#[must_use]
pub fn version(&self) -> &str {
&self.identity.version
}
#[must_use]
pub const fn source(&self) -> Option<&LockedSource> {
self.identity.source.as_ref()
}
#[must_use]
pub const fn checksum(&self) -> Option<&[u8; 32]> {
self.checksum.as_ref()
}
}