From 82c5a2ea94235156e0dc3e41f1957fc54179d581 Mon Sep 17 00:00:00 2001 From: Wildan M Date: Mon, 20 Apr 2026 20:40:07 +0700 Subject: [PATCH] Simplify error messages --- src/bin/repo.rs | 6 +++--- src/bin/repo_builder.rs | 9 ++------- src/cook/cook_build.rs | 12 +++--------- src/cook/fetch.rs | 34 ++++++++++++---------------------- src/cook/fs.rs | 8 +++++++- src/cook/tree.rs | 9 ++++----- src/lib.rs | 24 ++++++++++++++++++++++-- src/staged_pkg.rs | 4 +--- 8 files changed, 54 insertions(+), 52 deletions(-) diff --git a/src/bin/repo.rs b/src/bin/repo.rs index ca78d665..d30360dc 100644 --- a/src/bin/repo.rs +++ b/src/bin/repo.rs @@ -361,7 +361,7 @@ fn repo_inner(config: &CliConfig, command: &CliCommand, recipe: &CookRecipe) -> let mut logger = Some((&mut stdout_writer, &mut stderr_writer)); let result = repo_inner_fn(&logger); if let Err(err_ctx) = &result { - write_to_pty(&logger, &format!("\n{:?}", err_ctx)); + write_to_pty(&logger, &format!("\n{err_ctx}")); } // successful cached build is not that useful to log if !matches!(result, Ok(true)) { @@ -1201,7 +1201,7 @@ fn run_tui_cook(config: CliConfig, recipes: Vec) -> Result { && !matches!(handler, Ok(true)) { if let Err(err_ctx) = &handler { - write_to_pty(&logger, &format!("\n{:?}", err_ctx)); + write_to_pty(&logger, &format!("\n{err_ctx}")); } flush_pty(&mut logger); let log_path = log_path.join(format!("{}/{}.log", recipe.target, name.name())); @@ -1306,7 +1306,7 @@ fn run_tui_cook(config: CliConfig, recipes: Vec) -> Result { && !matches!(handler, Ok(FetchResult { cached: true, .. })) { if let Err(err_ctx) = &handler { - write_to_pty(&logger, &format!("\n{:?}", err_ctx)); + write_to_pty(&logger, &format!("\n{err_ctx}")); } flush_pty(&mut logger); let log_path = log_path.join(format!("{}/{}.log", recipe.target, name.name())); diff --git a/src/bin/repo_builder.rs b/src/bin/repo_builder.rs index 004f1133..6a9140a2 100644 --- a/src/bin/repo_builder.rs +++ b/src/bin/repo_builder.rs @@ -219,10 +219,7 @@ fn publish_packages(config: &CliConfig) -> Result<()> { // === 4. Read and update repo.toml === let repo_toml_path = repo_path.join("repo.toml"); if repo_toml_path.exists() { - let contents = fs::read_to_string(&repo_toml_path)?; - - let parsed: Repository = toml::from_str(&contents) - .map_err(|_| Error::Other(format!("Unable to deserialize repo.toml")))?; + let parsed: Repository = fs::read_toml(&repo_toml_path)?; for (k, v) in parsed.packages { packages.insert(k, v); } @@ -253,9 +250,7 @@ fn publish_packages(config: &CliConfig) -> Result<()> { continue; } - let content = fs::read_to_string(&path)?; - let parsed: Value = toml::from_str(&content) - .map_err(|_| Error::Other(format!("Unable to deserialize repo.toml")))?; + let parsed: Value = fs::read_toml(&path)?; let empty_ver = Value::String("".to_string()); let version_str = parsed diff --git a/src/cook/cook_build.rs b/src/cook/cook_build.rs index 8592f554..a0ebc956 100644 --- a/src/cook/cook_build.rs +++ b/src/cook/cook_build.rs @@ -685,10 +685,7 @@ fn build_auto_deps( } let auto_deps = if auto_deps_path.exists() { - let toml_content = - fs::read_to_string(&auto_deps_path).map_err(|_| "failed to read cached auto_deps")?; - let wrapper: AutoDeps = - toml::from_str(&toml_content).map_err(|_| "failed to deserialize cached auto_deps")?; + let wrapper: AutoDeps = fs::read_toml(&auto_deps_path)?; wrapper.packages } else { let mut dynamic_deps = auto_deps_from_dynamic_linking(stage_dirs, &dep_pkgars, logger); @@ -736,9 +733,7 @@ pub fn build_remote( if cached { log_to_pty!(logger, "DEBUG: using cached build"); - let toml_content = fs::read_to_string(&auto_deps_path)?; - let wrapper: AutoDeps = - toml::from_str(&toml_content).map_err(|_| "failed to deserialize cached auto_deps")?; + let wrapper: AutoDeps = fs::read_toml(&auto_deps_path)?; return Ok(BuildResult::cached(stage_dirs, wrapper.packages)); } @@ -755,8 +750,7 @@ pub fn build_remote( let auto_deps = { let toml_content = fs::read_to_string(&source_toml)?; - let pkg_toml: Package = - toml::from_str(&toml_content).map_err(|_| "failed to deserialize source.toml")?; + let pkg_toml = Package::from_toml(&toml_content)?; let wrapper = AutoDeps { packages: pkg_toml.depends.into_iter().collect(), }; diff --git a/src/cook/fetch.rs b/src/cook/fetch.rs index 50aab92b..2305cdaa 100644 --- a/src/cook/fetch.rs +++ b/src/cook/fetch.rs @@ -690,23 +690,19 @@ pub fn fetch_remote( if !source_toml.is_file() { { let toml_file = File::create(&source_toml) - .map_err(|e| format!("Unable to create source.toml: {e:?}"))?; + .map_err(wrap_io_err!(source_toml, "Creating file"))?; let mut writer = DownloadBackendWriter::ToFile(toml_file); - manager - .download(&format!("{}.toml", &source_name), None, &mut writer) - .map_err(|e| format!("Unable to download source.toml: {e:?}"))?; + manager.download(&format!("{}.toml", &source_name), None, &mut writer)?; } let pkg_toml = read_source_toml(&source_toml)?; let pkgar_file = File::create(&source_pkgar) - .map_err(|e| format!("Unable to create source.pkgar: {e:?}"))?; + .map_err(wrap_io_err!(source_pkgar, "Creating file"))?; let mut writer = DownloadBackendWriter::ToFile(pkgar_file); - manager - .download( - &format!("{}.pkgar", &source_name), - Some(pkg_toml.network_size), - &mut writer, - ) - .map_err(|e| format!("Unable to download source.pkgar: {e:?}"))?; + manager.download( + &format!("{}.pkgar", &source_name), + Some(pkg_toml.network_size), + &mut writer, + )?; cached = false; } @@ -743,13 +739,11 @@ pub fn fetch_remote( } fn read_source_toml(source_toml: &Path) -> Result { - let mut file = - File::open(source_toml).map_err(|e| format!("Unable to open source.toml: {e:?}"))?; + let mut file = File::open(source_toml).map_err(wrap_io_err!(source_toml, "Opening file"))?; let mut contents = String::new(); file.read_to_string(&mut contents) - .map_err(|e| format!("Unable to read source.toml: {e:?}"))?; - let pkg_toml = pkg::Package::from_toml(&contents) - .map_err(|e| format!("Unable to parse source.toml: {e:?}"))?; + .map_err(wrap_io_err!(source_toml, "Reading file"))?; + let pkg_toml = pkg::Package::from_toml(&contents)?; Ok(pkg_toml) } @@ -842,9 +836,5 @@ pub(crate) fn fetch_apply_source_info_from_remote( pub fn fetch_get_source_info(recipe: &CookRecipe) -> Result { let target_dir = recipe.target_dir(); let source_toml_path = target_dir.join("source_info.toml"); - let toml_content = fs::read_to_string(source_toml_path) - .map_err(|e| format!("Unable to read source_info.toml: {:?}", e))?; - let parsed = toml::from_str(&toml_content) - .map_err(|e| format!("Unable to parse source_info.toml: {:?}", e))?; - Ok(parsed) + read_toml(&source_toml_path) } diff --git a/src/cook/fs.rs b/src/cook/fs.rs index 7668365d..d0711686 100644 --- a/src/cook/fs.rs +++ b/src/cook/fs.rs @@ -1,4 +1,4 @@ -use serde::Serialize; +use serde::{Serialize, de::DeserializeOwned}; use std::{ collections::BTreeSet, fs, @@ -261,6 +261,12 @@ pub fn serialize_and_write(file_path: &Path, content: &T) -> Resul Ok(()) } +pub fn read_toml(file_path: &Path) -> Result { + // TODO: General error rather than from PackageError? + toml::from_str(&read_to_string(file_path)?) + .map_err(|e| Error::Package(pkg::PackageError::Parse(e, Some(file_path.to_path_buf())))) +} + pub fn offline_check_exists(path: &PathBuf) -> Result<()> { if !path.exists() { bail_other_err!( diff --git a/src/cook/tree.rs b/src/cook/tree.rs index 675921cc..88e2ccc5 100644 --- a/src/cook/tree.rs +++ b/src/cook/tree.rs @@ -2,12 +2,12 @@ use pkg::{Package, PackageName}; use std::fmt::Write as _; use std::{ collections::{HashMap, HashSet}, - fs::read_to_string, path::PathBuf, }; +use crate::Result; +use crate::cook::fs; use crate::recipe::CookRecipe; -use crate::{Result, wrap_other_err}; pub enum WalkTreeEntry<'a> { Built(&'a PathBuf, u64), @@ -94,10 +94,9 @@ pub fn walk_tree_entry( all_deps_set.extend(cook_recipe.recipe.build.dependencies.iter()); all_deps_set.extend(cook_recipe.recipe.package.dependencies.iter()); } else { - if let Ok(pkg_toml_str) = read_to_string(&pkg_toml) { + if let Ok(pkg_toml_str) = fs::read_to_string(&pkg_toml) { // more accurate with auto deps - pkg_meta = toml::from_str(&pkg_toml_str) - .map_err(|_| wrap_other_err!("Unable to parse {}", pkg_toml.display())())?; + pkg_meta = Package::from_toml(&pkg_toml_str)?; all_deps_set.extend(pkg_meta.depends.iter()); } } diff --git a/src/lib.rs b/src/lib.rs index c9f88b80..0c2f3cf3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -45,6 +45,7 @@ pub enum Error { }, Command(Command, ExitStatus), Package(pkg::PackageError), + PackageBackend(pkg::backend::Error), Pkgar(pkgar::Error), Options(String), Other(String), @@ -94,8 +95,11 @@ impl Display for Error { command, exit_status ) } - Error::Package(package_error) => write!(f, "{}", package_error), - Error::Pkgar(error) => write!(f, "{}", error), + Error::Package(package_error) => write!(f, "Package error: {}", package_error), + Error::PackageBackend(package_error) => { + write!(f, "Package backend error: {}", package_error) + } + Error::Pkgar(error) => write!(f, "Package archive error: {}", error), Error::Other(context) | Error::Options(context) => { write!(f, "{context}") } @@ -163,6 +167,22 @@ impl From for Error { } } +impl From for Error { + fn from(value: pkg::backend::Error) -> Self { + match value { + pkg::backend::Error::IO(error) + | pkg::backend::Error::Download(pkg::net_backend::DownloadError::IO(error)) => { + Error::Io { + source: error, + path: None, + context: "Package backend I/O", + } + } + error => Error::PackageBackend(error), + } + } +} + impl From for Error { fn from(value: pkgar::Error) -> Self { match value { diff --git a/src/staged_pkg.rs b/src/staged_pkg.rs index d7abbce0..7248915c 100644 --- a/src/staged_pkg.rs +++ b/src/staged_pkg.rs @@ -71,9 +71,7 @@ pub fn from_path(dir: &Path, feature: Option<&str>) -> Result