feat: Convert to camino and camino-tempfile (#9)

Author: adamspofford-dfinity

Cargo.lock

@@ -3,12 +3,13 @@ members = [
     "bin/icp-cli",
     "lib/icp-identity",
     "lib/icp-network",
-    "lib/icp-fs"
+    "lib/icp-fs",
 ]
 
 resolver = "3"
 
 [workspace.dependencies]
+camino = { version = "1.1.9", features = ["serde1"] }
 candid = "0.10.14"
 fd-lock = "4.0.4"
 hex = "0.4.3"

Cargo.toml

@@ -9,6 +9,7 @@ name = "icp"
 path = "src/main.rs"
 
 [dependencies]
+camino = { workspace = true }
 clap = { version = "4.5.35", features = ["derive"] }
 icp-network = { path = "../../lib/icp-network" }
 icp-fs = { path = "../../lib/icp-fs" }
@@ -19,4 +20,4 @@ tokio = { workspace = true }
 assert_cmd = "2"
 predicates = "3"
 reqwest = { workspace = true }
-tempfile = "3"
+camino-tempfile = "1"

bin/icp-cli/Cargo.toml

@@ -1,5 +1,8 @@
-use crate::commands::network::run::RunNetworkCommandError::ProjectNotFound;
 use crate::project::directory::ProjectDirectory;
+use crate::{
+    commands::network::run::RunNetworkCommandError::ProjectNotFound,
+    project::directory::FindProjectError,
+};
 use clap::Parser;
 use icp_network::{ManagedNetworkModel, RunNetworkError, run_network};
 use snafu::Snafu;
@@ -10,11 +13,11 @@ pub struct Cmd {}
 
 pub async fn exec(_cmd: Cmd) -> Result<(), RunNetworkCommandError> {
     let config = ManagedNetworkModel::default();
-    let pd = ProjectDirectory::find().ok_or(ProjectNotFound)?;
+    let pd = ProjectDirectory::find()?.ok_or(ProjectNotFound)?;
     let nd = pd.network("local");
 
-    eprintln!("Project root: {}", pd.structure().root().display());
-    eprintln!("Network root: {}", nd.structure().network_root().display());
+    eprintln!("Project root: {}", pd.structure().root());
+    eprintln!("Network root: {}", nd.structure().network_root());
 
     run_network(config, nd).await?;
 
@@ -26,6 +29,9 @@ pub enum RunNetworkCommandError {
     #[snafu(display("no project (icp.yaml) found in current directory or its parents"))]
     ProjectNotFound,
 
+    #[snafu(transparent)]
+    FindProjectError { source: FindProjectError },
+
     #[snafu(transparent)]
     NetworkExecutionFailed { source: RunNetworkError },
 }

bin/icp-cli/src/commands/network/run.rs

@@ -1,22 +1,26 @@
 use crate::project::structure::ProjectDirectoryStructure;
+use camino::Utf8PathBuf;
 use icp_network::NetworkDirectory;
+use snafu::{ResultExt, Snafu};
+use std::io;
 
 pub struct ProjectDirectory {
     structure: ProjectDirectoryStructure,
 }
 
 impl ProjectDirectory {
-    pub fn find() -> Option<Self> {
-        let current_dir = std::env::current_dir().ok()?;
+    pub fn find() -> Result<Option<Self>, FindProjectError> {
+        let current_dir = Utf8PathBuf::try_from(std::env::current_dir().context(AccessSnafu)?)
+            .context(NonUtf8Snafu)?;
         let mut path = current_dir.clone();
         loop {
             let structure = ProjectDirectoryStructure::new(&path);
 
             if structure.project_yaml_path().exists() {
-                break Some(Self { structure });
+                break Ok(Some(Self { structure }));
             }
             if !path.pop() {
-                break None;
+                break Ok(None);
             }
         }
     }
@@ -30,3 +34,11 @@ impl ProjectDirectory {
         NetworkDirectory::new(&network_root)
     }
 }
+
+#[derive(Debug, Snafu)]
+pub enum FindProjectError {
+    #[snafu(display("project path is non-UTF-8"))]
+    NonUtf8 { source: camino::FromPathBufError },
+    #[snafu(display("failed to access current directory"))]
+    AccessError { source: io::Error },
+}

bin/icp-cli/src/project/directory.rs

@@ -1,33 +1,33 @@
-use std::path::{Path, PathBuf};
+use camino::{Utf8Path, Utf8PathBuf};
 
 pub struct ProjectDirectoryStructure {
-    root: PathBuf,
+    root: Utf8PathBuf,
 }
 
 impl ProjectDirectoryStructure {
-    pub fn new(root: &Path) -> Self {
+    pub fn new(root: &Utf8Path) -> Self {
         let root = root.to_path_buf();
         Self { root }
     }
 
-    pub fn root(&self) -> &PathBuf {
+    pub fn root(&self) -> &Utf8PathBuf {
         &self.root
     }
 
-    pub fn project_yaml_path(&self) -> PathBuf {
+    pub fn project_yaml_path(&self) -> Utf8PathBuf {
         self.root.join("icp.yaml")
     }
 
     #[allow(dead_code)]
-    pub fn network_config_path(&self, name: &str) -> PathBuf {
+    pub fn network_config_path(&self, name: &str) -> Utf8PathBuf {
         self.root.join("networks").join(format!("{name}.yaml"))
     }
 
-    fn work_dir(&self) -> PathBuf {
+    fn work_dir(&self) -> Utf8PathBuf {
         self.root.join(".icp")
     }
 
-    pub fn network_root(&self, network_name: &str) -> PathBuf {
+    pub fn network_root(&self, network_name: &str) -> Utf8PathBuf {
         self.work_dir().join("networks").join(network_name)
     }
 }

bin/icp-cli/src/project/structure.rs

@@ -1,29 +1,26 @@
 use crate::common::os::PATH_SEPARATOR;
 use assert_cmd::Command;
+use camino::{Utf8Path, Utf8PathBuf};
+use camino_tempfile::Utf8TempDir;
 use std::env;
 use std::ffi::OsString;
 use std::fs;
 use std::fs::create_dir_all;
-use std::path::{Path, PathBuf};
-use tempfile::TempDir;
 
 pub struct TestEnv {
-    home_dir: TempDir,
-    bin_dir: PathBuf,
-    dfx_path: Option<PathBuf>,
+    home_dir: Utf8TempDir,
+    bin_dir: Utf8PathBuf,
+    dfx_path: Option<Utf8PathBuf>,
     os_path: OsString,
 }
 
 impl TestEnv {
     pub fn new() -> Self {
-        let home_dir = tempfile::tempdir().expect("failed to create temp home dir");
+        let home_dir = camino_tempfile::tempdir().expect("failed to create temp home dir");
         let bin_dir = home_dir.path().join("bin");
         fs::create_dir(&bin_dir).expect("failed to create bin dir");
         let os_path = Self::build_os_path(&bin_dir);
-        eprintln!(
-            "Test environment home directory: {}",
-            home_dir.path().display()
-        );
+        eprintln!("Test environment home directory: {}", home_dir.path());
 
         Self {
             home_dir,
@@ -35,13 +32,12 @@ impl TestEnv {
 
     /// Sets up `dfx` in the test environment by copying the binary from $ICPTEST_DFX_PATH
     pub fn with_dfx(mut self) -> Self {
-        let dfx_path = std::env::var_os("ICPTEST_DFX_PATH")
+        let dfx_path = std::env::var("ICPTEST_DFX_PATH")
             .expect("ICPTEST_DFX_PATH must be set to use with_dfx()");
-        let src = PathBuf::from(dfx_path);
+        let src = Utf8PathBuf::from(dfx_path);
         assert!(
             src.exists(),
-            "ICPTEST_DFX_PATH points to non-existent file: {}",
-            src.display()
+            "ICPTEST_DFX_PATH points to non-existent file: {src}",
         );
 
         let dest = self.bin_dir.join("dfx");
@@ -51,7 +47,7 @@ impl TestEnv {
         {
             use std::os::unix::fs::PermissionsExt;
             let mut perms = fs::metadata(&dest)
-                .unwrap_or_else(|e| panic!("Failed to read metadata for {}: {}", dest.display(), e))
+                .unwrap_or_else(|e| panic!("Failed to read metadata for {dest}: {e}"))
                 .permissions();
             perms.set_mode(0o500);
             fs::set_permissions(&dest, perms).unwrap();
@@ -61,7 +57,7 @@ impl TestEnv {
         self
     }
 
-    pub fn home_path(&self) -> &Path {
+    pub fn home_path(&self) -> &Utf8Path {
         self.home_dir.path()
     }
 
@@ -88,7 +84,7 @@ impl TestEnv {
         cmd.env("PATH", self.os_path.clone());
     }
 
-    fn build_os_path(bin_dir: &Path) -> OsString {
+    fn build_os_path(bin_dir: &Utf8Path) -> OsString {
         let old_path = env::var_os("PATH").unwrap_or_default();
         let mut new_path = bin_dir.as_os_str().to_os_string();
         new_path.push(PATH_SEPARATOR);

bin/icp-cli/tests/common/test_env.rs

@@ -0,0 +1,4 @@
+disallowed-types = [
+    { path = "std::path::PathBuf", replacement = "camino::Utf8PathBuf" },
+    { path = "std::path::Path", replacement = "camino::Utf8Path" },
+]

clippy.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+camino = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 snafu = { workspace = true }

lib/icp-fs/Cargo.toml

@@ -1,60 +1,65 @@
+use camino::{Utf8Path, Utf8PathBuf};
 use snafu::prelude::*;
-use std::path::{Path, PathBuf};
 
 #[derive(Snafu, Debug)]
-#[snafu(display("failed to create directory {} and parents", path.display()))]
+#[snafu(display("failed to create directory {path} and parents"))]
 pub struct CreateDirAllError {
-    pub path: PathBuf,
+    pub path: Utf8PathBuf,
     pub source: std::io::Error,
 }
 
-pub fn create_dir_all(path: &Path) -> Result<(), CreateDirAllError> {
+pub fn create_dir_all(path: impl AsRef<Utf8Path>) -> Result<(), CreateDirAllError> {
+    let path = path.as_ref();
     std::fs::create_dir_all(path).context(CreateDirAllSnafu { path })
 }
 
 #[derive(Snafu, Debug)]
-#[snafu(display("failed to read {}", path.display()))]
+#[snafu(display("failed to read {path}"))]
 pub struct ReadFileError {
-    pub path: PathBuf,
+    pub path: Utf8PathBuf,
     pub source: std::io::Error,
 }
 
-pub fn read<P: AsRef<Path>>(path: P) -> Result<Vec<u8>, ReadFileError> {
+pub fn read<P: AsRef<Utf8Path>>(path: P) -> Result<Vec<u8>, ReadFileError> {
     let path = path.as_ref();
     std::fs::read(path).context(ReadFileSnafu { path })
 }
 
 #[derive(Snafu, Debug)]
-#[snafu(display("failed to remove directory {} and contents", path.display()))]
+#[snafu(display("failed to remove directory {path} and contents"))]
 pub struct RemoveDirAllError {
-    pub path: PathBuf,
+    pub path: Utf8PathBuf,
     pub source: std::io::Error,
 }
 
-pub fn remove_dir_all(path: &Path) -> Result<(), RemoveDirAllError> {
+pub fn remove_dir_all(path: impl AsRef<Utf8Path>) -> Result<(), RemoveDirAllError> {
+    let path = path.as_ref();
     std::fs::remove_dir_all(path).context(RemoveDirAllSnafu { path })
 }
 
 #[derive(Snafu, Debug)]
-#[snafu(display("failed to remove file {}", path.display()))]
+#[snafu(display("failed to remove file {path}"))]
 pub struct RemoveFileError {
-    pub path: PathBuf,
+    pub path: Utf8PathBuf,
     pub source: std::io::Error,
 }
 
-pub fn remove_file<P: AsRef<Path>>(path: P) -> Result<(), RemoveFileError> {
+pub fn remove_file<P: AsRef<Utf8Path>>(path: P) -> Result<(), RemoveFileError> {
     let path = path.as_ref();
     std::fs::remove_file(path).context(RemoveFileSnafu { path })
 }
 
 #[derive(Snafu, Debug)]
-#[snafu(display("failed to write {}", path.display()))]
+#[snafu(display("failed to write {path}"))]
 pub struct WriteFileError {
-    pub path: PathBuf,
+    pub path: Utf8PathBuf,
     pub source: std::io::Error,
 }
 
-pub fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) -> Result<(), WriteFileError> {
+pub fn write<P: AsRef<Utf8Path>, C: AsRef<[u8]>>(
+    path: P,
+    contents: C,
+) -> Result<(), WriteFileError> {
     let path = path.as_ref();
     std::fs::write(path, contents).context(WriteFileSnafu { path })
 }