Improve CLI error reporting

Author: yungcomputerchair

src/bin/ffbuildtool.rs

@@ -6,7 +6,7 @@ use std::{
 
 use clap::{Args, Parser, Subcommand};
 
-use ffbuildtool::{Error, ItemProgress, Version};
+use ffbuildtool::{ItemProgress, Version};
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use uuid::Uuid;
 
@@ -199,10 +199,16 @@ impl ProgressManager {
     }
 }
 
+async fn parse_manifest(path: &str) -> Result<Version, String> {
+    Version::from_manifest(path)
+        .await
+        .map_err(|e| format!("Couldn't parse manifest: {}", e))
+}
+
 static PROGRESS: OnceLock<ProgressManager> = OnceLock::new();
 
 #[tokio::main]
-async fn main() -> Result<(), Error> {
+async fn main() -> Result<(), String> {
     PROGRESS
         .set(ProgressManager::new())
         .unwrap_or_else(|_| panic!());
@@ -217,13 +223,13 @@ async fn main() -> Result<(), Error> {
     }
 }
 
-async fn generate_manifest(args: GenManifestArgs) -> Result<(), Error> {
+async fn generate_manifest(args: GenManifestArgs) -> Result<(), String> {
     println!(
         "Generating manifest for build at {} with asset URL {}",
         args.build_path, args.asset_url
     );
     let parent_uuid: Option<Uuid> = if let Some(p) = args.parent {
-        Some(Uuid::parse_str(p.as_str())?)
+        Some(Uuid::parse_str(p.as_str()).map_err(|_| "Invalid parent UUID".to_string())?)
     } else {
         None
     };
@@ -235,21 +241,24 @@ async fn generate_manifest(args: GenManifestArgs) -> Result<(), Error> {
         args.description.as_deref(),
         parent_uuid,
     )
-    .await?;
+    .await
+    .map_err(|e| format!("Couldn't generate bundle info: {}", e))?;
 
     if args.hidden {
         version.set_hidden(true);
     }
 
     println!("Build UUID: {}", version.get_uuid());
 
-    version.export_manifest(&args.output_path)?;
+    version
+        .export_manifest(&args.output_path)
+        .map_err(|e| format!("Couldn't export manifest: {}", e))?;
     println!("Manifest exported to {}", args.output_path);
     Ok(())
 }
 
-async fn download_build(args: DownloadBuildArgs) -> Result<(), Error> {
-    let version = Version::from_manifest(&args.manifest_path).await?;
+async fn download_build(args: DownloadBuildArgs) -> Result<(), String> {
+    let version = parse_manifest(&args.manifest_path).await?;
     println!(
         "Downloading build {} to {}",
         version.get_uuid(),
@@ -262,13 +271,14 @@ async fn download_build(args: DownloadBuildArgs) -> Result<(), Error> {
 
     version
         .download_compressed(&args.output_path, Some(Arc::new(cb)))
-        .await?;
+        .await
+        .map_err(|e| format!("Couldn't download build: {}", e))?;
     println!("Download complete");
     Ok(())
 }
 
-async fn repair_build(args: RepairBuildArgs) -> Result<(), Error> {
-    let version = Version::from_manifest(&args.manifest_path).await?;
+async fn repair_build(args: RepairBuildArgs) -> Result<(), String> {
+    let version = parse_manifest(&args.manifest_path).await?;
     println!(
         "Repairing build {} at {}",
         version.get_uuid(),
@@ -279,7 +289,10 @@ async fn repair_build(args: RepairBuildArgs) -> Result<(), Error> {
         PROGRESS.get().unwrap().update_item(name, progress);
     };
 
-    let corrupted = version.repair(&args.build_path, Some(Arc::new(cb))).await?;
+    let corrupted = version
+        .repair(&args.build_path, Some(Arc::new(cb)))
+        .await
+        .map_err(|e| format!("Couldn't repair build: {}", e))?;
     if corrupted.is_empty() {
         println!("No corrupted files found");
     } else {
@@ -291,8 +304,8 @@ async fn repair_build(args: RepairBuildArgs) -> Result<(), Error> {
     Ok(())
 }
 
-async fn validate_build(args: ValidateBuildArgs) -> Result<(), Error> {
-    let version = Version::from_manifest(&args.manifest_path).await?;
+async fn validate_build(args: ValidateBuildArgs) -> Result<(), String> {
+    let version = parse_manifest(&args.manifest_path).await?;
     println!(
         "Validating build {} at {}",
         version.get_uuid(),
@@ -306,11 +319,13 @@ async fn validate_build(args: ValidateBuildArgs) -> Result<(), Error> {
     let corrupted = if args.uncompressed {
         version
             .validate_uncompressed(&args.build_path, None)
-            .await?
+            .await
+            .map_err(|e| format!("Couldn't validate uncompressed files: {}", e))?
     } else {
         version
             .validate_compressed(&args.build_path, Some(Arc::new(cb)))
-            .await?
+            .await
+            .map_err(|e| format!("Couldn't validate compressed files: {}", e))?
     };
 
     if corrupted.is_empty() {
@@ -325,7 +340,7 @@ async fn validate_build(args: ValidateBuildArgs) -> Result<(), Error> {
 }
 
 #[cfg(feature = "lzma")]
-async fn extract_bundle(args: ExtractBundleArgs) -> Result<(), Error> {
+async fn extract_bundle(args: ExtractBundleArgs) -> Result<(), String> {
     use std::path::PathBuf;
 
     let asset_bundle = ffbuildtool::bundle::AssetBundle::from_file(&args.bundle_path)?;

src/bundle.rs

@@ -357,9 +357,6 @@ impl AssetBundle {
             );
         }
 
-        #[cfg(debug_assertions)]
-        dbg!(&header);
-
         // seek to first level
         let offset = reader.reader_bytes();
         skip_exact(&mut reader, header.header_size as usize - offset)?;
@@ -377,9 +374,6 @@ impl AssetBundle {
             }
         }
 
-        #[cfg(debug_assertions)]
-        dbg!(&levels);
-
         Ok(Self { levels })
     }
 
@@ -405,18 +399,23 @@ impl AssetBundle {
         Ok(())
     }
 
-    pub fn from_file(path: &str) -> Result<Self, Error> {
-        let file = File::open(path)?;
-        let metadata = file.metadata()?;
+    pub fn from_file(path: &str) -> Result<Self, String> {
+        let file = File::open(path).map_err(|e| format!("Couldn't open file {}: {}", path, e))?;
+        let metadata = file.metadata().unwrap();
         let mut reader = BufReader::new(file);
         Self::read(&mut reader, metadata.len() as u32)
+            .map_err(|e| format!("Couldn't read bundle: {}", e))
     }
 
-    pub fn to_file(&self, path: &str) -> Result<(), Error> {
-        let file = File::create(path)?;
+    pub fn to_file(&self, path: &str) -> Result<(), String> {
+        let file =
+            File::create(path).map_err(|e| format!("Couldn't create file {}: {}", path, e))?;
         let mut writer = BufWriter::new(file);
-        self.write(&mut writer)?;
-        writer.flush()?;
+        self.write(&mut writer)
+            .map_err(|e| format!("Couldn't write bundle: {}", e))?;
+        writer
+            .flush()
+            .map_err(|e| format!("Couldn't finish writing bundle: {}", e))?;
         Ok(())
     }
 
@@ -438,20 +437,23 @@ impl AssetBundle {
         Ok(result)
     }
 
-    pub fn extract_files(&self, output_dir: &str) -> Result<(), Error> {
+    pub fn extract_files(&self, output_dir: &str) -> Result<(), String> {
         let make_subdirs = self.levels.len() > 1;
         for (i, level) in self.levels.iter().enumerate() {
             let level_dir = if make_subdirs {
                 format!("{}/level{}", output_dir, i)
             } else {
                 output_dir.to_string()
             };
-            util::create_dir_if_needed(&level_dir)?;
+            util::create_dir_if_needed(&level_dir)
+                .map_err(|e| format!("Couldn't create dir {}: {}", level_dir, e))?;
 
             let dir_path = Path::new(&level_dir);
             for file in &level.files {
                 let file_path = dir_path.join(&file.name);
-                std::fs::write(&file_path, &file.data)?;
+                std::fs::write(&file_path, &file.data).map_err(|e| {
+                    format!("Couldn't write file {}/{}: {}", level_dir, file.name, e)
+                })?;
             }
         }
         Ok(())