use crate::destination::package_bound_to_tree;
use crate::environment::package_matches_environment;
use crate::paths::validate_destination_path;
use crate::resolve::ResolvedProject;
use crate::substitute::substitute_pray_symbols;
use crate::{PrayError, PrayResult};
use std::fs;
use std::path::{Path, PathBuf};
#[derive(Debug, Clone)]
pub struct PlannedProvisionedFile {
pub path: PathBuf,
pub source: PathBuf,
pub package: String,
pub export: String,
}
pub fn planned_provisioned_files(
project: &ResolvedProject,
) -> PrayResult<Vec<PlannedProvisionedFile>> {
let mut planned = Vec::new();
collect_exact_file_bindings(project, &mut planned)?;
for target in &project.manifest.targets {
for folder_root in &target.skills {
let destination_root = project.project_root.join(folder_root);
for package in &project.packages {
if !package.explicit {
continue;
}
if !package_matches_environment(
&package.declaration.groups,
project.environment.as_deref(),
) {
continue;
}
if !package_bound_to_tree(&package.declaration, target) {
continue;
}
collect_legacy_skill_files(project, package, &destination_root, &mut planned)?;
collect_selected_export_files(project, package, &destination_root, &mut planned)?;
}
}
}
planned.sort_by(|left, right| left.path.cmp(&right.path));
planned.dedup_by(|left, right| left.path == right.path);
Ok(planned)
}
pub fn expected_provisioned_bytes(
source: &Path,
symbols: &std::collections::BTreeMap<String, String>,
) -> PrayResult<Vec<u8>> {
let bytes = fs::read(source)?;
match String::from_utf8(bytes) {
Ok(text) => Ok(substitute_pray_symbols(&text, symbols)?.into_bytes()),
Err(error) => Ok(error.into_bytes()),
}
}
fn collect_exact_file_bindings(
project: &ResolvedProject,
planned: &mut Vec<PlannedProvisionedFile>,
) -> PrayResult<()> {
for package in &project.packages {
if !package.explicit {
continue;
}
let Some(destination) = &package.declaration.file else {
continue;
};
if !package_matches_environment(&package.declaration.groups, project.environment.as_deref())
{
continue;
}
let mut matched = false;
for export_name in &package.selected_exports {
let Some(export) = package.spec.exports.get(export_name) else {
continue;
};
if export.kind != "file" {
continue;
}
let source = package.root.join(&export.path);
if !source.is_file() {
return Err(PrayError::Render(format!(
"file export source missing: {}",
source.display()
)));
}
let relative = validate_destination_path(destination)?;
planned.push(PlannedProvisionedFile {
path: relative.as_path().to_path_buf(),
source,
package: package.declaration.name.clone(),
export: export_name.clone(),
});
matched = true;
break;
}
if !matched {
return Err(PrayError::Render(format!(
"package {} has file: \"{}\" but no selected file export",
package.declaration.name, destination
)));
}
}
Ok(())
}
fn relative_project_path(project: &ResolvedProject, absolute: &Path) -> PathBuf {
absolute
.strip_prefix(&project.project_root)
.map(Path::to_path_buf)
.unwrap_or_else(|_| absolute.to_path_buf())
}
fn collect_legacy_skill_files(
project: &ResolvedProject,
package: &crate::resolve::ResolvedPackage,
destination_root: &Path,
planned: &mut Vec<PlannedProvisionedFile>,
) -> PrayResult<()> {
for (skill_name, skill) in &package.spec.skills {
if legacy_skill_covered_by_export(package, skill) {
continue;
}
let skill_files = package.skill_files.get(skill_name).ok_or_else(|| {
PrayError::Render(format!(
"package {} has no indexed files for legacy skill {}",
package.declaration.name, skill_name
))
})?;
collect_tree_files(
project,
&package.root.join(&skill.path),
&destination_root.join(skill_name),
skill_files,
(&[], &[]),
(&package.declaration.name, skill_name),
planned,
)?;
}
Ok(())
}
fn legacy_skill_covered_by_export(
package: &crate::resolve::ResolvedPackage,
skill: &crate::package_spec::PackageSkill,
) -> bool {
package.spec.exports.iter().any(|(export_name, export)| {
package.selected_exports.contains(export_name)
&& matches!(export.kind.as_str(), "folder" | "skill")
&& export.path.trim_end_matches('/') == skill.path.trim_end_matches('/')
})
}
fn collect_selected_export_files(
project: &ResolvedProject,
package: &crate::resolve::ResolvedPackage,
destination_root: &Path,
planned: &mut Vec<PlannedProvisionedFile>,
) -> PrayResult<()> {
for export_name in &package.selected_exports {
let Some(export) = package.spec.exports.get(export_name) else {
continue;
};
match export.kind.as_str() {
"folder" | "skill" => {
let indexed_files = package.skill_files.get(export_name).ok_or_else(|| {
PrayError::Render(format!(
"package {} has no indexed files for folder export {}",
package.declaration.name, export_name
))
})?;
let destination_name = folder_destination_name(export_name, &export.path);
collect_tree_files(
project,
&package.root.join(&export.path),
&destination_root.join(destination_name),
indexed_files,
(&export.only, &export.except),
(&package.declaration.name, export_name),
planned,
)?;
}
"file" => {
if package.declaration.file.is_some() {
continue;
}
let source = package.root.join(&export.path);
if !source.is_file() {
return Err(PrayError::Render(format!(
"file export source missing: {}",
source.display()
)));
}
let file_name =
source
.file_name()
.map(|name| name.to_owned())
.ok_or_else(|| {
PrayError::Render(format!(
"file export path has no file name: {}",
export.path
))
})?;
let destination = destination_root.join(export_name).join(file_name);
planned.push(PlannedProvisionedFile {
path: relative_project_path(project, &destination),
source,
package: package.declaration.name.clone(),
export: export_name.clone(),
});
}
_ => {}
}
}
Ok(())
}
fn folder_destination_name(export_name: &str, export_path: &str) -> String {
Path::new(export_path.trim_end_matches('/'))
.file_name()
.map(|name| name.to_string_lossy().to_string())
.unwrap_or_else(|| export_name.to_string())
}
fn collect_tree_files(
project: &ResolvedProject,
source_root: &Path,
destination_root: &Path,
relative_files: &[String],
filters: (&[String], &[String]),
origin: (&str, &str),
planned: &mut Vec<PlannedProvisionedFile>,
) -> PrayResult<()> {
let (only, except) = filters;
let (package, export) = origin;
if !source_root.is_dir() {
return Err(PrayError::Render(format!(
"folder source directory missing: {}",
source_root.display()
)));
}
if relative_files.is_empty() {
return Err(PrayError::Render(format!(
"no files listed in package manifest for {}",
source_root.display()
)));
}
let mut matched = false;
for relative in relative_files {
if !only.is_empty() && !only.iter().any(|entry| entry == relative) {
continue;
}
if except.iter().any(|entry| entry == relative) {
continue;
}
let source = source_root.join(relative);
if !source.is_file() {
return Err(PrayError::Render(format!(
"provisioned file missing: {}",
source.display()
)));
}
let destination = destination_root.join(relative);
planned.push(PlannedProvisionedFile {
path: relative_project_path(project, &destination),
source,
package: package.to_string(),
export: export.to_string(),
});
matched = true;
}
if !matched && only.is_empty() && except.is_empty() {
return Err(PrayError::Render(format!(
"no files listed in package manifest for {}",
source_root.display()
)));
}
Ok(())
}