camino conversion

Author: adamspofford-dfinity

Cargo.lock

@@ -36,7 +36,7 @@ tokio.workspace = true
 assert_cmd = "2"
 predicates = "3"
 reqwest = { workspace = true }
-tempfile = "3"
+camino-tempfile = "1"
 
 [lints]
 workspace = true

bin/icp-cli/Cargo.toml

@@ -12,10 +12,10 @@ pub struct Env {
 }
 
 impl Env {
-    pub fn new(output_format: OutputFormat, identity: Option<String>) -> Self {
+    pub fn new(output_format: OutputFormat, dirs: IcpCliDirs, identity: Option<String>) -> Self {
         Self {
             output_format,
-            dirs: IcpCliDirs::new(),
+            dirs,
             identity,
         }
     }

bin/icp-cli/src/env.rs

@@ -1,7 +1,8 @@
 use clap::{Parser, ValueEnum};
 use commands::{Cmd, DispatchError};
 use env::Env;
-use snafu::report;
+use icp_dirs::{DiscoverDirsError, IcpCliDirs};
+use snafu::{Snafu, report};
 
 mod commands;
 mod env;
@@ -26,13 +27,22 @@ enum OutputFormat {
 
 #[tokio::main]
 #[report]
-async fn main() -> Result<(), DispatchError> {
+async fn main() -> Result<(), ProgramError> {
     let cli = Cli::parse();
-    let env = Env::new(cli.output_format, cli.identity);
+    let dirs = IcpCliDirs::new()?;
+    let env = Env::new(cli.output_format, dirs, cli.identity);
     commands::dispatch(&env, cli.command).await?;
     Ok(())
 }
 
+#[derive(Debug, Snafu)]
+pub enum ProgramError {
+    #[snafu(transparent)]
+    Dispatch { source: DispatchError },
+    #[snafu(transparent)]
+    Dirs { source: DiscoverDirsError },
+}
+
 #[cfg(test)]
 mod tests {
     use clap::CommandFactory;

bin/icp-cli/src/main.rs

@@ -1,32 +1,29 @@
 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,
-    asset_dir: PathBuf,
-    dfx_path: Option<PathBuf>,
+    home_dir: Utf8TempDir,
+    bin_dir: Utf8PathBuf,
+    asset_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");
         let asset_dir = home_dir.path().join("share");
         fs::create_dir(&bin_dir).expect("failed to create bin dir");
         fs::create_dir(&asset_dir).expect("failed to create asset 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,
@@ -39,13 +36,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");
@@ -55,7 +51,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();
@@ -65,7 +61,7 @@ impl TestEnv {
         self
     }
 
-    pub fn home_path(&self) -> &Path {
+    pub fn home_path(&self) -> &Utf8Path {
         self.home_dir.path()
     }
 
@@ -93,11 +89,11 @@ impl TestEnv {
         cmd.env_remove("ICP_HOME");
     }
 
-    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();
+        let mut new_path = bin_dir.as_os_str().to_owned();
         new_path.push(PATH_SEPARATOR);
-        new_path.push(old_path);
+        new_path.push(&old_path);
         new_path
     }
 
@@ -111,11 +107,11 @@ impl TestEnv {
         fs::write(&networks_json_path, networks).unwrap();
     }
 
-    pub fn pkg_dir(&self) -> PathBuf {
+    pub fn pkg_dir(&self) -> Utf8PathBuf {
         env!("CARGO_MANIFEST_DIR").into()
     }
 
-    pub fn make_asset(&self, name: &str) -> PathBuf {
+    pub fn make_asset(&self, name: &str) -> Utf8PathBuf {
         let target = self.asset_dir.join(name);
         fs::copy(self.pkg_dir().join(format!("tests/assets/{name}")), &target)
             .expect("failed to copy asset");

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

@@ -1,13 +1,13 @@
 use core::str;
 use std::io::Write;
 
+use camino_tempfile::NamedUtf8TempFile;
 use common::TestEnv;
 use ic_agent::export::Principal;
 use predicates::{
     ord::eq,
     str::{PredicateStrExt, contains},
 };
-use tempfile::NamedTempFile;
 
 mod common;
 
@@ -28,7 +28,7 @@ fn identity_anonymous() {
 
 #[test]
 fn identity_import_seed() {
-    let mut file = NamedTempFile::new().unwrap();
+    let mut file = NamedUtf8TempFile::new().unwrap();
     file.write_all(b"equip will roof matter pink blind book anxiety banner elbow sun young")
         .unwrap();
     let path = file.into_temp_path();
@@ -78,7 +78,7 @@ fn identity_import_pem() {
         .stderr(contains("missing field `parameters`"));
 
     // from encrypted
-    let mut file = NamedTempFile::new().unwrap();
+    let mut file = NamedUtf8TempFile::new().unwrap();
     file.write_all(b"swordfish").unwrap();
     let path = file.into_temp_path();
     env.icp()
@@ -118,7 +118,7 @@ fn identity_create() {
         .args(["identity", "principal", "--identity", "alice"])
         .assert()
         .success();
-    let mut file = NamedTempFile::new().unwrap();
+    let mut file = NamedUtf8TempFile::new().unwrap();
     file.write_all(seed.trim().as_bytes()).unwrap();
     let path = file.into_temp_path();
     env.icp()

bin/icp-cli/tests/identity_tests.rs

@@ -4,7 +4,9 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+camino.workspace = true
 directories.workspace = true
+snafu.workspace = true
 
 [lints]
 workspace = true

lib/icp-dirs/Cargo.toml

@@ -1,32 +1,56 @@
-use std::path::PathBuf;
-
+use camino::Utf8PathBuf;
 use directories::ProjectDirs;
+use snafu::{OptionExt, ResultExt, Snafu};
 
 #[derive(Debug, Clone)]
 pub enum IcpCliDirs {
-    Standard(ProjectDirs),
-    Overridden(PathBuf),
+    Standard(Utf8ProjectDirs),
+    Overridden(Utf8PathBuf),
 }
 
 impl IcpCliDirs {
-    pub fn new() -> Self {
-        if let Some(override_var) = std::env::var_os("ICP_HOME") {
-            Self::Overridden(override_var.into())
+    pub fn new() -> Result<Self, DiscoverDirsError> {
+        if let Ok(override_var) = std::env::var("ICP_HOME") {
+            Ok(Self::Overridden(override_var.into()))
         } else {
-            Self::Standard(ProjectDirs::from("org.dfinity", "", "icp-cli").unwrap())
+            Ok(Self::Standard(
+                Utf8ProjectDirs::from_dirs(
+                    ProjectDirs::from("org.dfinity", "", "icp-cli").context(CannotFindHomeSnafu)?,
+                )
+                .context(NonUtf8Snafu)?,
+            ))
         }
     }
 
-    pub fn identity_dir(&self) -> PathBuf {
+    pub fn identity_dir(&self) -> Utf8PathBuf {
         match self {
-            Self::Standard(dirs) => dirs.data_dir().join("identity"),
+            Self::Standard(dirs) => dirs.data_dir.join("identity"),
             Self::Overridden(path) => path.join("identity"),
         }
     }
 }
 
-impl Default for IcpCliDirs {
-    fn default() -> Self {
-        Self::new()
+#[derive(Debug, Snafu)]
+pub enum DiscoverDirsError {
+    #[snafu(display("user directories are non-UTF-8"))]
+    NonUtf8 { source: camino::FromPathBufError },
+    #[snafu(display("home directory could not be located"))]
+    CannotFindHome,
+}
+
+#[derive(Debug, Clone)]
+pub struct Utf8ProjectDirs {
+    pub data_dir: Utf8PathBuf,
+    pub config_dir: Utf8PathBuf,
+    pub cache_dir: Utf8PathBuf,
+}
+
+impl Utf8ProjectDirs {
+    pub fn from_dirs(dirs: ProjectDirs) -> Result<Self, camino::FromPathBufError> {
+        Ok(Self {
+            data_dir: dirs.data_dir().to_owned().try_into()?,
+            config_dir: dirs.config_dir().to_owned().try_into()?,
+            cache_dir: dirs.cache_dir().to_owned().try_into()?,
+        })
     }
 }

lib/icp-dirs/src/lib.rs

@@ -8,7 +8,8 @@ pub struct CreateDirAllError {
     pub source: std::io::Error,
 }
 
-pub fn create_dir_all(path: &Path) -> Result<(), CreateDirAllError> {
+pub fn create_dir_all(path: impl AsRef<Path>) -> Result<(), CreateDirAllError> {
+    let path = path.as_ref();
     std::fs::create_dir_all(path).context(CreateDirAllSnafu { path })
 }
 

lib/icp-fs/src/fs.rs

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+camino.workspace = true
 directories.workspace = true
 ed25519-consensus.workspace = true
 elliptic-curve.workspace = true