fix and replace all AsCPtr usage

nixide/src/errors/context.rs

@@ -21,12 +21,14 @@
 //     static std::optional<std::string> programName;
 // };
 
+use std::ffi::CString;
 use std::ffi::c_uint;
 use std::ffi::c_void;
 use std::ptr::NonNull;
 
 use super::{NixError, NixideResult};
-use crate::stdext::{AsCPtr as _, CCharPtrExt as _};
+use crate::errors::ToNixideResult as _;
+use crate::stdext::CCharPtrExt as _;
 use crate::sys;
 use crate::util::wrap;
 use crate::util::wrappers::AsInnerPtr;
@@ -188,11 +190,11 @@ impl ErrorContext {
     ///
     #[allow(unused)]
     pub fn set_err(&self, err: NixError, msg: &str) -> NixideResult<()> {
-        let ptr = unsafe { self.as_ptr() };
+        let ctx = unsafe { self.as_ptr() };
-        assert!(!ptr.is_null(), "");
+        let c_msg = CString::new(msg).to_nixide_result()?;
 
         unsafe {
-            sys::nix_set_err_msg(ptr, err.err_code(), msg.as_c_ptr()?);
+            sys::nix_set_err_msg(ctx, err.err_code(), c_msg.as_ptr());
         }
 
         Ok(())

nixide/src/errors/error.rs

@@ -5,6 +5,16 @@ use crate::sys;
 
 pub type NixideResult<T> = Result<T, NixideError>;
 
+pub(crate) trait ToNixideResult<T> {
+    fn to_nixide_result(self) -> NixideResult<T>;
+}
+
+impl<T> ToNixideResult<T> for Result<T, std::ffi::NulError> {
+    fn to_nixide_result(self) -> NixideResult<T> {
+        Err(new_nixide_error!(StringNulByte))
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum NixideError {
     /// # Warning
@@ -134,16 +144,3 @@ impl Display for NixideError {
         }
     }
 }
-
-// pub trait AsErr<T> {
-//     fn as_err(self) -> Result<(), T>;
-// }
-
-// impl AsErr<NixideError> for Option<NixideError> {
-//     fn as_err(self) -> Result<(), NixideError> {
-//         match self {
-//             Some(err) => Err(err),
-//             None => Ok(()),
-//         }
-//     }
-// }

nixide/src/errors/mod.rs

@@ -4,6 +4,6 @@ mod context;
 mod nix_error;
 
 pub(crate) use context::ErrorContext;
-pub(crate) use error::new_nixide_error;
 pub use error::{NixideError, NixideResult};
+pub(crate) use error::{ToNixideResult, new_nixide_error};
 pub use nix_error::NixError;

nixide/src/expr/eval_state.rs

@@ -1,11 +1,10 @@
 use std::cell::RefCell;
+use std::ffi::CString;
 use std::ptr::NonNull;
 use std::rc::Rc;
 
-use crate::stdext::AsCPtr as _;
-
 use super::Value;
-use crate::errors::ErrorContext;
+use crate::errors::{ErrorContext, ToNixideResult as _};
 use crate::sys;
 use crate::util::wrappers::AsInnerPtr;
 use crate::util::{panic_issue_call_failed, wrap};
@@ -22,22 +21,6 @@ pub struct EvalState {
     store: Rc<RefCell<Store>>,
 }
 
-// impl Clone for EvalState {
-//     fn clone(&self) -> Self {
-//         let inner = self.inner.clone();
-//
-//         wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
-//             sys::nix_gc_incref(ctx.as_ptr(), self.as_ptr() as *mut c_void);
-//         })
-//         .unwrap();
-//
-//         Self {
-//             inner,
-//             store: self.store.clone(),
-//         }
-//     }
-// }
-
 impl AsInnerPtr<sys::EvalState> for EvalState {
     #[inline]
     unsafe fn as_ptr(&self) -> *mut sys::EvalState {
@@ -87,8 +70,8 @@ impl EvalState {
     /// Returns an error if evaluation fails.
     ///
     pub fn interpret(&self, expr: &str, path: &str) -> NixideResult<Value> {
-        let expr = expr.as_c_ptr()?;
+        let c_expr = CString::new(expr).to_nixide_result()?;
-        let path = path.as_c_ptr()?;
+        let c_path = CString::new(path).to_nixide_result()?;
 
         // Allocate value for result
         // XXX: TODO: create a method for this (``)
@@ -99,10 +82,15 @@ impl EvalState {
 
         // Evaluate expression
         wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
-            sys::nix_expr_eval_from_string(ctx.as_ptr(), self.as_ptr(), expr, path, value.as_ptr());
+            sys::nix_expr_eval_from_string(
-            value
+                ctx.as_ptr(),
+                self.as_ptr(),
+                c_expr.as_ptr(),
+                c_path.as_ptr(),
+                value.as_ptr(),
+            );
+            Value::from((value, self.inner_ref().clone()))
         })
-        .map(|ptr| Value::from((ptr, self.inner_ref().clone())))
     }
 }
 

nixide/src/expr/values/attrs.rs

@@ -1,15 +1,16 @@
 use std::cell::RefCell;
+use std::ffi::CString;
 use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
 use std::ptr::{self, NonNull};
 use std::rc::Rc;
 
 use super::{NixThunk, NixValue, Value};
-use crate::NixError;
+use crate::errors::{ErrorContext, NixideError, ToNixideResult as _};
-use crate::errors::{ErrorContext, NixideError};
+use crate::stdext::CCharPtrExt;
-use crate::stdext::{AsCPtr, CCharPtrExt};
 use crate::sys;
 use crate::util::wrappers::AsInnerPtr;
 use crate::util::{panic_issue_call_failed, wrap};
+use crate::{NixError, NixideResult};
 
 pub struct NixAttrs {
     inner: NonNull<sys::NixValue>,
@@ -170,55 +171,58 @@ impl NixAttrs {
         Some(name)
     }
 
-    pub fn get<T>(&self, name: T) -> Option<Value>
+    pub fn get<T>(&self, name: T) -> NixideResult<Option<Value>>
     where
         T: AsRef<str>,
     {
+        let c_name = CString::new(name.as_ref()).to_nixide_result()?;
+
         let result = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
             sys::nix_get_attr_byname(
                 ctx.as_ptr(),
                 self.as_ptr(),
                 self.state.borrow().as_ptr(),
-                name.as_ref()
+                c_name.as_ptr(),
-                    .into_c_ptr()
-                    .unwrap_or_else(|err| panic_issue_call_failed!("{}", err)),
             )
         });
 
         match result {
-            Ok(inner) => Some(Value::from((inner, self.state.clone()))),
+            Ok(inner) => Ok(Some(Value::from((inner, self.state.clone())))),
 
             Err(NixideError::NixError {
                 err: NixError::KeyNotFound(_),
                 ..
-            }) => None,
+            }) => Ok(None),
-            Err(err) => panic_issue_call_failed!("{}", err),
+            Err(err) => Err(err),
         }
     }
 
-    pub fn get_lazy<T>(&self, name: T) -> Option<NixThunk>
+    pub fn get_lazy<T>(&self, name: T) -> NixideResult<Option<NixThunk>>
     where
         T: AsRef<str>,
     {
+        let c_name = CString::new(name.as_ref()).to_nixide_result()?;
+
         let result = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
             sys::nix_get_attr_byname_lazy(
                 ctx.as_ptr(),
                 self.as_ptr(),
                 self.state.borrow().as_ptr(),
-                name.as_ref()
+                c_name.as_ptr(),
-                    .into_c_ptr()
-                    .unwrap_or_else(|err| panic_issue_call_failed!("{}", err)),
             )
         });
 
         match result {
-            Ok(inner) => Some(<NixThunk as NixValue>::from(inner, self.state.clone())),
+            Ok(inner) => Ok(Some(<NixThunk as NixValue>::from(
+                inner,
+                self.state.clone(),
+            ))),
 
             Err(NixideError::NixError {
                 err: NixError::KeyNotFound(_),
                 ..
-            }) => None,
+            }) => Ok(None),
-            Err(err) => panic_issue_call_failed!("{}", err),
+            Err(err) => Err(err),
         }
     }
 }

nixide/src/flake/fetchers_settings.rs

@@ -1,8 +1,8 @@
+use std::ffi::{CString, c_char};
 use std::ptr::NonNull;
 
 use crate::NixideResult;
-use crate::errors::ErrorContext;
+use crate::errors::{ErrorContext, ToNixideResult as _};
-use crate::stdext::AsCPtr as _;
 use crate::sys;
 use crate::util::wrap;
 use crate::util::wrappers::AsInnerPtr;
@@ -57,15 +57,15 @@ impl FetchersSettings {
     #[allow(unused)]
     pub fn add_access_token(&self, token_name: &str, token_value: &str) -> NixideResult<()> {
         // XXX: TODO: have a dedicated `self.access_tokens: HashMap<String, String>` instead
-        let name_ptr = token_name.into_c_ptr()?;
+        let c_name = CString::new(token_name).to_nixide_result()?;
-        let value_ptr = token_value.into_c_ptr()?;
+        let c_value = CString::new(token_value).to_nixide_result()?;
 
         wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
             sys::nix_fetchers_settings_add_access_token(
                 ctx.as_ptr(),
                 self.as_ptr(),
-                name_ptr,
+                c_name.as_ptr() as *mut c_char,
-                value_ptr,
+                c_value.as_ptr() as *mut c_char,
             );
         })
         .unwrap();
@@ -84,10 +84,14 @@ impl FetchersSettings {
     #[allow(unused)]
     pub fn remove_access_token(&self, token_name: &str) -> NixideResult<()> {
         // XXX: TODO: have a dedicated `self.access_tokens: HashMap<String, String>` instead
-        let name_ptr = token_name.into_c_ptr()?;
+        let c_name = CString::new(token_name).to_nixide_result()?;
 
         wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
-            sys::nix_fetchers_settings_remove_access_token(ctx.as_ptr(), self.as_ptr(), name_ptr);
+            sys::nix_fetchers_settings_remove_access_token(
+                ctx.as_ptr(),
+                self.as_ptr(),
+                c_name.as_ptr() as *mut c_char,
+            );
         })
         .unwrap();
 
@@ -168,13 +172,13 @@ impl FetchersSettings {
     /// It is instead **exposed by the Nixide C API extensions.**
     ///
     pub fn global_flake_registry(&self, registry: &str) -> NixideResult<()> {
-        let registry_ptr = registry.into_c_ptr()?;
+        let c_registry = CString::new(registry).to_nixide_result()?;
 
         wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
             sys::nix_fetchers_settings_set_global_flake_registry(
                 ctx.as_ptr(),
                 self.as_ptr(),
-                registry_ptr,
+                c_registry.as_ptr() as *mut c_char,
             );
         })
         .unwrap();

nixide/src/flake/flake_lock_flags.rs

@@ -1,10 +1,9 @@
-use std::ffi::c_char;
+use std::ffi::{CString, c_char};
 use std::ptr::{self, NonNull};
 
 use super::FlakeRef;
 use crate::NixideResult;
-use crate::errors::ErrorContext;
+use crate::errors::{ErrorContext, ToNixideResult as _};
-use crate::stdext::AsCPtr as _;
 use crate::sys;
 use crate::util::wrap;
 use crate::util::wrappers::AsInnerPtr;
@@ -120,13 +119,13 @@ impl FlakeLockFlags {
     #[allow(unused)]
     pub fn override_input(self, input: &str, flakeref: &FlakeRef) -> NixideResult<Self> {
         // XXX: TODO: should `input` be wrapped as `format!("inputs.{input}")`?
-        let input_path = input.as_c_ptr()?;
+        let c_input = CString::new(input).to_nixide_result()?;
 
         wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
             sys::nix_flake_lock_flags_add_input_override(
                 ctx.as_ptr(),
                 self.as_ptr(),
-                input_path,
+                c_input.as_ptr(),
                 flakeref.as_ptr(),
             );
         })?;
@@ -148,10 +147,14 @@ impl FlakeLockFlags {
     #[allow(unused)]
     pub fn update_input(self, input: &str) -> NixideResult<Self> {
         // XXX: TODO: should `input` be wrapped as `format!("inputs.{input}")`?
-        let input_path = input.as_c_ptr()?;
+        let c_input = CString::new(input).to_nixide_result()?;
 
         wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
-            sys::nix_flake_lock_flags_add_input_update(ctx.as_ptr(), self.as_ptr(), input_path);
+            sys::nix_flake_lock_flags_add_input_update(
+                ctx.as_ptr(),
+                self.as_ptr(),
+                c_input.as_ptr(),
+            );
         })?;
 
         Ok(self)
@@ -287,13 +290,13 @@ impl FlakeLockFlags {
     ///
     #[allow(unused)]
     pub fn input_lock_file_path(self, path: &str) -> NixideResult<Self> {
-        let path_ptr = path.as_c_ptr()? as *mut c_char;
+        let c_path = CString::new(path).to_nixide_result()?;
 
         wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
             sys::nix_flake_lock_flags_set_reference_lock_file_path(
                 ctx.as_ptr(),
                 self.as_ptr(),
-                path_ptr,
+                c_path.as_ptr() as *mut c_char,
             )
         })
         .unwrap();
@@ -311,13 +314,13 @@ impl FlakeLockFlags {
     ///
     #[allow(unused)]
     pub fn output_lock_file_path(self, path: &str) -> NixideResult<Self> {
-        let path_ptr = path.as_c_ptr()? as *mut c_char;
+        let c_path = CString::new(path).to_nixide_result()?;
 
         wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
             sys::nix_flake_lock_flags_set_output_lock_file_path(
                 ctx.as_ptr(),
                 self.as_ptr(),
-                path_ptr,
+                c_path.as_ptr() as *mut c_char,
             )
         })
         .unwrap();

nixide/src/flake/flake_settings.rs

@@ -1,8 +1,8 @@
+use std::ffi::CString;
 use std::ptr::NonNull;
 
 use crate::NixideResult;
-use crate::errors::ErrorContext;
+use crate::errors::{ErrorContext, ToNixideResult as _};
-use crate::stdext::AsCPtr as _;
 use crate::sys;
 use crate::util::wrap;
 use crate::util::wrappers::AsInnerPtr;
@@ -86,12 +86,12 @@ impl FlakeSettings {
     ///
     #[allow(unused)]
     pub fn commit_lock_file_summary(self, summary: &str) -> NixideResult<Self> {
-        let summary_ptr = summary.into_c_ptr()?;
+        let c_summary = CString::new(summary).to_nixide_result()?;
         wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
             sys::nix_flake_settings_set_commit_lock_file_summary(
                 ctx.as_ptr(),
                 self.as_ptr(),
-                summary_ptr,
+                c_summary.as_ptr().cast_mut(),
             )
         })
         .unwrap();

nixide/src/flake/flakeref_builder.rs

@@ -1,10 +1,9 @@
-use std::ffi::c_void;
+use std::ffi::{CString, c_void};
 use std::path::Path;
 use std::ptr::{self, NonNull, null_mut};
 
 use super::{FetchersSettings, FlakeRef, FlakeRefParseFlags};
-use crate::errors::{ErrorContext, NixideResult, new_nixide_error};
+use crate::errors::{ErrorContext, NixideResult, ToNixideResult as _, new_nixide_error};
-use crate::stdext::AsCPtr as _;
 use crate::sys;
 use crate::util::wrap;
 use crate::util::wrappers::AsInnerPtr;
@@ -32,7 +31,7 @@ impl FlakeRefBuilder {
     }
 
     pub fn build(&self) -> NixideResult<FlakeRef> {
-        let reference_ptr = self.reference.as_c_ptr()?;
+        let c_reference = CString::new(self.reference.as_str()).to_nixide_result()?;
 
         let mut ptr: *mut sys::NixFlakeReference = null_mut();
         let fragment = wrap::nix_string_callback!(
@@ -45,7 +44,7 @@ impl FlakeRefBuilder {
                     self.fetch_settings.as_ptr(),
                     ptr::null_mut(),
                     self.parse_flags.as_ptr(),
-                    reference_ptr,
+                    c_reference.as_ptr(),
                     self.reference.len(),
                     &mut ptr,
                     Some(callback),

nixide/src/flake/flakeref_parse_flags.rs

@@ -1,7 +1,7 @@
+use std::ffi::CString;
 use std::ptr::{self, NonNull};
 
-use crate::errors::ErrorContext;
+use crate::errors::{ErrorContext, ToNixideResult as _};
-use crate::stdext::AsCPtr as _;
 use crate::util::wrap;
 use crate::util::wrappers::AsInnerPtr;
 use crate::{NixideResult, sys};
@@ -68,13 +68,13 @@ impl FlakeRefParseFlags {
     /// to the current working directory (see `libutil/filesystem.cc:absPath`).
     ///
     pub fn base_directory(&mut self, base_directory: &str) -> NixideResult<()> {
-        let base_directory_ptr = base_directory.as_c_ptr()?;
+        let c_base_directory = CString::new(base_directory).to_nixide_result()?;
 
         wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
             sys::nix_flake_reference_parse_flags_set_base_directory(
                 ctx.as_ptr(),
                 self.as_ptr(),
-                base_directory_ptr,
+                c_base_directory.as_ptr(),
                 base_directory.len(),
             );
         })

nixide/src/flake/locked_flake.rs

@@ -175,8 +175,8 @@ mod tests {
         if let Value::Attrs(outputs) = outputs {
             let value = outputs.get("hello").unwrap();
 
-            assert!(matches!(value, Value::String(_)));
+            assert!(matches!(value, Some(Value::String(_))));
-            if let Value::String(value) = value {
+            if let Some(Value::String(value)) = value {
                 assert_eq!(value.as_string(), "world");
             }
         }

nixide/src/logging.rs

@@ -1,5 +1,6 @@
-use crate::errors::ErrorContext;
+use std::ffi::CString;
-use crate::stdext::AsCPtr as _;
+
+use crate::errors::{ErrorContext, ToNixideResult as _};
 use crate::sys;
 use crate::util::wrap;
 use crate::util::wrappers::AsInnerPtr as _;
@@ -69,8 +70,10 @@ impl ToString for LogFormat {
 /// modified without nixide updating to account for this.
 ///
 pub fn set_log_format(format: LogFormat) {
+    let c_format = CString::new(format.to_string()).to_nixide_result().unwrap();
+
     wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
-        sys::nix_set_log_format(ctx.as_ptr(), format.to_string().as_c_ptr().unwrap());
+        sys::nix_set_log_format(ctx.as_ptr(), c_format.as_ptr());
     })
     .unwrap()
 }

nixide/src/nix_settings.rs

@@ -1,7 +1,7 @@
 use std::ffi::{CString, c_void};
 
 use crate::NixideResult;
-use crate::errors::{AsNixideResult as _, ErrorContext};
+use crate::errors::{ErrorContext, ToNixideResult as _};
 use crate::util::wrap;
 use crate::util::wrappers::AsInnerPtr as _;
 
@@ -11,13 +11,13 @@ use crate::util::wrappers::AsInnerPtr as _;
 /// Please prefer [nixide::FlakeSettings] and [nixide::FetchersSettings].
 ///
 pub unsafe fn get_global_setting(key: &str) -> NixideResult<String> {
-    let key = CString::new(key).to_nixide_result()?;
+    let c_key = CString::new(key).to_nixide_result()?;
 
     wrap::nix_string_callback!(
         |callback, userdata: *mut __UserData, ctx: &ErrorContext| unsafe {
             sys::nix_setting_get(
                 ctx.as_ptr(),
-                key.as_ptr(),
+                c_key.as_ptr(),
                 Some(callback),
                 userdata as *mut c_void,
             );
@@ -30,11 +30,10 @@ pub unsafe fn get_global_setting(key: &str) -> NixideResult<String> {
 /// Please prefer [nixide::FlakeSettings] and [nixide::FetchersSettings].
 ///
 pub unsafe fn set_global_setting(key: &str, value: &str) -> NixideResult<()> {
-    // DEBUG: TODO: write a convenient way to convert this to NixideResult
+    let c_key = CString::new(key).to_nixide_result()?;
-    let key = CString::new(key).unwrap();
+    let c_value = CString::new(value).to_nixide_result()?;
-    let value = CString::new(value).unwrap();
 
     wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
-        sys::nix_setting_set(ctx.as_ptr(), key.as_ptr(), value.as_ptr());
+        sys::nix_setting_set(ctx.as_ptr(), c_key.as_ptr(), c_value.as_ptr());
     })
 }

nixide/src/plugins.rs

@@ -1,6 +1,7 @@
+use std::ffi::CString;
+
 use crate::NixideResult;
-use crate::errors::ErrorContext;
+use crate::errors::{ErrorContext, ToNixideResult as _};
-use crate::stdext::AsCPtr as _;
 use crate::util::wrap;
 use crate::util::wrappers::AsInnerPtr as _;
 
@@ -11,8 +12,8 @@ pub fn load_plugins() -> NixideResult<()> {
 }
 
 pub fn register_plugin<S: AsRef<str>>(path: S) -> NixideResult<()> {
-    let path_ptr = path.as_ref().into_c_ptr()?;
+    let c_path = CString::new(path.as_ref()).to_nixide_result()?;
     wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
-        sys::nix_register_plugin(ctx.as_ptr(), path_ptr);
+        sys::nix_register_plugin(ctx.as_ptr(), c_path.as_ptr().cast_mut());
     })
 }

nixide/src/stdext/cchar_ptr.rs

@@ -5,33 +5,6 @@ use std::str::from_utf8;
 use crate::NixideResult;
 use crate::errors::new_nixide_error;
 
-pub trait AsCPtr<T> {
-    #[allow(unused)]
-    fn as_c_ptr(&self) -> NixideResult<*const T>;
-
-    #[allow(unused)]
-    fn into_c_ptr(self) -> NixideResult<*mut T>;
-}
-
-impl<T> AsCPtr<c_char> for T
-where
-    T: AsRef<str>,
-{
-    fn as_c_ptr(&self) -> NixideResult<*const c_char> {
-        match CStr::from_bytes_until_nul(self.as_ref().as_bytes()) {
-            Ok(s) => Ok(s.as_ptr()),
-            Err(_) => Err(new_nixide_error!(StringNulByte)),
-        }
-    }
-
-    fn into_c_ptr(self) -> NixideResult<*mut c_char> {
-        match CStr::from_bytes_until_nul(self.as_ref().as_bytes()) {
-            Ok(s) => Ok(s.as_ptr().cast_mut()),
-            Err(_) => Err(new_nixide_error!(StringNulByte)),
-        }
-    }
-}
-
 pub trait CCharPtrExt {
     #[allow(unused)]
     fn to_utf8_string(self) -> NixideResult<String>;

nixide/src/stdext/mod.rs

@@ -1,5 +1,5 @@
 mod cchar_ptr;
 mod slice;
 
-pub(crate) use cchar_ptr::{AsCPtr, CCharPtrExt};
+pub(crate) use cchar_ptr::CCharPtrExt;
 pub(crate) use slice::SliceExt;

nixide/src/store/mod.rs

@@ -8,14 +8,13 @@ mod path;
 pub use path::*;
 
 use std::cell::RefCell;
-use std::ffi::{c_char, c_void};
+use std::ffi::{CString, c_char, c_void};
 use std::path::PathBuf;
 use std::ptr::{NonNull, null, null_mut};
 use std::rc::Rc;
 
 use crate::NixideResult;
-use crate::errors::ErrorContext;
+use crate::errors::{ErrorContext, ToNixideResult as _};
-use crate::stdext::AsCPtr as _;
 use crate::sys;
 use crate::util::wrap;
 use crate::util::wrappers::AsInnerPtr;
@@ -58,7 +57,8 @@ impl Store {
     /// Returns an error if the store cannot be opened.
     ///
     pub fn open(uri: &str) -> NixideResult<Rc<RefCell<Self>>> {
-        unsafe { Self::open_ptr(uri.as_c_ptr()?) }
+        let c_uri = CString::new(uri).to_nixide_result()?;
+        unsafe { Self::open_ptr(c_uri.as_ptr()) }
     }
 
     /// Opens a connection to the default Nix store.