nixide/src/errors/context.rs

@@ -119,6 +119,7 @@ impl Into<NixideResult<()>> for &ErrorContext {
             },
 
             sys::NixErr::Unknown => NixError::Unknown,
+            err => NixError::Undocumented(err),
         };
 
         Err(new_nixide_error!(NixError, inner, err, msg))

nixide/src/errors/error.rs

@@ -86,7 +86,7 @@ pub(crate) use new_nixide_error;
 macro_rules! retrace_nixide_error {
     ($x:expr) => {{ crate::errors::new_nixide_error!($x.err) }};
 }
-// pub(crate) use retrace_nixide_error;
+pub(crate) use retrace_nixide_error;
 
 impl std::error::Error for NixideError {}
 

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(crate) use error::{new_nixide_error, retrace_nixide_error};
 pub use error::{NixideError, NixideResult};
 pub use nix_error::NixError;

nixide/src/expr/eval_state.rs

@@ -15,7 +15,6 @@ use crate::{NixideResult, Store};
 ///
 /// This provides the main interface for evaluating Nix expressions
 /// and creating values.
-#[derive(Clone)]
 pub struct EvalState {
     inner: Rc<RefCell<NonNull<sys::EvalState>>>,
 

nixide/src/expr/eval_state_builder.rs

@@ -106,8 +106,8 @@ impl EvalStateBuilder {
     }
 
     pub fn set_lookup_path<P: AsRef<str>>(self, paths: Vec<P>) -> NixideResult<Self> {
-        // let paths_len = paths.len();
+        let paths_len = paths.len();
-        // let paths_capacity = paths.capacity();
+        let paths_capacity = paths.capacity();
 
         // XXX: TODO: use the `AsCArray` trait instead
         let mut ptrs: Vec<*const c_char> = paths

nixide/src/verbosity.rs

@@ -1,9 +1,46 @@
 use crate::errors::ErrorContext;
 use crate::sys;
-use crate::util::wrap;
 use crate::util::wrappers::AsInnerPtr as _;
+use crate::util::{panic_issue_call_failed, wrap};
 
-pub use sys::NixVerbosity;
+/// Verbosity level
+///
+/// # NOTE
+///
+/// This should be kept in sync with the C++ implementation (nix::Verbosity)
+///
+#[derive(Debug, Clone, Copy)]
+pub enum NixVerbosity {
+    Error,
+    Warn,
+    Notice,
+    Info,
+    Talkative,
+    Chatty,
+    Debug,
+    Vomit,
+}
+
+impl From<sys::NixVerbosity> for NixVerbosity {
+    fn from(level: sys::NixVerbosity) -> NixVerbosity {
+        match level {
+            sys::NixVerbosity::Error => NixVerbosity::Error,
+            sys::NixVerbosity::Warn => NixVerbosity::Warn,
+            sys::NixVerbosity::Notice => NixVerbosity::Notice,
+            sys::NixVerbosity::Info => NixVerbosity::Info,
+            sys::NixVerbosity::Talkative => NixVerbosity::Talkative,
+            sys::NixVerbosity::Chatty => NixVerbosity::Chatty,
+            sys::NixVerbosity::Debug => NixVerbosity::Debug,
+            sys::NixVerbosity::Vomit => NixVerbosity::Vomit,
+        }
+    }
+}
+
+impl Into<sys::NixVerbosity> for NixVerbosity {
+    fn into(self) -> sys::NixVerbosity {
+        self as sys::NixVerbosity
+    }
+}
 
 /// Sets the verbosity level.
 ///
@@ -30,7 +67,7 @@ pub use sys::NixVerbosity;
 ///
 pub fn set_verbosity(level: NixVerbosity) {
     wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
-        sys::nix_set_verbosity(ctx.as_ptr(), level);
+        sys::nix_set_verbosity(ctx.as_ptr(), level.into());
     })
-    .unwrap()
+    .unwrap_or_else(|err| panic_issue_call_failed!("{}", err))
 }