Merge branch 'ergo-err' into 'master'

Simplify error messages

See merge request redox-os/redox!2087

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<CookRecipe>) -> Result<TuiApp> {
                     && !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<CookRecipe>) -> Result<TuiApp> {
                     && !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()));

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

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(),
         };

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<pkg::Package> {
-    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<SourceIdentifier> {
     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)
 }

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<T: Serialize>(file_path: &Path, content: &T) -> Resul
     Ok(())
 }
 
+pub fn read_toml<T: DeserializeOwned>(file_path: &Path) -> Result<T> {
+    // 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!(

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());
         }
     }

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<pkg::PackageError> for Error {
     }
 }
 
+impl From<pkg::backend::Error> 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<pkgar::Error> for Error {
     fn from(value: pkgar::Error) -> Self {
         match value {

src/staged_pkg.rs

@@ -71,9 +71,7 @@ pub fn from_path(dir: &Path, feature: Option<&str>) -> Result<Package, PackageEr
         return Err(PackageError::FileMissing(file));
     }
 
-    let toml = std::fs::read_to_string(&file)
-        .map_err(|err| PackageError::FileError(err.raw_os_error(), file.clone()))?;
-    toml::from_str(&toml).map_err(|err| PackageError::Parse(err, Some(file)))
+    Package::from_file(file)
 }
 
 pub fn new_recursive(