refact: remove virtual package
This commit is contained in:
steven-omaha
+566
@@ -0,0 +1,566 @@
|
||||
use std::collections::HashMap;
|
||||
use std::env::current_dir;
|
||||
use std::fs::{copy, create_dir_all, remove_file, rename, File};
|
||||
use std::os::unix::fs::symlink;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
|
||||
use anyhow::{bail, ensure, Context, Result};
|
||||
use const_format::formatcp;
|
||||
|
||||
use crate::cmd::{run_edit_command, run_external_command};
|
||||
use crate::env::{get_editor, should_print_debug_info};
|
||||
use crate::grouping::group::groups_to_backend_packages;
|
||||
use crate::path::{binary_in_path, get_absolutized_file_paths, get_group_dir};
|
||||
use crate::prelude::*;
|
||||
use crate::review::review;
|
||||
use crate::search::search_packages;
|
||||
use crate::ui::get_user_confirmation;
|
||||
|
||||
impl MainArguments {
|
||||
/// Run the action that was provided by the user as first argument.
|
||||
///
|
||||
/// For convenience sake, all called functions take a `&self` argument, even if
|
||||
/// these are not strictly required.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function propagates errors from the underlying functions.
|
||||
pub fn run(self, groups: &Groups, config: &Config) -> Result<()> {
|
||||
match self.subcommand {
|
||||
MainSubcommand::Group(group) => group.run(groups),
|
||||
MainSubcommand::Package(package) => package.run(groups, config),
|
||||
MainSubcommand::Version(version) => version.run(config),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl VersionArguments {
|
||||
/// If the crate was compiled from git, return `pacdef, <version> (<hash>)`.
|
||||
/// Otherwise return `pacdef, <version>`.
|
||||
fn run(self, config: &Config) -> Result<()> {
|
||||
let backends = get_included_backends(config);
|
||||
let mut result = format!("pacdef, version: {}\n", get_version_string());
|
||||
result.push_str("supported backends:");
|
||||
for b in backends {
|
||||
result.push_str("\n ");
|
||||
result.push_str(b);
|
||||
}
|
||||
|
||||
println!("{}", result);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl GroupArguments {
|
||||
fn run(self, groups: &Groups) -> Result<()> {
|
||||
match self.group_action {
|
||||
GroupAction::Edit(edit) => edit.run(groups),
|
||||
GroupAction::Export(export) => export.run(groups),
|
||||
GroupAction::Import(import) => import.run(),
|
||||
GroupAction::List(list) => list.run(groups),
|
||||
GroupAction::New(new) => new.run(),
|
||||
GroupAction::Remove(remove) => remove.run(groups),
|
||||
GroupAction::Show(show) => show.run(groups),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl EditGroupAction {
|
||||
fn run(self, groups: &Groups) -> Result<()> {
|
||||
let group_files: Vec<_> = find_groups_by_name(&self.edit_groups, groups)
|
||||
.context("getting group files for args")?
|
||||
.into_iter()
|
||||
.map(|g| g.path.as_path())
|
||||
.collect();
|
||||
|
||||
let mut cmd = Command::new(get_editor().context("getting suitable editor")?);
|
||||
cmd.current_dir(
|
||||
group_files[0]
|
||||
.parent()
|
||||
.context("getting parent dir of first file argument")?,
|
||||
);
|
||||
for group_file in group_files {
|
||||
cmd.arg(group_file.to_string_lossy().to_string());
|
||||
}
|
||||
run_external_command(cmd)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl ExportGroupAction {
|
||||
/// Export pacdef groups by moving a group file to an output dir. The path of the
|
||||
/// group file relative to the group base dir will be replicated under the output
|
||||
/// directory.
|
||||
///
|
||||
/// By default, the output dir is the current working directory. `output_dir` may be
|
||||
/// specified to the path of another directory, in which case `output_dir` must
|
||||
/// exist.
|
||||
///
|
||||
/// If `force` is `true`, the output file will be overwritten if it exists.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error if
|
||||
/// - the group file is a symlink (in which case exporting makes no sense),
|
||||
/// - the output file exists and `force` is not `true`, or
|
||||
/// - the user does not have permission to write to the output dir.
|
||||
///
|
||||
/// # Limitations
|
||||
///
|
||||
/// At the moment we cannot export nested group dirs. The user would have to
|
||||
/// export every group file individually, or use a shell glob.
|
||||
fn run(self, groups: &Groups) -> Result<()> {
|
||||
let groups = find_groups_by_name(&self.export_groups, groups)?;
|
||||
let output_dir = match self.output_dir {
|
||||
Some(p) => p,
|
||||
None => current_dir().context("no output dir specified, getting current directory")?,
|
||||
};
|
||||
|
||||
ensure!(
|
||||
output_dir.exists() && output_dir.is_dir(),
|
||||
"output must be a directory and exist"
|
||||
);
|
||||
|
||||
for group in &groups {
|
||||
ensure!(!&group.path.is_symlink(), "cannot export symlinks");
|
||||
|
||||
let mut exported_path = output_dir.clone();
|
||||
exported_path.push(PathBuf::from(&group.name));
|
||||
|
||||
ensure!(
|
||||
!self.force && !exported_path.exists(),
|
||||
"{exported_path:?} already exists"
|
||||
);
|
||||
|
||||
create_parent(&exported_path)
|
||||
.with_context(|| format!("creating parent dir of {exported_path:?}"))?;
|
||||
move_file(&group.path, &exported_path).context("moving file")?;
|
||||
symlink(&exported_path, &group.path).context("creating symlink to exported file")?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl ImportGroupAction {
|
||||
fn run(self) -> Result<()> {
|
||||
let files = get_absolutized_file_paths(&self.import_groups)?;
|
||||
let groups_dir = get_group_dir()?;
|
||||
|
||||
for target in files {
|
||||
let target_name = target
|
||||
.file_name()
|
||||
.context("path should not end in '..'")?
|
||||
.to_str()
|
||||
.context("filename is not valid UTF-8")?;
|
||||
|
||||
if !target.exists() {
|
||||
log::warn!("file {target_name} does not exist, skipping");
|
||||
continue;
|
||||
}
|
||||
|
||||
let mut link = groups_dir.clone();
|
||||
link.push(target_name);
|
||||
|
||||
if link.exists() {
|
||||
log::warn!("group {target_name} already exists, skipping");
|
||||
} else {
|
||||
symlink(target, link)?;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl ListGroupAction {
|
||||
/// Print the alphabetically sorted names of all groups to stdout.
|
||||
///
|
||||
/// This methods cannot return an error. It returns a `Result` to be consistent
|
||||
/// with other methods.
|
||||
fn run(self, groups: &Groups) -> Result<()> {
|
||||
let mut vec: Vec<_> = groups.iter().collect();
|
||||
vec.sort_unstable();
|
||||
for g in vec {
|
||||
println!("{}", g.name);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl NewGroupAction {
|
||||
/// Create empty group files.
|
||||
///
|
||||
/// If `edit` is `true`, the editor will be run to edit the files after they are
|
||||
/// created.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error if
|
||||
/// - a group name is `.` or `..`,
|
||||
/// - a group with the same name already exists,
|
||||
/// - the editor cannot be run, or
|
||||
/// - if we do not have permission to write to the group dir.
|
||||
fn run(&self) -> Result<()> {
|
||||
let group_path = get_group_dir()?;
|
||||
|
||||
// prevent group names that resolve to directories
|
||||
for new_group in &self.new_groups {
|
||||
ensure!(
|
||||
new_group != "." && new_group != "..",
|
||||
Error::InvalidGroupName(new_group.clone())
|
||||
);
|
||||
}
|
||||
|
||||
let paths: Vec<_> = self
|
||||
.new_groups
|
||||
.iter()
|
||||
.map(|name| {
|
||||
let mut base = group_path.clone();
|
||||
base.push(name);
|
||||
base
|
||||
})
|
||||
.collect();
|
||||
|
||||
for file in &paths {
|
||||
ensure!(!file.exists(), Error::GroupAlreadyExists(file.clone()));
|
||||
}
|
||||
|
||||
for file in &paths {
|
||||
File::create(file)?;
|
||||
}
|
||||
|
||||
if self.edit {
|
||||
run_edit_command(&paths).context("running editor")?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl RemoveGroupAction {
|
||||
fn run(self, groups: &Groups) -> Result<()> {
|
||||
let found = find_groups_by_name(&self.remove_groups, groups)?;
|
||||
|
||||
for group in found {
|
||||
remove_file(&group.path)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl ShowGroupAction {
|
||||
fn run(self, groups: &Groups) -> Result<()> {
|
||||
let mut errors = vec![];
|
||||
let mut found_groups = vec![];
|
||||
|
||||
// make sure all args exist before doing anything
|
||||
for show_group in &self.show_groups {
|
||||
let possible_group = groups.iter().find(|group| group.name == *show_group);
|
||||
|
||||
let Some(group) = possible_group else {
|
||||
errors.push(show_group.to_string());
|
||||
continue;
|
||||
};
|
||||
|
||||
found_groups.push(group);
|
||||
}
|
||||
|
||||
// return an error if any arg was not found
|
||||
ensure!(errors.is_empty(), Error::MultipleGroupsNotFound(errors));
|
||||
|
||||
let show_more_than_one_group = self.show_groups.len() > 1;
|
||||
|
||||
let mut iter = found_groups.into_iter().peekable();
|
||||
|
||||
while let Some(group) = iter.next() {
|
||||
if show_more_than_one_group {
|
||||
let name = &group.name;
|
||||
println!("{name}");
|
||||
for _ in 0..name.len() {
|
||||
print!("-");
|
||||
}
|
||||
println!();
|
||||
}
|
||||
|
||||
println!("{group}");
|
||||
if iter.peek().is_some() {
|
||||
println!();
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl PackageArguments {
|
||||
fn run(self, groups: &Groups, config: &Config) -> Result<()> {
|
||||
match self.package_action {
|
||||
PackageAction::Clean(clean) => clean.run(groups, config),
|
||||
PackageAction::Review(review) => review.run(groups, config),
|
||||
PackageAction::Search(search) => search.run(groups),
|
||||
PackageAction::Sync(sync) => sync.run(groups, config),
|
||||
PackageAction::Unmanaged(unmanaged) => unmanaged.run(groups, config),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl CleanPackageAction {
|
||||
fn run(self, groups: &Groups, config: &Config) -> Result<()> {
|
||||
let to_remove = get_unmanaged_packages(groups, config)?;
|
||||
|
||||
if to_remove.nothing_to_do_for_all_backends() {
|
||||
println!("nothing to do");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
println!("Would remove the following packages:\n");
|
||||
to_remove.show().context("printing things to do")?;
|
||||
|
||||
println!();
|
||||
if self.no_confirm {
|
||||
println!("proceeding without confirmation");
|
||||
} else if !get_user_confirmation()? {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
to_remove.remove_unmanaged_packages(self.no_confirm)
|
||||
}
|
||||
}
|
||||
|
||||
impl ReviewPackageAction {
|
||||
fn run(self, groups: &Groups, config: &Config) -> Result<()> {
|
||||
review(get_unmanaged_packages(groups, config)?, groups)
|
||||
}
|
||||
}
|
||||
|
||||
impl SearchPackageAction {
|
||||
fn run(self, groups: &Groups) -> Result<()> {
|
||||
search_packages(&self.regex, groups)
|
||||
}
|
||||
}
|
||||
|
||||
impl SyncPackageAction {
|
||||
fn run(self, groups: &Groups, config: &Config) -> Result<()> {
|
||||
let to_install = get_missing_packages(groups, config)?;
|
||||
|
||||
if to_install.nothing_to_do_for_all_backends() {
|
||||
println!("nothing to do");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
println!("Would install the following packages:\n");
|
||||
to_install.show().context("printing things to do")?;
|
||||
|
||||
println!();
|
||||
if self.no_confirm {
|
||||
println!("proceeding without confirmation");
|
||||
} else if !get_user_confirmation()? {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
to_install.install_missing_packages(self.no_confirm)
|
||||
}
|
||||
}
|
||||
|
||||
impl UnmanagedPackageAction {
|
||||
fn run(self, groups: &Groups, config: &Config) -> Result<()> {
|
||||
let unmanaged_per_backend = &get_unmanaged_packages(groups, config)?;
|
||||
|
||||
if unmanaged_per_backend.nothing_to_do_for_all_backends() {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
unmanaged_per_backend
|
||||
.show()
|
||||
.context("printing things to do")
|
||||
}
|
||||
}
|
||||
|
||||
fn get_missing_packages(groups: &Groups, config: &Config) -> Result<ToDoPerBackend> {
|
||||
let backend_packages = groups_to_backend_packages(groups, config)?;
|
||||
|
||||
let mut to_install = ToDoPerBackend::new();
|
||||
|
||||
for (any_backend, packages) in &backend_packages {
|
||||
let backend_info = any_backend.backend_info();
|
||||
|
||||
if config
|
||||
.disabled_backends
|
||||
.contains(&backend_info.section.to_string())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if !binary_in_path(&backend_info.binary)? {
|
||||
continue;
|
||||
}
|
||||
|
||||
let managed_backend = ManagedBackend {
|
||||
packages: packages.clone(),
|
||||
any_backend: any_backend.clone(),
|
||||
};
|
||||
|
||||
match managed_backend.get_missing_packages_sorted() {
|
||||
Ok(diff) => to_install.push((any_backend.clone(), diff)),
|
||||
Err(error) => show_backend_query_error(&error, any_backend),
|
||||
};
|
||||
}
|
||||
|
||||
Ok(to_install)
|
||||
}
|
||||
|
||||
/// Get a list of unmanaged packages per backend.
|
||||
///
|
||||
/// This method loops through all enabled `Backend`s whose binary is in `PATH`.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will propagate errors from the individual backends.
|
||||
fn get_unmanaged_packages(groups: &Groups, config: &Config) -> Result<ToDoPerBackend> {
|
||||
let backend_packages = groups_to_backend_packages(groups, config)?;
|
||||
|
||||
let mut todo_unmanaged = ToDoPerBackend::new();
|
||||
|
||||
for (any_backend, packages) in &backend_packages {
|
||||
let backend_info = any_backend.backend_info();
|
||||
if config
|
||||
.disabled_backends
|
||||
.contains(&backend_info.section.to_string())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if !binary_in_path(&backend_info.binary)? {
|
||||
continue;
|
||||
}
|
||||
|
||||
let managed_backend = ManagedBackend {
|
||||
packages: packages.clone(),
|
||||
any_backend: any_backend.clone(),
|
||||
};
|
||||
|
||||
match managed_backend.get_unmanaged_packages_sorted() {
|
||||
Ok(unmanaged) => todo_unmanaged.push((any_backend.clone(), unmanaged)),
|
||||
Err(error) => show_backend_query_error(&error, any_backend),
|
||||
};
|
||||
}
|
||||
|
||||
Ok(todo_unmanaged)
|
||||
}
|
||||
|
||||
/// Create the parent directory of the `path` if that directory does not exist.
|
||||
///
|
||||
/// Do nothing otherwise.
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// Panics if the path does not have a parent.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will propagate errors from [`std::fs::create_dir_all`].
|
||||
fn create_parent(path: &Path) -> Result<()> {
|
||||
let parent = &path.parent().expect("this should never be /");
|
||||
if !parent.is_dir() {
|
||||
create_dir_all(parent).context("creating parent dir")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Move a file from one place to another.
|
||||
///
|
||||
/// At first [`std::fs::rename`] is used, which fails if `from` and `to` reside under
|
||||
/// different filesystems. In case that happens, we will resort to copying the files
|
||||
/// and then removing `from`.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error if we lack permission to write the file.
|
||||
fn move_file<P, Q>(from: P, to: Q) -> Result<()>
|
||||
where
|
||||
P: AsRef<Path>,
|
||||
Q: AsRef<Path>,
|
||||
{
|
||||
let from = from.as_ref();
|
||||
let to = to.as_ref();
|
||||
match rename(from, to) {
|
||||
Ok(_) => (),
|
||||
Err(e) => {
|
||||
// CrossesDevices is nightly. See rust #86442.
|
||||
// We cannot check that here, so we just assume that
|
||||
// that would be the error if permissions are okay.
|
||||
if e.kind() == std::io::ErrorKind::PermissionDenied {
|
||||
bail!(e);
|
||||
}
|
||||
copy(from, to).with_context(|| format!("copying {from:?} to {to:?}"))?;
|
||||
remove_file(from).with_context(|| format!("deleting {from:?}"))?;
|
||||
}
|
||||
};
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// For the provided names, get the group with the same name.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error if any of the file names do not match one
|
||||
/// of group names.
|
||||
fn find_groups_by_name<'a>(names: &[String], groups: &'a Groups) -> Result<Vec<&'a Group>> {
|
||||
let name_group_map: HashMap<&str, &Group> =
|
||||
groups.iter().map(|g| (g.name.as_str(), g)).collect();
|
||||
|
||||
let mut result = Vec::new();
|
||||
|
||||
for file in names {
|
||||
match name_group_map.get(file.as_str()) {
|
||||
Some(group) => {
|
||||
result.push(*group);
|
||||
}
|
||||
None => bail!(Error::GroupFileNotFound(file.clone())),
|
||||
}
|
||||
}
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
/// Show the error chain for an error that has occurred when a backend was queried
|
||||
/// if the `RUST_BACKTRACE` env variable is set to `1` or `full`.
|
||||
fn show_backend_query_error(error: &anyhow::Error, backend: &AnyBackend) {
|
||||
if should_print_debug_info() {
|
||||
log::warn!(
|
||||
"skipping backend '{backend}': {}",
|
||||
error.chain().map(|x| x.to_string()).collect::<String>()
|
||||
);
|
||||
} else {
|
||||
log::warn!("skipping backend '{backend}': {error}");
|
||||
}
|
||||
}
|
||||
|
||||
/// If the crate was compiled from git, return `<version> (<hash>)`. Otherwise
|
||||
/// return `<version>`.
|
||||
pub const fn get_version_string() -> &'static str {
|
||||
const VERSION: &str = env!("CARGO_PKG_VERSION");
|
||||
const HASH: &str = env!("GIT_HASH");
|
||||
|
||||
if HASH.is_empty() {
|
||||
VERSION
|
||||
} else {
|
||||
formatcp!("{VERSION} ({HASH})")
|
||||
}
|
||||
}
|
||||
|
||||
/// Get a vector with the names of all backends, sorted alphabetically.
|
||||
fn get_included_backends(config: &Config) -> Vec<&'static str> {
|
||||
let mut result = vec![];
|
||||
for backend in AnyBackend::all(config) {
|
||||
result.push(backend.backend_info().section);
|
||||
}
|
||||
result.sort_unstable();
|
||||
result
|
||||
}
|
||||
Reference in New Issue
Block a user