switch from parsing yaml bytes to taking the path so we can report better errors

Author: rikonor

Cargo.lock

@@ -1,8 +1,7 @@
 use clap::Parser;
-use icp_canister::{CanisterManifest, CanisterManifestError};
-use snafu::Snafu;
+use snafu::{ResultExt, Snafu};
 
-use icp_fs::fs::{ReadFileError, read};
+use icp_canister::{CanisterManifest, CanisterManifestError};
 use icp_project::{ProjectManifest, ProjectManifestError};
 
 use crate::project::structure::ProjectDirectoryStructure;
@@ -11,30 +10,24 @@ use crate::project::structure::ProjectDirectoryStructure;
 pub struct Cmd;
 
 pub async fn dispatch(_cmd: Cmd) -> Result<(), BuildCommandError> {
-    // Open project
-    let pds = ProjectDirectoryStructure::find().ok_or(BuildCommandError::ProjectNotFound)?;
-
-    let mpath = pds.root().join("icp.yaml");
-    if !mpath.exists() {
-        return Err(BuildCommandError::ProjectNotFound);
-    }
+    let mpath = ProjectDirectoryStructure::find()
+        .ok_or(BuildCommandError::ProjectNotFound)?
+        .root()
+        .join("icp.yaml");
 
-    let bs = read(mpath)?;
-    let pm = ProjectManifest::from_bytes(&bs)?;
+    let pm = ProjectManifest::from_file(&mpath).context(ProjectLoadSnafu {
+        path: format!("{mpath:?}"),
+    })?;
 
     // List canisters in project
     let mut cs = Vec::new();
 
     for c in pm.canisters {
         let mpath = c.join("canister.yaml");
-        if !mpath.exists() {
-            return Err(BuildCommandError::CanisterNotFound {
-                path: format!("{mpath:?}"),
-            });
-        }
 
-        let bs = read(mpath)?;
-        let cm = CanisterManifest::from_bytes(&bs)?;
+        let cm = CanisterManifest::from_file(&mpath).context(CanisterLoadSnafu {
+            path: format!("{mpath:?}"),
+        })?;
 
         cs.push(cm);
     }
@@ -50,15 +43,15 @@ pub enum BuildCommandError {
     #[snafu(display("no project (icp.yaml) found in current directory or its parents"))]
     ProjectNotFound,
 
-    #[snafu(transparent)]
-    ProjectParse { source: ProjectManifestError },
-
-    #[snafu(display("canister manifest not found: {path}"))]
-    CanisterNotFound { path: String },
-
-    #[snafu(transparent)]
-    CanisterParse { source: CanisterManifestError },
-
-    #[snafu(transparent)]
-    ReadFile { source: ReadFileError },
+    #[snafu(display("failed to load project manifest: {path}"))]
+    ProjectLoad {
+        source: ProjectManifestError,
+        path: String,
+    },
+
+    #[snafu(display("failed to load canister manifest: {path}"))]
+    CanisterLoad {
+        source: CanisterManifestError,
+        path: String,
+    },
 }

bin/icp-cli/src/commands/build.rs

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+icp-fs = { "path" = "../icp-fs" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true }

lib/icp-canister/Cargo.toml

@@ -1,5 +1,9 @@
+use std::path::Path;
+
 use serde::Deserialize;
-use snafu::{ResultExt, Snafu};
+use snafu::{ResultExt, Snafu, ensure};
+
+use icp_fs::fs::{ReadFileError, read};
 
 /// Configuration for a Rust-based canister build adapter.
 #[derive(Debug, Deserialize)]
@@ -76,7 +80,21 @@ pub struct CanisterManifest {
 }
 
 impl CanisterManifest {
-    pub fn from_bytes<B: AsRef<[u8]>>(bytes: B) -> Result<Self, CanisterManifestError> {
+    pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, CanisterManifestError> {
+        let path = path.as_ref();
+
+        // Check existence
+        ensure!(
+            path.exists(),
+            NotFoundSnafu {
+                path: format!("{path:?}")
+            }
+        );
+
+        // Read
+        let bytes = read(path)?;
+
+        // Parse
         let cm: CanisterManifest = serde_yaml::from_slice(bytes.as_ref()).context(ParseSnafu)?;
 
         Ok(cm)
@@ -85,6 +103,12 @@ impl CanisterManifest {
 
 #[derive(Debug, Snafu)]
 pub enum CanisterManifestError {
+    #[snafu(display("canister manifest not found: {path}"))]
+    NotFound { path: String },
+
     #[snafu(display("failed to parse canister manifest: {}", source))]
     Parse { source: serde_yaml::Error },
+
+    #[snafu(transparent)]
+    ReadFile { source: ReadFileError },
 }

lib/icp-canister/src/lib.rs

@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 glob = { workspace = true }
 icp-canister = { path = "../icp-canister" }
+icp-fs = { "path" = "../icp-fs" }
 icp-network = { path = "../icp-network" }
 serde = { workspace = true }
 serde_json = { workspace = true }

lib/icp-project/Cargo.toml

@@ -1,6 +1,9 @@
+use std::path::{Path, PathBuf};
+
 use serde::Deserialize;
-use snafu::{OptionExt, ResultExt, Snafu};
-use std::path::PathBuf;
+use snafu::{OptionExt, ResultExt, Snafu, ensure};
+
+use icp_fs::fs::{ReadFileError, read};
 
 /// Represents the manifest for an ICP project, typically loaded from `icp.yaml`.
 /// A project is a repository or directory grouping related canisters and network definitions.
@@ -18,7 +21,21 @@ pub struct ProjectManifest {
 }
 
 impl ProjectManifest {
-    pub fn from_bytes<B: AsRef<[u8]>>(bytes: B) -> Result<Self, ProjectManifestError> {
+    pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, ProjectManifestError> {
+        let path = path.as_ref();
+
+        // Check existence
+        ensure!(
+            path.exists(),
+            NotFoundSnafu {
+                path: format!("{path:?}")
+            }
+        );
+
+        // Load
+        let bytes = read(path)?;
+
+        // Parse
         let mut pm: ProjectManifest = serde_yaml::from_slice(bytes.as_ref()).context(ParseSnafu)?;
 
         // Project canisters
@@ -48,6 +65,9 @@ impl ProjectManifest {
 
 #[derive(Debug, Snafu)]
 pub enum ProjectManifestError {
+    #[snafu(display("project manifest not found: {path}"))]
+    NotFound { path: String },
+
     #[snafu(display("failed to parse project manifest: {}", source))]
     Parse { source: serde_yaml::Error },
 
@@ -59,4 +79,7 @@ pub enum ProjectManifestError {
 
     #[snafu(transparent)]
     GlobWalk { source: glob::GlobError },
+
+    #[snafu(transparent)]
+    ReadFile { source: ReadFileError },
 }