use std::io;
use crate::{
build::BuildBehaviour,
config::Config,
lockfile::{
LockedPackage, LockedPackageLockType, Lockfile, PinnedState, ReadOnly, ReadWrite,
WorkspaceLockfile,
},
lua_version::{LuaVersion, LuaVersionUnset},
package::{PackageReq, RockConstraintUnsatisfied},
package_db::{PackageDB, PackageDBError},
remote_package_source::RemotePackageSource,
tree::{self, InstallTree, Tree, TreeError},
workspace::{Workspace, WorkspaceError, WorkspaceTreeError},
};
use bon::Builder;
use itertools::Itertools;
use miette::Diagnostic;
use thiserror::Error;
use super::{PackageInstallSpec, RemoveError, Uninstall};
use crate::drivers::install_packages::{InstallPackages, InstallPackagesError};
use crate::drivers::sync::{Sync, SyncError, SyncMode, TargetSet};
#[derive(Error, Debug, Diagnostic)]
pub enum UpdateError {
#[error(transparent)]
#[diagnostic(transparent)]
RockConstraintUnsatisfied(#[from] RockConstraintUnsatisfied),
#[error("failed to update rock")]
#[diagnostic(forward(0))]
Install(#[from] Box<InstallPackagesError>),
#[error("failed to remove old rock")]
#[diagnostic(forward(0))]
Remove(#[from] RemoveError),
#[error("error initialising remote package DB")]
#[diagnostic(forward(0))]
PackageDB(#[from] PackageDBError),
#[error("error loading the workspace")]
#[diagnostic(forward(0))]
Workspace(#[from] WorkspaceError),
#[error(transparent)]
#[diagnostic(transparent)]
LuaVersionUnset(#[from] LuaVersionUnset),
#[error(transparent)]
Io(#[from] io::Error),
#[error(transparent)]
#[diagnostic(transparent)]
Tree(#[from] TreeError),
#[error("error initialising the workspace install tree")]
#[diagnostic(forward(0))]
WorkspaceTree(#[from] WorkspaceTreeError),
#[error("error syncing the workspace install tree")]
#[diagnostic(forward(0))]
Sync(#[from] Box<SyncError>),
}
impl From<InstallPackagesError> for UpdateError {
fn from(source: InstallPackagesError) -> Self {
Self::Install(Box::new(source))
}
}
impl From<SyncError> for UpdateError {
fn from(source: SyncError) -> Self {
Self::Sync(Box::new(source))
}
}
#[derive(Builder)]
#[builder(start_fn = new, finish_fn(name = _update, vis = ""))]
pub struct Update<'a> {
#[builder(start_fn)]
config: &'a Config,
#[builder(field)]
packages: Option<Vec<PackageReq>>,
#[builder(field)]
test_dependencies: Option<Vec<PackageReq>>,
#[builder(field)]
build_dependencies: Option<Vec<PackageReq>>,
workspace: Option<Workspace>,
validate_integrity: Option<bool>,
package_db: Option<PackageDB>,
}
impl<State: update_builder::State> UpdateBuilder<'_, State> {
pub fn packages(mut self, packages: Option<Vec<PackageReq>>) -> Self {
self.packages = packages;
self
}
pub fn build_dependencies(mut self, packages: Option<Vec<PackageReq>>) -> Self {
self.build_dependencies = packages;
self
}
pub fn test_dependencies(mut self, packages: Option<Vec<PackageReq>>) -> Self {
self.test_dependencies = packages;
self
}
}
impl<State: update_builder::State> UpdateBuilder<'_, State> {
#[tracing::instrument(name = "Updating packages", skip_all)]
pub async fn update(self) -> Result<Vec<LockedPackage>, UpdateError>
where
State: update_builder::IsComplete,
{
let args = self._update();
if args
.packages
.as_ref()
.is_some_and(|packages| packages.is_empty())
{
return Ok(Vec::default());
}
let package_db = match &args.package_db {
Some(db) => db.clone(),
None => {
let db = PackageDB::from_config(args.config).await?;
db
}
};
let workspace = match args.workspace.clone() {
Some(ws) => Some(ws),
None => Workspace::current()?,
};
match workspace {
Some(workspace) => Box::pin(update_workspace(workspace, args, package_db)).await,
None => Box::pin(update_install_tree(args, package_db)).await,
}
}
}
async fn update_workspace(
workspace: Workspace,
args: Update<'_>,
package_db: PackageDB,
) -> Result<Vec<LockedPackage>, UpdateError> {
let tree = workspace.tree(args.config)?;
let sync_report = Sync::new(&workspace, args.config)
.mode(SyncMode::Frozen)
.targets(TargetSet::all(&workspace, true))
.validate_integrity(args.validate_integrity.unwrap_or(false))
.sync()
.await?;
let mut project_lockfile = workspace.lockfile()?.write_guard();
let updated_dependencies = update_dependency_tree(
tree,
&mut project_lockfile,
LockedPackageLockType::Regular,
package_db.clone(),
args.config,
&args.packages,
)
.await?;
let test_tree = workspace.test_tree(args.config)?;
let updated_test_dependencies = update_dependency_tree(
test_tree,
&mut project_lockfile,
LockedPackageLockType::Test,
package_db.clone(),
args.config,
&args.test_dependencies,
)
.await?;
let build_tree = workspace.build_tree(args.config)?;
let updated_build_dependencies = update_dependency_tree(
build_tree,
&mut project_lockfile,
LockedPackageLockType::Build,
package_db,
args.config,
&args.build_dependencies,
)
.await?;
Ok(updated_dependencies
.into_iter()
.chain(sync_report.added)
.chain(sync_report.removed)
.chain(updated_build_dependencies)
.chain(updated_test_dependencies)
.collect_vec())
}
async fn update_dependency_tree(
tree: Tree,
project_lockfile: &mut WorkspaceLockfile<ReadWrite>,
lock_type: LockedPackageLockType,
package_db: PackageDB,
config: &Config,
packages: &Option<Vec<PackageReq>>,
) -> Result<Vec<LockedPackage>, UpdateError> {
let lockfile = tree.lockfile()?;
let dependencies = updatable_packages(&lockfile)
.into_iter()
.filter(|pkg| is_included(pkg, packages))
.collect_vec();
let updated_dependencies = update(dependencies, package_db, &tree, &lockfile, config).await?;
if !updated_dependencies.is_empty() {
let updated_lockfile = tree.lockfile()?;
project_lockfile.sync(updated_lockfile.local_pkg_lock(), &lock_type);
}
Ok(updated_dependencies)
}
fn is_included(
(pkg, _): &(LockedPackage, PackageReq),
package_reqs: &Option<Vec<PackageReq>>,
) -> bool {
package_reqs.is_none()
|| package_reqs.as_ref().is_some_and(|packages| {
packages
.iter()
.any(|req| req.matches(&pkg.as_package_spec()))
})
}
async fn update_install_tree(
args: Update<'_>,
package_db: PackageDB,
) -> Result<Vec<LockedPackage>, UpdateError> {
let tree = args
.config
.user_tree(LuaVersion::from(args.config)?.clone())?;
let lockfile = tree.lockfile()?;
let packages = updatable_packages(&lockfile)
.into_iter()
.filter(|pkg| is_included(pkg, &args.packages))
.collect_vec();
update(packages, package_db, &tree, &lockfile, args.config).await
}
async fn update(
packages: Vec<(LockedPackage, PackageReq)>,
package_db: PackageDB,
tree: &Tree,
lockfile: &Lockfile<ReadOnly>,
config: &Config,
) -> Result<Vec<LockedPackage>, UpdateError> {
let mut updatable = Vec::new();
for (package, constraint) in packages.clone() {
match package
.to_package()
.has_update_with(&constraint, &package_db)
.await
{
Ok(Some(_)) if package.pinned() == PinnedState::Unpinned => {
updatable.push((package, constraint));
}
_ => {}
}
}
if updatable.is_empty() {
Ok(Vec::new())
} else {
Uninstall::new()
.config(config)
.packages(updatable.iter().map(|(package, _)| package.id()))
.remove()
.await?;
let (updated_packages, _lockfile) = InstallPackages::new(config, tree)
.packages(
updatable
.iter()
.map(|updatable| mk_install_spec(updatable, lockfile))
.collect(),
)
.package_db(package_db)
.install()
.await?;
Ok(updated_packages)
}
}
fn updatable_packages(lockfile: &Lockfile<ReadOnly>) -> Vec<(LockedPackage, PackageReq)> {
lockfile
.rocks()
.values()
.filter(|package| {
package.pinned() == PinnedState::Unpinned
&& match package.source() {
RemotePackageSource::LuarocksRockspec(_) => true,
RemotePackageSource::LuarocksSrcRock(_) => true,
RemotePackageSource::LuarocksBinaryRock(_) => true,
RemotePackageSource::Wally(_) => true,
RemotePackageSource::RockspecContent(_) => false,
RemotePackageSource::Local => false,
#[cfg(test)]
RemotePackageSource::Test => false,
}
})
.map(|package| (package.clone(), package.spec().as_package_req()))
.collect_vec()
}
fn mk_install_spec(
(package, req): &(LockedPackage, PackageReq),
lockfile: &Lockfile<ReadOnly>,
) -> PackageInstallSpec {
let entry_type = if lockfile.is_entrypoint(&package.id()) {
tree::EntryType::Entrypoint
} else {
tree::EntryType::DependencyOnly
};
PackageInstallSpec::new(req.clone(), entry_type)
.build_behaviour(BuildBehaviour::Force)
.pin(PinnedState::Unpinned)
.opt(package.opt())
.build()
}
#[cfg(all(test, feature = "impure_tests"))]
mod tests {
use std::path::PathBuf;
use assert_fs::prelude::PathCopy;
use crate::{
config::ConfigBuilder, lockfile::LockedPackageLockType, lua_version::LuaVersion,
package_db::PackageDB, workspace::Workspace,
};
use super::Update;
#[tokio::test]
async fn update_preserves_pessimistic_req_and_persists_lockfile() {
let sample = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("resources/test/sample-projects/no-build-spec/");
let temp = assert_fs::TempDir::new().unwrap();
temp.copy_from(sample, &["**"]).unwrap();
let toml_path = temp.path().join("lux.toml");
let manifest = std::fs::read_to_string(&toml_path).unwrap();
std::fs::write(
&toml_path,
format!("{manifest}\n[dependencies]\n30log = \"~> 0.9\"\n"),
)
.unwrap();
let config = ConfigBuilder::new()
.unwrap()
.lua_version(Some(LuaVersion::Lua51))
.build()
.unwrap();
let package_db = PackageDB::from_config(&config).await.unwrap();
let mut workspace = Workspace::from_exact(temp.path()).unwrap().unwrap();
workspace
.members_mut()
.iter_mut()
.next()
.unwrap()
.upgrade_all(&package_db, &config)
.await
.unwrap();
let rewritten = std::fs::read_to_string(&toml_path).unwrap();
assert!(
rewritten.contains("30log = \"~>"),
"upgrade overwrote the pessimistic req: {rewritten}"
);
assert!(
!rewritten.contains("30log = \"~> 0.9\""),
"upgrade did not widen the pessimistic req: {rewritten}"
);
Update::new(&config)
.workspace(workspace.clone())
.package_db(package_db.clone())
.update()
.await
.unwrap();
let reloaded = Workspace::from_exact(temp.path()).unwrap().unwrap();
let lockfile = reloaded.lockfile().unwrap();
assert!(
lockfile
.rocks(&LockedPackageLockType::Regular)
.values()
.any(|pkg| pkg.name().to_string() == "30log"),
"lockfile was not persisted"
);
}
}