cry/nixide
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

rename FlakeRef

Browse source
This commit is contained in:
do butterflies cry? 2026-04-02 23:37:52 +10:00
parent 26c222247a
commit 03c25e234b
Signed by: cry
GPG key ID: F68745A836CA0412
6 changed files with 73 additions and 158 deletions
Download patch file Download diff file Expand all files Collapse all files

2
nixide/src/expr/eval_state_builder.rs
View file

@ -77,7 +77,6 @@ impl EvalStateBuilder {
} }
// XXX: TODO: use `flakes()` instead // XXX: TODO: use `flakes()` instead
#[deprecated]
#[cfg(feature = "flakes")] #[cfg(feature = "flakes")]
pub fn set_flake_settings(self, settings: &FlakeSettings) -> NixideResult<Self> { pub fn set_flake_settings(self, settings: &FlakeSettings) -> NixideResult<Self> {
wrap::nix_fn!(|ctx: &ErrorContext| unsafe { wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
@ -93,7 +92,6 @@ impl EvalStateBuilder {
#[cfg(feature = "flakes")] #[cfg(feature = "flakes")]
pub fn flakes(self) -> NixideResult<Self> { pub fn flakes(self) -> NixideResult<Self> {
#[allow(deprecated)]
self.set_flake_settings(&FlakeSettings::new()?) self.set_flake_settings(&FlakeSettings::new()?)
} }

11
nixide/src/flake/flake_lock_flags.rs
View file

@ -1,6 +1,6 @@
use std::ptr::NonNull; use std::ptr::NonNull;
use super::{FlakeReference, FlakeSettings}; use super::{FlakeRef, FlakeSettings};
use crate::NixideResult; use crate::NixideResult;
use crate::errors::ErrorContext; use crate::errors::ErrorContext;
use crate::stdext::AsCPtr as _; use crate::stdext::AsCPtr as _;
@ -67,7 +67,6 @@ impl AsInnerPtr<sys::NixFlakeLockFlags> for FlakeLockFlags {
} }
impl FlakeLockFlags { impl FlakeLockFlags {
// XXX: TODO: what is the default FlakeLockMode?
pub fn new(settings: &FlakeSettings) -> NixideResult<Self> { pub fn new(settings: &FlakeSettings) -> NixideResult<Self> {
let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe { let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_flake_lock_flags_new(ctx.as_ptr(), settings.as_ptr()) sys::nix_flake_lock_flags_new(ctx.as_ptr(), settings.as_ptr())
@ -76,7 +75,7 @@ impl FlakeLockFlags {
Ok(FlakeLockFlags { inner }) Ok(FlakeLockFlags { inner })
} }
pub fn set_mode(&mut self, mode: &FlakeLockMode) -> NixideResult<()> { pub fn set_mode(self, mode: FlakeLockMode) -> NixideResult<Self> {
wrap::nix_fn!(|ctx: &ErrorContext| { wrap::nix_fn!(|ctx: &ErrorContext| {
match mode { match mode {
FlakeLockMode::WriteAsNeeded => unsafe { FlakeLockMode::WriteAsNeeded => unsafe {
@ -89,7 +88,9 @@ impl FlakeLockFlags {
sys::nix_flake_lock_flags_set_mode_check(ctx.as_ptr(), self.as_ptr()) sys::nix_flake_lock_flags_set_mode_check(ctx.as_ptr(), self.as_ptr())
}, },
}; };
}) });
Ok(self)
} }
/// Adds an input override to the lock file that will be produced. /// Adds an input override to the lock file that will be produced.
@ -104,7 +105,7 @@ impl FlakeLockFlags {
/// ///
/// * `path` - The input name/path to override (must not be empty) /// * `path` - The input name/path to override (must not be empty)
/// * `flakeref` - The flake reference to use as the override /// * `flakeref` - The flake reference to use as the override
pub fn override_input(&mut self, path: &str, flakeref: &FlakeReference) -> NixideResult<()> { pub fn override_input(&mut self, path: &str, flakeref: &FlakeRef) -> NixideResult<()> {
let input_path = path.as_c_ptr()?; let input_path = path.as_c_ptr()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe { wrap::nix_fn!(|ctx: &ErrorContext| unsafe {

38
nixide/src/flake/flake_reference.rs
View file

@ -1,17 +1,19 @@
use std::ffi::{c_char, c_void}; use std::ffi::{c_char, c_void};
use std::ptr::{NonNull, null_mut}; use std::ptr::{NonNull, null_mut};
use super::{FetchersSettings, FlakeReferenceParseFlags, FlakeSettings}; use super::{FetchersSettings, FlakeRefParseFlags, FlakeSettings};
use crate::NixideError; use crate::NixideError;
use crate::errors::{ErrorContext, new_nixide_error}; use crate::errors::{ErrorContext, new_nixide_error};
use crate::sys; use crate::sys;
use crate::util::wrap; use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr; use crate::util::wrappers::AsInnerPtr;
// XXX: TODO: rename FlakeReference -> FlakeRef pub struct FlakeRef {
pub struct FlakeReference {
inner: NonNull<sys::NixFlakeReference>, inner: NonNull<sys::NixFlakeReference>,
fragment: String, fragment: String,
fetch_settings: FetchersSettings,
flake_settings: FlakeSettings,
} }
// impl Clone for FlakeReference { // impl Clone for FlakeReference {
@ -28,7 +30,7 @@ pub struct FlakeReference {
// } // }
// } // }
impl Drop for FlakeReference { impl Drop for FlakeRef {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
sys::nix_flake_reference_free(self.as_ptr()); sys::nix_flake_reference_free(self.as_ptr());
@ -36,7 +38,7 @@ impl Drop for FlakeReference {
} }
} }
impl AsInnerPtr<sys::NixFlakeReference> for FlakeReference { impl AsInnerPtr<sys::NixFlakeReference> for FlakeRef {
#[inline] #[inline]
unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReference { unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReference {
self.inner.as_ptr() self.inner.as_ptr()
@ -53,17 +55,16 @@ impl AsInnerPtr<sys::NixFlakeReference> for FlakeReference {
} }
} }
impl FlakeReference { impl FlakeRef {
/// Parse a flake reference from a string. /// Parse a flake reference from a string.
/// The string must be a valid flake reference, such as `github:owner/repo`. /// The string must be a valid flake reference, such as `github:owner/repo`.
/// It may also be suffixed with a `#` and a fragment, such as `github:owner/repo#something`, /// It may also be suffixed with a `#` and a fragment, such as `github:owner/repo#something`,
/// in which case, the returned string will contain the fragment. /// in which case, the returned string will contain the fragment.
pub fn parse( pub fn parse<S: AsRef<str>>(reference: S) -> Result<FlakeRef, NixideError> {
fetch_settings: &FetchersSettings, let fetch_settings = FetchersSettings::new()?;
flake_settings: &FlakeSettings, let flake_settings = FlakeSettings::new()?;
flags: &FlakeReferenceParseFlags, let parse_flags = FlakeRefParseFlags::new(&flake_settings)?;
reference: &str,
) -> Result<FlakeReference, NixideError> {
let mut ptr: *mut sys::NixFlakeReference = null_mut(); let mut ptr: *mut sys::NixFlakeReference = null_mut();
let fragment = wrap::nix_string_callback!( let fragment = wrap::nix_string_callback!(
|callback, userdata: *mut __UserData, ctx: &ErrorContext| unsafe { |callback, userdata: *mut __UserData, ctx: &ErrorContext| unsafe {
@ -71,9 +72,9 @@ impl FlakeReference {
ctx.as_ptr(), ctx.as_ptr(),
fetch_settings.as_ptr(), fetch_settings.as_ptr(),
flake_settings.as_ptr(), flake_settings.as_ptr(),
flags.as_ptr(), parse_flags.as_ptr(),
reference.as_ptr() as *const c_char, reference.as_ref().as_ptr() as *const c_char,
reference.len(), reference.as_ref().len(),
&mut ptr, &mut ptr,
Some(callback), Some(callback),
userdata as *mut c_void, userdata as *mut c_void,
@ -82,7 +83,12 @@ impl FlakeReference {
)?; )?;
match NonNull::new(ptr) { match NonNull::new(ptr) {
Some(inner) => Ok(FlakeReference { inner, fragment }), Some(inner) => Ok(FlakeRef {
inner,
fragment,
fetch_settings,
flake_settings,
}),
None => Err(new_nixide_error!(NullPtr)), None => Err(new_nixide_error!(NullPtr)),
} }
} }

8
nixide/src/flake/flake_reference_parse_flags.rs
View file

@ -10,7 +10,7 @@ use crate::util::wrappers::AsInnerPtr;
/// Parameters for parsing a flake reference. /// Parameters for parsing a flake reference.
#[derive(Debug)] #[derive(Debug)]
pub struct FlakeReferenceParseFlags { pub struct FlakeRefParseFlags {
inner: NonNull<sys::NixFlakeReferenceParseFlags>, inner: NonNull<sys::NixFlakeReferenceParseFlags>,
} }
@ -27,7 +27,7 @@ pub struct FlakeReferenceParseFlags {
// } // }
// } // }
impl Drop for FlakeReferenceParseFlags { impl Drop for FlakeRefParseFlags {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
sys::nix_flake_reference_parse_flags_free(self.inner.as_ptr()); sys::nix_flake_reference_parse_flags_free(self.inner.as_ptr());
@ -35,7 +35,7 @@ impl Drop for FlakeReferenceParseFlags {
} }
} }
impl AsInnerPtr<sys::NixFlakeReferenceParseFlags> for FlakeReferenceParseFlags { impl AsInnerPtr<sys::NixFlakeReferenceParseFlags> for FlakeRefParseFlags {
#[inline] #[inline]
unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReferenceParseFlags { unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReferenceParseFlags {
self.inner.as_ptr() self.inner.as_ptr()
@ -52,7 +52,7 @@ impl AsInnerPtr<sys::NixFlakeReferenceParseFlags> for FlakeReferenceParseFlags {
} }
} }
impl FlakeReferenceParseFlags { impl FlakeRefParseFlags {
pub fn new(settings: &FlakeSettings) -> NixideResult<Self> { pub fn new(settings: &FlakeSettings) -> NixideResult<Self> {
let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe { let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_flake_reference_parse_flags_new(ctx.as_ptr(), settings.as_ptr()) sys::nix_flake_reference_parse_flags_new(ctx.as_ptr(), settings.as_ptr())

168
nixide/src/flake/locked_flake.rs
View file

@ -1,8 +1,10 @@
// XXX: TODO: find a way to read directly from FlakeSettings and FetchersSettings (the C++ classes) // XXX: TODO: find a way to read directly from FlakeSettings and FetchersSettings (the C++ classes)
use std::cell::RefCell;
use std::ptr::NonNull; use std::ptr::NonNull;
use std::rc::Rc;
use super::{FetchersSettings, FlakeLockFlags, FlakeReference, FlakeSettings}; use super::{FetchersSettings, FlakeLockFlags, FlakeLockMode, FlakeRef, FlakeSettings};
use crate::errors::ErrorContext; use crate::errors::ErrorContext;
use crate::sys; use crate::sys;
use crate::util::wrap; use crate::util::wrap;
@ -12,31 +14,13 @@ use crate::{EvalState, NixideResult, Value};
pub struct LockedFlake { pub struct LockedFlake {
inner: NonNull<sys::NixLockedFlake>, inner: NonNull<sys::NixLockedFlake>,
flakeref: FlakeReference, flakeref: FlakeRef,
state: EvalState, state: Rc<RefCell<NonNull<sys::EvalState>>>,
flags: FlakeLockFlags, lock_flags: FlakeLockFlags,
fetch_settings: FetchersSettings, fetch_settings: FetchersSettings,
flake_settings: FlakeSettings, flake_settings: FlakeSettings,
} }
// impl Clone for LockedFlake {
// fn clone(&self) -> Self {
// wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
// sys::nix_gc_incref(ctx.as_ptr(), self.as_ptr() as *mut c_void);
// })
// .unwrap();
//
// Self {
// inner: self.inner.clone(),
// flakeref: self.flakeref.clone(),
// state: self.state.clone(),
// flags: self.flags.clone(),
// fetch_settings: self.fetch_settings.clone(),
// flake_settings: self.flake_settings.clone(),
// }
// }
// }
impl Drop for LockedFlake { impl Drop for LockedFlake {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
@ -64,30 +48,33 @@ impl AsInnerPtr<sys::NixLockedFlake> for LockedFlake {
impl LockedFlake { impl LockedFlake {
pub fn lock( pub fn lock(
fetch_settings: &FetchersSettings, mode: FlakeLockMode,
flake_settings: &FlakeSettings, flakeref: FlakeRef,
state: &EvalState, state: &EvalState,
flags: &FlakeLockFlags,
flakeref: &FlakeReference,
) -> NixideResult<LockedFlake> { ) -> NixideResult<LockedFlake> {
let state_inner = state.inner_ref();
let fetch_settings = FetchersSettings::new()?;
let flake_settings = FlakeSettings::new()?;
let lock_flags = FlakeLockFlags::new(&flake_settings)?.set_mode(mode)?;
let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe { let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_flake_lock( sys::nix_flake_lock(
ctx.as_ptr(), ctx.as_ptr(),
fetch_settings.as_ptr(), fetch_settings.as_ptr(),
flake_settings.as_ptr(), flake_settings.as_ptr(),
state.as_ptr(), state_inner.borrow().as_ptr(),
flags.as_ptr(), lock_flags.as_ptr(),
flakeref.as_ptr(), flakeref.as_ptr(),
) )
})?; })?;
Ok(Self { Ok(Self {
inner, inner,
flakeref: flakeref.clone(), flakeref,
state: state.clone(), state: state_inner.clone(),
flags: flags.clone(), lock_flags,
fetch_settings: fetch_settings.clone(), fetch_settings,
flake_settings: flake_settings.clone(), flake_settings,
}) })
} }
@ -97,12 +84,12 @@ impl LockedFlake {
sys::nix_locked_flake_get_output_attrs( sys::nix_locked_flake_get_output_attrs(
ctx.as_ptr(), ctx.as_ptr(),
self.flake_settings.as_ptr(), self.flake_settings.as_ptr(),
self.state.as_ptr(), self.state.borrow().as_ptr(),
self.inner.as_ptr(), self.inner.as_ptr(),
) )
})?; })?;
Ok(Value::from((value, &self.state))) Ok(Value::from((value, self.state.clone())))
} }
} }
@ -111,8 +98,8 @@ mod tests {
use std::fs; use std::fs;
use std::sync::Once; use std::sync::Once;
use super::{FetchersSettings, FlakeLockFlags, FlakeReference, FlakeSettings, LockedFlake}; use super::{FetchersSettings, FlakeLockFlags, FlakeRef, FlakeSettings, LockedFlake};
use crate::flake::{FlakeLockMode, FlakeReferenceParseFlags}; use crate::flake::{FlakeLockMode, FlakeRefParseFlags};
use crate::{EvalStateBuilder, Store, Value, set_global_setting}; use crate::{EvalStateBuilder, Store, Value, set_global_setting};
static INIT: Once = Once::new(); static INIT: Once = Once::new();
@ -167,36 +154,19 @@ mod tests {
let store_ref = Store::default().unwrap(); let store_ref = Store::default().unwrap();
let flake_settings = FlakeSettings::new().unwrap(); let flake_settings = FlakeSettings::new().unwrap();
let mut eval_state = EvalStateBuilder::new(store_ref.clone()) let eval_state = EvalStateBuilder::new(store_ref.clone())
.unwrap() .unwrap()
.set_flake_settings(&flake_settings) .set_flake_settings(&flake_settings)
.unwrap() .unwrap()
.build() .build()
.unwrap(); .unwrap();
let fetchers_settings = FetchersSettings::new().unwrap(); let flakeref =
let flake_lock_flags = FlakeLockFlags::new(&flake_settings).unwrap(); FlakeRef::parse(&format!("path:{}#subthing", tmp_dir.path().display())).unwrap();
let flakeref = FlakeReference::parse(
&fetchers_settings,
&flake_settings,
&FlakeReferenceParseFlags::new(&flake_settings).unwrap(),
&format!("path:{}#subthing", tmp_dir.path().display()),
)
.unwrap();
assert_eq!(flakeref.fragment(), "subthing"); assert_eq!(flakeref.fragment(), "subthing");
let locked_flake = LockedFlake::lock( let outputs = LockedFlake::lock(, flakeref, &eval_state).unwrap().outputs().unwrap();
&fetchers_settings,
&flake_settings,
&eval_state,
&flake_lock_flags,
&flakeref,
)
.unwrap();
let outputs = locked_flake.outputs().unwrap();
assert!(matches!(outputs, Value::Attrs(_))); assert!(matches!(outputs, Value::Attrs(_)));
if let Value::Attrs(outputs) = outputs { if let Value::Attrs(outputs) = outputs {
@ -216,7 +186,7 @@ mod tests {
let store_ref = Store::default().unwrap(); let store_ref = Store::default().unwrap();
let fetchers_settings = FetchersSettings::new().unwrap(); let fetchers_settings = FetchersSettings::new().unwrap();
let flake_settings = FlakeSettings::new().unwrap(); let flake_settings = FlakeSettings::new().unwrap();
let mut eval_state = EvalStateBuilder::new(store_ref.clone()) let eval_state = EvalStateBuilder::new(store_ref.clone())
.unwrap() .unwrap()
.set_flake_settings(&flake_settings) .set_flake_settings(&flake_settings)
.unwrap() .unwrap()
@ -281,33 +251,20 @@ mod tests {
let mut flake_lock_flags = FlakeLockFlags::new(&flake_settings).unwrap(); let mut flake_lock_flags = FlakeLockFlags::new(&flake_settings).unwrap();
let mut flake_reference_parse_flags = let mut flake_reference_parse_flags = FlakeRefParseFlags::new(&flake_settings).unwrap();
FlakeReferenceParseFlags::new(&flake_settings).unwrap();
flake_reference_parse_flags flake_reference_parse_flags
.set_base_directory(tmp_dir.path().to_str().unwrap()) .set_base_directory(tmp_dir.path().to_str().unwrap())
.unwrap(); .unwrap();
let flakeref_a = FlakeReference::parse( let flakeref_a = FlakeRef::parse(&format!("path:{}", &flake_dir_a_str)).unwrap();
&fetchers_settings,
&flake_settings,
&flake_reference_parse_flags,
&format!("path:{}", &flake_dir_a_str),
)
.unwrap();
assert_eq!(flakeref_a.fragment(), ""); assert_eq!(flakeref_a.fragment(), "");
// Step 1: Do not update (check), fails // Step 1: Do not update (check), fails
flake_lock_flags.set_mode(&FlakeLockMode::Check).unwrap(); flake_lock_flags.set_mode(&FlakeLockMode::Check).unwrap();
let locked_flake = LockedFlake::lock( let locked_flake = LockedFlake::lock(flake_lock_flags, flakeref_a, &eval_state);
&fetchers_settings,
&flake_settings,
&eval_state,
&flake_lock_flags,
&flakeref_a,
);
// Has not been locked and would need to write a lock file. // Has not been locked and would need to write a lock file.
assert!(locked_flake.is_err()); assert!(locked_flake.is_err());
let saved_err = match locked_flake { let saved_err = match locked_flake {
@ -318,14 +275,7 @@ mod tests {
// Step 2: Update but do not write, succeeds // Step 2: Update but do not write, succeeds
flake_lock_flags.set_mode(&FlakeLockMode::Virtual).unwrap(); flake_lock_flags.set_mode(&FlakeLockMode::Virtual).unwrap();
let locked_flake = LockedFlake::lock( let locked_flake = LockedFlake::lock(flake_lock_flags, flakeref_a, &eval_state).unwrap();
&fetchers_settings,
&flake_settings,
&eval_state,
&flake_lock_flags,
&flakeref_a,
)
.unwrap();
let outputs = locked_flake.outputs().unwrap(); let outputs = locked_flake.outputs().unwrap();
@ -342,13 +292,7 @@ mod tests {
// Step 3: The lock was not written, so Step 1 would fail again // Step 3: The lock was not written, so Step 1 would fail again
flake_lock_flags.set_mode(&FlakeLockMode::Check).unwrap(); flake_lock_flags.set_mode(&FlakeLockMode::Check).unwrap();
let locked_flake = LockedFlake::lock( let locked_flake = LockedFlake::lock(flake_lock_flags, flakeref_a, &eval_state);
&fetchers_settings,
&flake_settings,
&eval_state,
&flake_lock_flags,
&flakeref_a,
);
// Has not been locked and would need to write a lock file. // Has not been locked and would need to write a lock file.
match locked_flake { match locked_flake {
Ok(_) => panic!("Expected error, but got Ok"), Ok(_) => panic!("Expected error, but got Ok"),
@ -362,14 +306,7 @@ mod tests {
.set_mode(&FlakeLockMode::WriteAsNeeded) .set_mode(&FlakeLockMode::WriteAsNeeded)
.unwrap(); .unwrap();
let locked_flake = LockedFlake::lock( let locked_flake = LockedFlake::lock(flake_lock_flags, flakeref_a, &eval_state).unwrap();
&fetchers_settings,
&flake_settings,
&eval_state,
&flake_lock_flags,
&flakeref_a,
)
.unwrap();
let outputs = locked_flake.outputs().unwrap(); let outputs = locked_flake.outputs().unwrap();
@ -386,14 +323,7 @@ mod tests {
// Step 5: Lock was written, so Step 1 succeeds // Step 5: Lock was written, so Step 1 succeeds
flake_lock_flags.set_mode(&FlakeLockMode::Check).unwrap(); flake_lock_flags.set_mode(&FlakeLockMode::Check).unwrap();
let locked_flake = LockedFlake::lock( let locked_flake = LockedFlake::lock(flake_lock_flags, flakeref_a, &eval_state).unwrap();
&fetchers_settings,
&flake_settings,
&eval_state,
&flake_lock_flags,
&flakeref_a,
)
.unwrap();
let outputs = locked_flake.outputs().unwrap(); let outputs = locked_flake.outputs().unwrap();
@ -414,25 +344,12 @@ mod tests {
.set_mode(&FlakeLockMode::WriteAsNeeded) .set_mode(&FlakeLockMode::WriteAsNeeded)
.unwrap(); .unwrap();
let flakeref_c = FlakeReference::parse( let flakeref_c = FlakeRef::parse(&format!("path:{}", &flake_dir_c_str)).unwrap();
&fetchers_settings,
&flake_settings,
&flake_reference_parse_flags,
&format!("path:{}", &flake_dir_c_str),
)
.unwrap();
assert_eq!(flakeref_c.fragment(), ""); assert_eq!(flakeref_c.fragment(), "");
flake_lock_flags.override_input("b", &flakeref_c).unwrap(); flake_lock_flags.override_input("b", &flakeref_c).unwrap();
let locked_flake = LockedFlake::lock( let locked_flake = LockedFlake::lock(flake_lock_flags, flakeref_a, &eval_state).unwrap();
&fetchers_settings,
&flake_settings,
&eval_state,
&flake_lock_flags,
&flakeref_a,
)
.unwrap();
let outputs = locked_flake.outputs().unwrap(); let outputs = locked_flake.outputs().unwrap();
@ -452,14 +369,7 @@ mod tests {
// Step 7: Override was not written; lock still points to b // Step 7: Override was not written; lock still points to b
flake_lock_flags.set_mode(&FlakeLockMode::Check).unwrap(); flake_lock_flags.set_mode(&FlakeLockMode::Check).unwrap();
let locked_flake = LockedFlake::lock( let locked_flake = LockedFlake::lock(flake_lock_flags, flakeref_a, &eval_state).unwrap();
&fetchers_settings,
&flake_settings,
&eval_state,
&flake_lock_flags,
&flakeref_a,
)
.unwrap();
let outputs = locked_flake.outputs().unwrap(); let outputs = locked_flake.outputs().unwrap();

4
nixide/src/flake/mod.rs
View file

@ -7,7 +7,7 @@ mod locked_flake;
use fetchers_settings::FetchersSettings; use fetchers_settings::FetchersSettings;
use flake_lock_flags::{FlakeLockFlags, FlakeLockMode}; use flake_lock_flags::{FlakeLockFlags, FlakeLockMode};
use flake_reference::FlakeReference; use flake_reference::FlakeRef;
use flake_reference_parse_flags::FlakeReferenceParseFlags; use flake_reference_parse_flags::FlakeRefParseFlags;
pub use flake_settings::FlakeSettings; pub use flake_settings::FlakeSettings;
pub use locked_flake::LockedFlake; pub use locked_flake::LockedFlake;