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

Compare commits

base: cry:20aefb99edf46a087c7e81b5fc7414e9c8721a74
Branches Tags
cry:main
..
compare: cry:91ccc02af2dc32639d18d2ac5ba86a4c677cc095
Branches Tags
cry:main

6 commits
20aefb99ed ... 91ccc02af2

Author SHA1 Message Date
_cry64
91ccc02af2
add nix .clang-format 2026-04-02 23:39:14 +10:00
_cry64
0a4cfcce7d
add custom flake+fetchers api 2026-04-02 23:38:56 +10:00
_cry64
544371e861
omg i got C binding working!! 2026-04-02 23:38:45 +10:00
_cry64
8525ea36c9
progress nix dep to 2.34.x 2026-04-02 23:38:12 +10:00
_cry64
03c25e234b
rename FlakeRef 2026-04-02 23:37:52 +10:00
_cry64
26c222247a
replace std::os::raw -> core::ffi 2026-04-02 10:40:18 +10:00
24 changed files with 722 additions and 332 deletions
Download patch file Download diff file Expand all files Collapse all files

39
.clang-format Normal file
View file

@ -0,0 +1,39 @@
#-* This file was taken directly from the official Nix repository
#-* hosted on GitHub, such that Nixide upholds the style guidelines.
#-* REF: https://github.com/NixOS/nix.git
BasedOnStyle: LLVM
IndentWidth: 4
BreakBeforeBraces: Custom
BraceWrapping:
AfterStruct: true
AfterClass: true
AfterFunction: true
AfterUnion: true
SplitEmptyRecord: false
PointerAlignment: Middle
FixNamespaceComments: true
SortIncludes: Never
#IndentPPDirectives: BeforeHash
SpaceAfterCStyleCast: true
SpaceAfterTemplateKeyword: false
AccessModifierOffset: -4
AlignAfterOpenBracket: AlwaysBreak
AlignEscapedNewlines: Left
ColumnLimit: 120
BreakStringLiterals: false
BitFieldColonSpacing: None
AllowShortFunctionsOnASingleLine: Empty
AlwaysBreakTemplateDeclarations: Yes
BinPackParameters: false
BreakConstructorInitializers: BeforeComma
EmptyLineAfterAccessModifier: Leave # change to always/never later?
EmptyLineBeforeAccessModifier: Leave
#PackConstructorInitializers: BinPack
BreakBeforeBinaryOperators: NonAssignment
AlwaysBreakBeforeMultilineStrings: true
IndentPPDirectives: AfterHash
PPIndentWidth: 2
BinPackArguments: false
BreakBeforeTernaryOperators: true
SeparateDefinitionBlocks: Always

96
.clang-tidy Normal file
View file

@ -0,0 +1,96 @@
#-* This file was taken directly from the official Nix repository
#-* hosted on GitHub, such that Nixide upholds the style guidelines.
#-* REF: https://github.com/NixOS/nix.git
UseColor: true
Checks:
- -*
- bugprone-*
# Too many warnings
- -bugprone-assignment-in-if-condition
# Too many warnings
- -bugprone-narrowing-conversions
# Kind of nonsense
- -bugprone-easily-swappable-parameters
# Too many warnings for now
- -bugprone-implicit-widening-of-multiplication-result
# Exception handling patterns in Nix
- -bugprone-empty-catch
# Many warnings
- -bugprone-unchecked-optional-access
# Many warnings, questionable lint
- -bugprone-branch-clone
# Extremely noisy before clang 19: https://github.com/llvm/llvm-project/issues/93959
- -bugprone-multi-level-implicit-pointer-conversion
# We don't compile out our asserts
- -bugprone-assert-side-effect
# TODO: figure out if this warning is useful
- -bugprone-exception-escape
# We use pointers to aggregates intentionally; void * would look weird
- -bugprone-sizeof-expression
#
# Checks disabled to pass on current codebase (can be progressively enabled):
#
# 11 warnings - optional value conversions in various places
- -bugprone-optional-value-conversion
# 4 warnings - switches without default cases
- -bugprone-switch-missing-default-case
# 4 warnings - string_view::data() usage patterns
- -bugprone-suspicious-stringview-data-usage
# 4 warnings - .cc files included in other files (intentional pattern)
- -bugprone-suspicious-include
# 2 warnings - unused return values (AllowCastToVoid helps but some remain)
- -bugprone-unused-return-value
# 2 warnings - unused local RAII-style variables
- -bugprone-unused-local-non-trivial-variable
# 2 warnings - returning const& from parameter
- -bugprone-return-const-ref-from-parameter
# 1 warning - unsafe C functions (e.g., getenv)
- -bugprone-unsafe-functions
# 1 warning - signed char misuse
- -bugprone-signed-char-misuse
# 1 warning - calling parent virtual instead of override
- -bugprone-parent-virtual-call
# 1 warning - null termination issues
- -bugprone-not-null-terminated-result
# 1 warning - macro parentheses
- -bugprone-macro-parentheses
# 1 warning - increment/decrement in conditions
- -bugprone-inc-dec-in-conditions
# 2 warnings - std::move on forwarding reference (auto&&) in ranges lambdas
- -bugprone-move-forwarding-reference
# 2 warnings - coroutine pattern: co_await await(std::move(waitees)) then reuse.
# Relies on moved-from containers being empty (holds for libstdc++/libc++).
- -bugprone-use-after-move
# 2 warnings - sorts Value* by ->string_view(), not by pointer value (false positive)
- -bugprone-nondeterministic-pointer-iteration-order
# 9 warnings - intentional std::bit_cast/memcpy on Value* arrays (evaluator hot path)
- -bugprone-bitwise-pointer-cast
# 1 warning (header) - value.hh mkFailed: GC alloc in noexcept. Boehm's
# gc_cleanup::operator new isn't marked noexcept but aborts on OOM rather
# than throws; std::terminate here is the intended behavior anyway.
- -bugprone-unhandled-exception-at-new
# 1 warning (header) - fmt.hh Magenta<T>::operator<<: generic colorizer
# template; fires when T=unsigned char but that instantiation is correct.
- -bugprone-unintended-char-ostream-output
#
# Non-bugprone checks (also disabled to pass on current codebase):
#
# 4 warnings - exceptions not derived from std::exception
# All thrown exceptions must derive from std::exception
# - hicpp-exception-baseclass
# 88 warnings - C-style casts should be explicit about intent
# - cppcoreguidelines-pro-type-cstyle-cast
# 11 warnings - coroutine lambdas with captures (intentional pattern in async goal/store code)
# - cppcoreguidelines-avoid-capturing-lambda-coroutines
# Custom nix checks (when added)
- nix-*
CheckOptions:
# __asan_default_options: ASAN runtime configuration function (see nix-meson-build-support/common/asan-options/)
# __wrap___assert_fail: Linker-wrapped assert handler for better stack traces (see nix-meson-build-support/common/assert-fail/)
# _SingleDerivedPathRaw, _DerivedPathRaw: Internal type aliases in derived-path.hh (leading underscore pattern)
# _SingleBuiltPathRaw, _BuiltPathRaw: Internal type aliases in built-path.hh (leading underscore pattern)
bugprone-reserved-identifier.AllowedIdentifiers: '__asan_default_options;__wrap___assert_fail;_SingleDerivedPathRaw;_DerivedPathRaw;_SingleBuiltPathRaw;_BuiltPathRaw'
# Allow explicitly discarding return values with (void) cast
bugprone-unused-return-value.AllowCastToVoid: true

3
TODO.md
View file

@ -1,3 +0,0 @@
- [ ] rename all `::std::os::raw` instances to ``::core::ffi`
- [ ] I probably don't need my implementations of `NixError` and `NixVerbosity` now, I could just re-export them for sys

8
flake.lock generated
View file

@ -23,16 +23,16 @@
},
"nixpkgs": {
"locked": {
"lastModified": 1773222311,
"narHash": "sha256-BHoB/XpbqoZkVYZCfXJXfkR+GXFqwb/4zbWnOr2cRcU=",
"lastModified": 1775036866,
"narHash": "sha256-ZojAnPuCdy657PbTq5V0Y+AHKhZAIwSIT2cb8UgAz/U=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "0590cd39f728e129122770c029970378a79d076a",
"rev": "6201e203d09599479a3b3450ed24fa81537ebc4e",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixos-25.11",
"ref": "nixos-unstable",
"repo": "nixpkgs",
"type": "github"
}

6
flake.nix
View file

@ -2,7 +2,7 @@
description = "rust wrapper for libnix";
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.11";
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
systems.url = "github:nix-systems/default";
fenix = {
@ -49,7 +49,7 @@
...
}: {
default = let
nixForBindings = pkgs.nixVersions.nix_2_32;
nixForBindings = pkgs.nixVersions.nix_2_34;
inherit (pkgs.rustc) llvmPackages;
in
pkgs.mkShell rec {
@ -113,7 +113,7 @@
};
nightly = let
nixForBindings = pkgs.nixVersions.nix_2_32;
nixForBindings = pkgs.nixVersions.nix_2_34;
inherit (pkgs.rustc) llvmPackages;
in
pkgs.mkShell rec {

79
nixide-sys/build.rs
View file

@ -23,11 +23,6 @@ impl ParseCallbacks for DoxygenCallbacks {
}
}
/// Bindfmt is just the name im giving to the callbacks
/// that handle renaming C/C++ tokens.
#[derive(Debug)]
struct BindfmtCallbacks;
#[inline]
fn strip_variant_prefix(
prefix: &'static str,
@ -43,6 +38,11 @@ fn strip_variant_prefix(
))
}
/// Bindfmt is just the name im giving to the callbacks
/// that handle renaming C/C++ tokens.
#[derive(Debug)]
struct BindfmtCallbacks;
impl ParseCallbacks for BindfmtCallbacks {
fn enum_variant_name(
&self,
@ -57,7 +57,9 @@ impl ParseCallbacks for BindfmtCallbacks {
"NixErr" => strip_variant_prefix("NixErr", enum_name, &variant)
.or_else(|_| strip_variant_prefix("Nix", enum_name, &variant))
.unwrap(),
"ValueType" => strip_variant_prefix("NixType", enum_name, &variant).unwrap(),
"ValueType" => strip_variant_prefix("NixType", enum_name, &variant)
.or_else(|_| strip_variant_prefix("N", enum_name, &variant))
.unwrap(),
_ => variant,
})
}
@ -106,14 +108,38 @@ fn main() {
.unique()
.collect();
let clang_args: Vec<String> = vec!["-x", "c++", "-std=c++23"]
.into_iter()
.map(|s: &str| s.to_owned())
.chain(include_paths.iter().map(|p| format!("-I{}", p.display())))
.collect();
// let clang_target = format!(
// "--target={}",
// env::var("CARGO_BUILD_TARGET")
// .expect("Environment variable `CARGO_BUILD_TARGET` not set! nixide/build.rs won't be able to set pointer sizes correctly!"));
let clang_args: Vec<String> = vec![
"-x",
"c++",
"-std=c++23",
"--target=x86_64-unknown-linux-gnu", // DEBUG
]
.into_iter()
.map(|s: &str| s.to_owned())
.chain(include_paths.iter().map(|p| format!("-I{}", p.display())))
.collect();
dbg!(&clang_args);
cc::Build::new()
// .cargo_output(true)
// .cargo_warnings(true)
// .cargo_metadata(true)
// .cargo_debug(cfg!(debug_assertions))
.cpp(true)
.std("c++23") // libnix compiles against `-std=c++23`
.cpp_link_stdlib("stdc++") // use libstdc++
.flags(["-fconcepts-diagnostics-depth=2"])
.file("libnixide-c/nixide_api_flake.cc")
.file("libnixide-c/nixide_api_fetchers.cc")
// .files(LIBS.iter().map(|s| (*s).strip_prefix("nix-").unwrap().strip_suffix("-c").unwrap()))
.includes(&include_paths)
.compile("libnixide");
let mut builder = bindgen::Builder::default()
.rust_edition(RustEdition::Edition2024)
.clang_args(clang_args)
@ -124,25 +150,44 @@ fn main() {
// Format generated bindings with rustfmt
.formatter(bindgen::Formatter::Rustfmt)
.rustfmt_configuration_file(std::fs::canonicalize("rustfmt.toml").ok())
// Control allow/block listing
.allowlist_recursively(true) // DEBUG(TEMP): should remain `false`
// .allowlist_file(r".*nix_api_[a-z]+(_internal)?\.h")
.allowlist_file(r".*nix_api_[a-z]+\.h")
// Wrap all unsafe operations in unsafe blocks
.layout_tests(true)
// .allowlist_type("nix_.*")
// .allowlist_function("nix_.*")
// DEBUG
// .allowlist_type(r"nix_locked_flake")
// .allowlist_type(r"nix_flake_settings")
// .allowlist_type(r"nix_flake_reference")
// .allowlist_type(r"nix_flake_reference_parse_flags")
// .allowlist_type(r"nix_flake_lock_flags")
// DEBUG
// .allowlist_file(r".+-gcc-14\.3\.0/include/c\+\+/14\.3\.0/optional") // allow optional type
// .blocklist_file(r".*-gcc-[^/]+/include/c++/[0-9\.]+/^(optional).*") // allow optional type
// .blocklist_file(r".*-(glibc|clang-wrapper|boost)-.*") // block stdlib (gcc|glibc|clang-wrapper|boost)
// .blocklist_type(r".*Optional.*")
.layout_tests(false) // DEBUG
.use_core() // use ::core instead of ::std
.ctypes_prefix("::core::ffi") // use ::core::ffi instead of ::std::os::raw
.time_phases(true)
// Wrap all unsafe operations in unsafe blocks
.wrap_unsafe_ops(true)
.trust_clang_mangling(true)
.respect_cxx_access_specs(true)
.default_enum_style(bindgen::EnumVariation::Rust { non_exhaustive: false })
.translate_enum_integer_types(false)
// .translate_enum_integer_types(false)
.size_t_is_usize(true)
.use_distinct_char16_t(false)
.use_distinct_char16_t(false) // DEBUG (comment this)
.generate_comments(false)
.generate_cstr(true) // use &CStr instead of &[u8]
.fit_macro_constants(true)
.fit_macro_constants(true) // DEBUG (comment this)
.explicit_padding(true)
.enable_cxx_namespaces()
.represent_cxx_operators(true)
.represent_cxx_operators(false) // DEBUG (comment this)
.enable_function_attribute_detection()
.raw_line("/** These bindings were auto-generated for the Nixide project (https://github.com/cry128/nixide) */");

3
nixide-sys/include/nix-fetchers.h
View file

@ -1,9 +1,10 @@
#ifndef NIXIDE_FETCHERS
#define NIXIDE_FETCHERS
// #include <nix_api_fetchers_internal.hh>
// Nix C API for fetcher operations.
//
#include <nix_api_fetchers.h>
// #include <nix_api_fetchers_internal.hh>
#endif

3
nixide-sys/include/nix-flake.h
View file

@ -1,9 +1,10 @@
#ifndef NIXIDE_FLAKE
#define NIXIDE_FLAKE
// #include <nix_api_flake_internal.hh>
// Nix C API for flake support.
//
#include <nix_api_flake.h>
// #include <nix_api_flake_internal.hh>
#endif

86
nixide-sys/libnixide-c/nixide_api_fetchers.cc Normal file
View file

@ -0,0 +1,86 @@
#include "nix_api_util_internal.h"
#include "nix_api_fetchers_internal.hh"
#include "nix/fetchers/fetch-settings.hh"
extern "C" {
// nix_err nix_fetchers_settings_add_access_token(
// nix_c_context * context, nix_fetchers_settings * settings, char * tokenName, char * tokenValue)
// {
// nix_clear_err(context);
// try {
// settings->settings->accessTokens.emplace(std::string(tokenName), std::string(tokenValue));
// }
// NIXC_CATCH_ERRS
// }
// nix_err
// nix_fetchers_settings_remove_access_token(nix_c_context * context, nix_fetchers_settings * settings, char *
// tokenName)
// {
// nix_clear_err(context);
// try {
// settings->settings->accessTokens.erase(std::string(tokenName));
// }
// NIXC_CATCH_ERRS
// }
nix_err nix_fetchers_settings_set_allow_dirty(nix_c_context * context, nix_fetchers_settings * settings, bool value)
{
nix_clear_err(context);
try {
settings->settings->allowDirty = value;
}
NIXC_CATCH_ERRS
}
nix_err nix_fetchers_settings_set_warn_dirty(nix_c_context * context, nix_fetchers_settings * settings, bool value)
{
nix_clear_err(context);
try {
settings->settings->warnDirty = value;
}
NIXC_CATCH_ERRS
}
nix_err
nix_fetchers_settings_set_allow_dirty_locks(nix_c_context * context, nix_fetchers_settings * settings, bool value)
{
nix_clear_err(context);
try {
settings->settings->allowDirtyLocks = value;
}
NIXC_CATCH_ERRS
}
nix_err nix_fetchers_settings_set_trust_tarballs_from_git_forges(
nix_c_context * context, nix_fetchers_settings * settings, bool value)
{
nix_clear_err(context);
try {
settings->settings->trustTarballsFromGitForges = value;
}
NIXC_CATCH_ERRS
}
nix_err nix_fetchers_settings_set_global_flake_registry(
nix_c_context * context, nix_fetchers_settings * settings, char * registry)
{
nix_clear_err(context);
try {
settings->settings->flakeRegistry = registry;
}
NIXC_CATCH_ERRS
}
nix_err nix_fetchers_settings_set_tarball_ttl(nix_c_context * context, nix_fetchers_settings * settings, uint ttl)
{
nix_clear_err(context);
try {
settings->settings->tarballTtl = ttl;
}
NIXC_CATCH_ERRS
}
} // extern "C"

36
nixide-sys/libnixide-c/nixide_api_fetchers.h Normal file
View file

@ -0,0 +1,36 @@
#ifndef NIXIDE_API_FETCHERS_H
#define NIXIDE_API_FETCHERS_H
#include "nix_api_fetchers.h"
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
nix_err nix_fetchers_settings_add_access_token(
nix_c_context * context, nix_fetchers_settings * settings, char * tokenName, char * tokenValue);
nix_err
nix_fetchers_settings_remove_access_token(nix_c_context * context, nix_fetchers_settings * settings, char * tokenName);
nix_err nix_fetchers_settings_set_allow_dirty(nix_c_context * context, nix_fetchers_settings * settings, bool value);
nix_err nix_fetchers_settings_set_warn_dirty(nix_c_context * context, nix_fetchers_settings * settings, bool value);
nix_err
nix_fetchers_settings_set_allow_dirty_locks(nix_c_context * context, nix_fetchers_settings * settings, bool value);
nix_err nix_fetchers_settings_set_trust_tarballs_from_git_forges(
nix_c_context * context, nix_fetchers_settings * settings, bool value);
nix_err nix_fetchers_settings_set_global_flake_registry(
nix_c_context * context, nix_fetchers_settings * settings, char * registry);
nix_err nix_fetchers_settings_set_tarball_ttl(nix_c_context * context, nix_fetchers_settings * settings, uint ttl);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // NIXIDE_API_FETCHERS_H

154
nixide-sys/libnixide-c/nixide_api_flake.cc Normal file
View file

@ -0,0 +1,154 @@
// #include <string>
// #include "nix_api_flake.h"
#include "nix_api_flake_internal.hh"
// #include "nix_api_util.h"
#include "nix_api_util_internal.h"
// #include "nix_api_expr_internal.h"
// #include "nix_api_fetchers_internal.hh"
// #include "nix_api_fetchers.h"
#include "nix/flake/flake.hh"
// #include "nixide_api_flake.h"
extern "C" {
nix_err nix_flake_lock_flags_set_recreate_lock_file(nix_c_context * context, nix_flake_lock_flags * flags, bool value)
{
nix_clear_err(context);
try {
flags->lockFlags->recreateLockFile = value;
}
NIXC_CATCH_ERRS
}
nix_err nix_flake_lock_flags_set_update_lock_file(nix_c_context * context, nix_flake_lock_flags * flags, bool value)
{
nix_clear_err(context);
try {
flags->lockFlags->updateLockFile = value;
}
NIXC_CATCH_ERRS
}
nix_err nix_flake_lock_flags_set_write_lock_file(nix_c_context * context, nix_flake_lock_flags * flags, bool value)
{
nix_clear_err(context);
try {
flags->lockFlags->writeLockFile = value;
}
NIXC_CATCH_ERRS
}
nix_err nix_flake_lock_flags_set_fail_on_unlocked(nix_c_context * context, nix_flake_lock_flags * flags, bool value)
{
nix_clear_err(context);
try {
flags->lockFlags->failOnUnlocked = value;
}
NIXC_CATCH_ERRS
}
nix_err nix_flake_lock_flags_set_use_registries(nix_c_context * context, nix_flake_lock_flags * flags, bool value)
{
nix_clear_err(context);
try {
flags->lockFlags->useRegistries = value;
}
NIXC_CATCH_ERRS
}
nix_err nix_flake_lock_flags_set_apply_nix_config(nix_c_context * context, nix_flake_lock_flags * flags, bool value)
{
nix_clear_err(context);
try {
flags->lockFlags->applyNixConfig = value;
}
NIXC_CATCH_ERRS
}
nix_err nix_flake_lock_flags_set_allow_unlocked(nix_c_context * context, nix_flake_lock_flags * flags, bool value)
{
nix_clear_err(context);
try {
flags->lockFlags->allowUnlocked = value;
}
NIXC_CATCH_ERRS
}
nix_err nix_flake_lock_flags_set_commit_lock_file(nix_c_context * context, nix_flake_lock_flags * flags, bool value)
{
nix_clear_err(context);
try {
flags->lockFlags->commitLockFile = value;
}
NIXC_CATCH_ERRS
}
nix_err
nix_flake_lock_flags_set_reference_lock_file_path(nix_c_context * context, nix_flake_lock_flags * flags, char * path)
{
nix_clear_err(context);
try {
auto accessor = nix::getFSSourceAccessor();
nix::CanonPath canon(path);
flags->lockFlags->referenceLockFilePath = nix::SourcePath(accessor, canon);
}
NIXC_CATCH_ERRS
}
nix_err
nix_flake_lock_flags_set_output_lock_file_path(nix_c_context * context, nix_flake_lock_flags * flags, char * outputPath)
{
nix_clear_err(context);
try {
flags->lockFlags->outputLockFilePath = outputPath;
}
NIXC_CATCH_ERRS
}
nix_err
nix_flake_lock_flags_add_input_update(nix_c_context * context, nix_flake_lock_flags * flags, const char * inputPath)
{
nix_clear_err(context);
try {
auto path = nix::flake::NonEmptyInputAttrPath::parse(inputPath);
if (!path)
throw nix::UsageError(
"input override path cannot be zero-length; it would refer to the flake itself, not an input");
flags->lockFlags->inputUpdates.emplace(std::move(*path));
}
NIXC_CATCH_ERRS
}
/* nix_flake_settings */
nix_err nix_flake_settings_set_use_registries(nix_c_context * context, nix_flake_settings * settings, bool value)
{
nix_clear_err(context);
try {
settings->settings->useRegistries = value;
}
NIXC_CATCH_ERRS
}
nix_err nix_flake_settings_set_accept_flake_config(nix_c_context * context, nix_flake_settings * settings, bool value)
{
nix_clear_err(context);
try {
settings->settings->acceptFlakeConfig = value;
}
NIXC_CATCH_ERRS
}
nix_err
nix_flake_settings_set_commit_lock_file_summary(nix_c_context * context, nix_flake_settings * settings, char * summary)
{
nix_clear_err(context);
try {
settings->settings->commitLockFileSummary = summary;
}
NIXC_CATCH_ERRS
}
} // extern "C"

47
nixide-sys/libnixide-c/nixide_api_flake.h Normal file
View file

@ -0,0 +1,47 @@
#ifndef NIXIDE_API_FLAKE_H
#define NIXIDE_API_FLAKE_H
#include "nix_api_flake.h"
#ifdef __cplusplus
extern "C" {
#endif
nix_err nix_flake_lock_flags_set_recreate_lock_file(nix_c_context * context, nix_flake_lock_flags * flags, bool value);
nix_err nix_flake_lock_flags_set_update_lock_file(nix_c_context * context, nix_flake_lock_flags * flags, bool value);
nix_err nix_flake_lock_flags_set_write_lock_file(nix_c_context * context, nix_flake_lock_flags * flags, bool value);
nix_err nix_flake_lock_flags_set_fail_on_unlocked(nix_c_context * context, nix_flake_lock_flags * flags, bool value);
nix_err nix_flake_lock_flags_set_use_registries(nix_c_context * context, nix_flake_lock_flags * flags, bool value);
nix_err nix_flake_lock_flags_set_apply_nix_config(nix_c_context * context, nix_flake_lock_flags * flags, bool value);
nix_err nix_flake_lock_flags_set_allow_unlocked(nix_c_context * context, nix_flake_lock_flags * flags, bool value);
nix_err nix_flake_lock_flags_set_commit_lock_file(nix_c_context * context, nix_flake_lock_flags * flags, bool value);
nix_err
nix_flake_lock_flags_set_reference_lock_file_path(nix_c_context * context, nix_flake_lock_flags * flags, char * path);
nix_err
nix_flake_lock_flags_set_output_lock_file_path(nix_c_context * context, nix_flake_lock_flags * flags, char * path);
nix_err
nix_flake_lock_flags_add_input_update(nix_c_context * context, nix_flake_lock_flags * flags, const char * inputPath);
/* nix_flake_settings */
nix_err nix_flake_settings_set_use_registries(nix_c_context * context, nix_flake_settings * settings, bool value);
nix_err nix_flake_settings_set_accept_flake_config(nix_c_context * context, nix_flake_settings * settings, bool value);
nix_err
nix_flake_settings_set_commit_lock_file_summary(nix_c_context * context, nix_flake_settings * settings, char * summary);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // NIXIDE_API_FLAKE_H

49
nixide-sys/tests/eval.rs
View file

@ -1,8 +1,9 @@
#![cfg(feature = "nix-expr-c")]
#![cfg(test)]
use std::ffi::{CStr, CString};
use std::ptr;
use ::core::ffi::{CStr, c_char, c_uint, c_void};
use ::std::ffi::CString;
use ::std::{f64, ptr, slice};
use serial_test::serial;
@ -23,7 +24,7 @@ fn eval_init_and_state_build() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}");
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -58,7 +59,7 @@ fn eval_simple_expression() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}");
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -119,12 +120,9 @@ fn value_construction_and_inspection() {
// Float
let float_val = nix_alloc_value(ctx, state);
assert!(!float_val.is_null());
assert_eq!(
nix_init_float(ctx, float_val, std::f64::consts::PI),
NixErr::Ok
);
assert_eq!(nix_init_float(ctx, float_val, f64::consts::PI), NixErr::Ok);
assert_eq!(nix_get_type(ctx, float_val), ValueType::Float);
assert!((nix_get_float(ctx, float_val) - std::f64::consts::PI).abs() < 1e-10);
assert!((nix_get_float(ctx, float_val) - f64::consts::PI).abs() < 1e-10);
// Bool
let bool_val = nix_alloc_value(ctx, state);
@ -145,13 +143,9 @@ fn value_construction_and_inspection() {
let s = CString::new("hello world").unwrap();
assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), NixErr::Ok);
assert_eq!(nix_get_type(ctx, string_val), ValueType::String);
extern "C" fn string_cb(
start: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_uint,
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
extern "C" fn string_cb(start: *const c_char, n: c_uint, user_data: *mut c_void) {
let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>();
unsafe { *out = Some(s.to_string()) };
}
@ -399,8 +393,7 @@ fn realised_string_and_gc() {
assert!(!realised.is_null());
let buf = nix_realised_string_get_buffer_start(realised);
let len = nix_realised_string_get_buffer_size(realised);
let realised_str =
std::str::from_utf8(std::slice::from_raw_parts(buf.cast::<u8>(), len)).unwrap();
let realised_str = str::from_utf8(slice::from_raw_parts(buf.cast::<u8>(), len)).unwrap();
assert_eq!(realised_str, "hello world");
assert_eq!(nix_realised_string_get_store_path_count(realised), 0);
@ -496,7 +489,7 @@ fn multi_argument_function_calls() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -584,7 +577,7 @@ fn curried_function_evaluation() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -713,7 +706,7 @@ fn thunk_creation_with_init_apply() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -792,7 +785,7 @@ fn lookup_path_configuration() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -806,7 +799,7 @@ fn lookup_path_configuration() {
let lookup_path_ptrs: Vec<*const _> = lookup_paths.iter().map(|s| s.as_ptr()).collect();
let mut lookup_path_ptrs_null_terminated = lookup_path_ptrs;
lookup_path_ptrs_null_terminated.push(std::ptr::null());
lookup_path_ptrs_null_terminated.push(ptr::null());
let set_lookup_err = nix_eval_state_builder_set_lookup_path(
ctx,
@ -869,7 +862,7 @@ fn complex_nested_evaluation() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -992,7 +985,7 @@ fn evaluation_error_handling() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -1043,10 +1036,10 @@ fn evaluation_error_handling() {
assert_ne!(error_code, NixErr::Ok);
// Try to get error message
let mut error_len: std::os::raw::c_uint = 0;
let mut error_len: c_uint = 0;
let error_msg_ptr = nix_err_msg(ctx, ctx, &mut error_len as *mut _);
if !error_msg_ptr.is_null() && error_len > 0 {
let error_msg = std::str::from_utf8(std::slice::from_raw_parts(
let error_msg = str::from_utf8(slice::from_raw_parts(
error_msg_ptr as *const u8,
error_len as usize,
))
@ -1123,7 +1116,7 @@ fn builtin_function_calls() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);

44
nixide-sys/tests/memory.rs
View file

@ -1,7 +1,9 @@
#![cfg(feature = "nix-expr-c")]
#![cfg(test)]
use core::ffi::{c_char, c_uint, c_void};
use std::ffi::CString;
use std::{ptr, slice, str};
use serial_test::serial;
@ -23,7 +25,7 @@ fn value_reference_counting() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -87,7 +89,7 @@ fn general_gc_reference_counting() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -111,7 +113,7 @@ fn general_gc_reference_counting() {
assert_eq!(init_err, NixErr::Ok);
// Test general GC reference counting
let gc_incref_err = nix_gc_incref(ctx, value as *const ::std::os::raw::c_void);
let gc_incref_err = nix_gc_incref(ctx, value as *const c_void);
assert_eq!(gc_incref_err, NixErr::Ok);
// Value should still be accessible
@ -119,7 +121,7 @@ fn general_gc_reference_counting() {
assert_eq!(value_type, ValueType::String);
// Test GC decrement
let gc_decref_err = nix_gc_decref(ctx, value as *const ::std::os::raw::c_void);
let gc_decref_err = nix_gc_decref(ctx, value as *const c_void);
assert_eq!(gc_decref_err, NixErr::Ok);
// Final cleanup
@ -147,7 +149,7 @@ fn manual_garbage_collection() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -205,7 +207,7 @@ fn value_copying_and_memory_management() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -240,12 +242,12 @@ fn value_copying_and_memory_management() {
// Test string contents using callback
unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_uint,
user_data: *mut ::std::os::raw::c_void,
start: *const c_char,
n: c_uint,
user_data: *mut c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap_or("");
let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = str::from_utf8(s).unwrap_or("");
let result = unsafe { &mut *(user_data as *mut Option<String>) };
*result = Some(s.to_string());
}
@ -257,14 +259,14 @@ fn value_copying_and_memory_management() {
ctx,
original,
Some(string_callback),
&mut original_string as *mut Option<String> as *mut ::std::os::raw::c_void,
&mut original_string as *mut Option<String> as *mut c_void,
);
let _ = nix_get_string(
ctx,
copy,
Some(string_callback),
&mut copy_string as *mut Option<String> as *mut ::std::os::raw::c_void,
&mut copy_string as *mut Option<String> as *mut c_void,
);
// Both should have the same string content
@ -315,7 +317,7 @@ fn complex_value_memory_management() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -442,20 +444,20 @@ fn memory_management_error_conditions() {
assert!(!ctx.is_null());
// Test reference counting with NULL pointers (should handle gracefully)
let null_incref_err = nix_gc_incref(ctx, std::ptr::null() as *const ::std::os::raw::c_void);
let null_incref_err = nix_gc_incref(ctx, ptr::null() as *const c_void);
// XXX: May succeed or fail depending on implementation. We can't really
// know, so assert both.
assert!(null_incref_err == NixErr::Ok || null_incref_err == NixErr::Unknown);
let null_decref_err = nix_gc_decref(ctx, std::ptr::null() as *const ::std::os::raw::c_void);
let null_decref_err = nix_gc_decref(ctx, ptr::null() as *const c_void);
assert!(null_decref_err == NixErr::Ok || null_decref_err == NixErr::Unknown);
let null_value_incref_err = nix_value_incref(ctx, std::ptr::null_mut());
let null_value_incref_err = nix_value_incref(ctx, ptr::null_mut());
// Some Nix APIs gracefully handle null pointers and return OK
assert!(null_value_incref_err == NixErr::Ok || null_value_incref_err == NixErr::Unknown);
let null_value_decref_err = nix_value_decref(ctx, std::ptr::null_mut());
let null_value_decref_err = nix_value_decref(ctx, ptr::null_mut());
// Some Nix APIs gracefully handle null pointers and return OK
assert!(null_value_decref_err == NixErr::Ok || null_value_decref_err == NixErr::Unknown);
@ -469,7 +471,7 @@ fn memory_management_error_conditions() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -485,10 +487,10 @@ fn memory_management_error_conditions() {
assert!(!valid_value.is_null());
// Test copying to/from NULL
let copy_from_null_err = nix_copy_value(ctx, valid_value, std::ptr::null_mut());
let copy_from_null_err = nix_copy_value(ctx, valid_value, ptr::null_mut());
assert_ne!(copy_from_null_err, NixErr::Ok);
let copy_to_null_err = nix_copy_value(ctx, std::ptr::null_mut(), valid_value);
let copy_to_null_err = nix_copy_value(ctx, ptr::null_mut(), valid_value);
assert_ne!(copy_to_null_err, NixErr::Ok);
// Clean up

78
nixide-sys/tests/primop.rs
View file

@ -1,8 +1,10 @@
#![cfg(feature = "nix-expr-c")]
#![cfg(test)]
use core::ffi::{c_char, c_uint, c_void};
use std::ffi::CString;
use std::sync::atomic::{AtomicU32, Ordering};
use std::{ptr, slice};
use serial_test::serial;
@ -16,7 +18,7 @@ struct TestPrimOpData {
// Simple PrimOp that adds 1 to an integer argument
unsafe extern "C" fn add_one_primop(
user_data: *mut ::std::os::raw::c_void,
user_data: *mut c_void,
context: *mut NixCContext,
state: *mut EvalState,
args: *mut *mut NixValue,
@ -81,7 +83,7 @@ unsafe extern "C" fn add_one_primop(
// PrimOp that returns a constant string
unsafe extern "C" fn hello_world_primop(
_user_data: *mut ::std::os::raw::c_void,
_user_data: *mut c_void,
context: *mut NixCContext,
_state: *mut EvalState,
_args: *mut *mut NixValue,
@ -93,7 +95,7 @@ unsafe extern "C" fn hello_world_primop(
// PrimOp that takes multiple arguments and concatenates them
unsafe extern "C" fn concat_strings_primop(
_user_data: *mut ::std::os::raw::c_void,
_user_data: *mut c_void,
context: *mut NixCContext,
state: *mut EvalState,
args: *mut *mut NixValue,
@ -135,12 +137,12 @@ unsafe extern "C" fn concat_strings_primop(
// Get string value using callback
unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_uint,
user_data: *mut ::std::os::raw::c_void,
start: *const c_char,
n: c_uint,
user_data: *mut c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap_or("");
let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = str::from_utf8(s).unwrap_or("");
let result = unsafe { &mut *(user_data as *mut String) };
result.push_str(s);
}
@ -150,7 +152,7 @@ unsafe extern "C" fn concat_strings_primop(
context,
arg,
Some(string_callback),
&mut result as *mut String as *mut ::std::os::raw::c_void,
&mut result as *mut String as *mut c_void,
)
};
}
@ -175,7 +177,7 @@ fn primop_allocation_and_registration() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -198,7 +200,7 @@ fn primop_allocation_and_registration() {
let arg_names = [CString::new("x").unwrap()];
let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
arg_name_ptrs_null_terminated.push(std::ptr::null());
arg_name_ptrs_null_terminated.push(ptr::null());
let name = CString::new("addOne").unwrap();
let doc = CString::new("Add 1 to the argument").unwrap();
@ -211,7 +213,7 @@ fn primop_allocation_and_registration() {
name.as_ptr(),
arg_name_ptrs_null_terminated.as_mut_ptr(),
doc.as_ptr(),
test_data_ptr as *mut ::std::os::raw::c_void,
test_data_ptr as *mut c_void,
);
if !primop.is_null() {
@ -259,7 +261,7 @@ fn primop_function_call() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -281,7 +283,7 @@ fn primop_function_call() {
// Create simple hello world PrimOp (no arguments)
let name = CString::new("helloWorld").unwrap();
let doc = CString::new("Returns hello world string").unwrap();
let mut empty_args: Vec<*const ::std::os::raw::c_char> = vec![std::ptr::null()];
let mut empty_args: Vec<*const c_char> = vec![ptr::null()];
let hello_primop = nix_alloc_primop(
ctx,
@ -290,7 +292,7 @@ fn primop_function_call() {
name.as_ptr(),
empty_args.as_mut_ptr(),
doc.as_ptr(),
std::ptr::null_mut(),
ptr::null_mut(),
);
if !hello_primop.is_null() {
@ -305,7 +307,7 @@ fn primop_function_call() {
let result = nix_alloc_value(ctx, state);
assert!(!result.is_null());
let call_err = nix_value_call(ctx, state, primop_value, std::ptr::null_mut(), result);
let call_err = nix_value_call(ctx, state, primop_value, ptr::null_mut(), result);
if call_err == NixErr::Ok {
// Force the result
let force_err = nix_value_force(ctx, state, result);
@ -316,13 +318,12 @@ fn primop_function_call() {
if result_type == ValueType::String {
// Get string value
unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_uint,
user_data: *mut ::std::os::raw::c_void,
start: *const c_char,
n: c_uint,
user_data: *mut c_void,
) {
let s =
unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap_or("");
let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = str::from_utf8(s).unwrap_or("");
let result = unsafe { &mut *(user_data as *mut Option<String>) };
*result = Some(s.to_string());
}
@ -332,7 +333,7 @@ fn primop_function_call() {
ctx,
result,
Some(string_callback),
&mut string_result as *mut Option<String> as *mut ::std::os::raw::c_void,
&mut string_result as *mut Option<String> as *mut c_void,
);
// Verify we got the expected string
@ -374,7 +375,7 @@ fn primop_with_arguments() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -397,7 +398,7 @@ fn primop_with_arguments() {
let arg_names = [CString::new("x").unwrap()];
let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
arg_name_ptrs_null_terminated.push(std::ptr::null());
arg_name_ptrs_null_terminated.push(ptr::null());
let name = CString::new("addOne").unwrap();
let doc = CString::new("Add 1 to the argument").unwrap();
@ -409,7 +410,7 @@ fn primop_with_arguments() {
name.as_ptr(),
arg_name_ptrs_null_terminated.as_mut_ptr(),
doc.as_ptr(),
test_data_ptr as *mut ::std::os::raw::c_void,
test_data_ptr as *mut c_void,
);
if !add_primop.is_null() {
@ -480,7 +481,7 @@ fn primop_multi_argument() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -496,7 +497,7 @@ fn primop_multi_argument() {
let arg_names = [CString::new("s1").unwrap(), CString::new("s2").unwrap()];
let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
arg_name_ptrs_null_terminated.push(std::ptr::null());
arg_name_ptrs_null_terminated.push(ptr::null());
let name = CString::new("concatStrings").unwrap();
let doc = CString::new("Concatenate two strings").unwrap();
@ -508,7 +509,7 @@ fn primop_multi_argument() {
name.as_ptr(),
arg_name_ptrs_null_terminated.as_mut_ptr(),
doc.as_ptr(),
std::ptr::null_mut(),
ptr::null_mut(),
);
if !concat_primop.is_null() {
@ -548,13 +549,12 @@ fn primop_multi_argument() {
let result_type = nix_get_type(ctx, result);
if result_type == ValueType::String {
unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_uint,
user_data: *mut ::std::os::raw::c_void,
start: *const c_char,
n: c_uint,
user_data: *mut c_void,
) {
let s =
unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap_or("");
let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = str::from_utf8(s).unwrap_or("");
let result = unsafe { &mut *(user_data as *mut Option<String>) };
*result = Some(s.to_string());
}
@ -564,7 +564,7 @@ fn primop_multi_argument() {
ctx,
result,
Some(string_callback),
&mut string_result as *mut Option<String> as *mut ::std::os::raw::c_void,
&mut string_result as *mut Option<String> as *mut c_void,
);
// Verify concatenation worked
@ -601,7 +601,7 @@ fn primop_error_handling() {
let err = nix_libexpr_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let builder = nix_eval_state_builder_new(ctx, store);
@ -616,7 +616,7 @@ fn primop_error_handling() {
// Test invalid PrimOp allocation (NULL callback)
let name = CString::new("invalid").unwrap();
let doc = CString::new("Invalid PrimOp").unwrap();
let mut empty_args: Vec<*const ::std::os::raw::c_char> = vec![std::ptr::null()];
let mut empty_args: Vec<*const c_char> = vec![ptr::null()];
let _invalid_primop = nix_alloc_primop(
ctx,
@ -625,7 +625,7 @@ fn primop_error_handling() {
name.as_ptr(),
empty_args.as_mut_ptr(),
doc.as_ptr(),
std::ptr::null_mut(),
ptr::null_mut(),
);
// Test initializing value with NULL PrimOp (should fail)

57
nixide-sys/tests/store.rs
View file

@ -1,8 +1,9 @@
#![cfg(feature = "nix-store-c")]
#![cfg(test)]
use core::ffi::{c_char, c_uint, c_void};
use std::ffi::CString;
use std::ptr;
use std::{ptr, slice, str};
use serial_test::serial;
@ -61,13 +62,9 @@ fn parse_and_clone_free_store_path() {
#[test]
#[serial]
fn store_get_uri_and_storedir() {
unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_uint,
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>();
unsafe { *out = Some(s.to_string()) };
}
@ -116,13 +113,9 @@ fn libstore_init_no_load_config() {
#[test]
#[serial]
fn store_is_valid_path_and_real_path() {
unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_uint,
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>();
unsafe { *out = Some(s.to_string()) };
}
@ -133,7 +126,7 @@ fn store_is_valid_path_and_real_path() {
let err = nix_libstore_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
// Use a dummy path (should not be valid, but should not crash)
@ -164,13 +157,9 @@ fn store_is_valid_path_and_real_path() {
#[test]
#[serial]
fn store_path_name() {
unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_uint,
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>();
unsafe { *out = Some(s.to_string()) };
}
@ -181,7 +170,7 @@ fn store_path_name() {
let err = nix_libstore_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let path_str = CString::new("/nix/store/foo-bar-baz").unwrap();
@ -202,13 +191,9 @@ fn store_path_name() {
#[test]
#[serial]
fn store_get_version() {
unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_uint,
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>();
unsafe { *out = Some(s.to_string()) };
}
@ -219,7 +204,7 @@ fn store_get_version() {
let err = nix_libstore_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
let mut version: Option<String> = None;
@ -238,8 +223,8 @@ fn store_get_version() {
#[serial]
fn store_realise_and_copy_closure() {
unsafe extern "C" fn realise_callback(
_userdata: *mut ::std::os::raw::c_void,
outname: *const ::std::os::raw::c_char,
_userdata: *mut c_void,
outname: *const c_char,
out: *const StorePath,
) {
// Just check that callback is called with non-null pointers
@ -253,7 +238,7 @@ fn store_realise_and_copy_closure() {
let err = nix_libstore_init(ctx);
assert_eq!(err, NixErr::Ok);
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
assert!(!store.is_null());
// Use a dummy path (should not crash, may not realise)
@ -265,7 +250,7 @@ fn store_realise_and_copy_closure() {
ctx,
store,
store_path,
std::ptr::null_mut(),
ptr::null_mut(),
Some(realise_callback),
);

28
nixide-sys/tests/util.rs
View file

@ -1,7 +1,9 @@
#![cfg(feature = "nix-util-c")]
#![cfg(test)]
use std::ffi::{CStr, CString};
use core::ffi::{CStr, c_char, c_uint, c_void};
use std::ffi::CString;
use std::{slice, str};
use serial_test::serial;
@ -47,13 +49,9 @@ fn version_get() {
#[test]
#[serial]
fn setting_set_and_get() {
unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_uint,
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>();
*unsafe { &mut *out } = Some(s.to_string());
}
@ -98,13 +96,9 @@ fn setting_set_and_get() {
#[test]
#[serial]
fn error_handling_apis() {
unsafe extern "C" fn string_callback(
start: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_uint,
user_data: *mut ::std::os::raw::c_void,
) {
let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = std::str::from_utf8(s).unwrap();
unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
let s = str::from_utf8(s).unwrap();
let out = user_data.cast::<Option<String>>();
*unsafe { &mut *out } = Some(s.to_string());
}
@ -125,10 +119,10 @@ fn error_handling_apis() {
assert_eq!(code, NixErr::Unknown);
// Get error message
let mut len: std::os::raw::c_uint = 0;
let mut len: c_uint = 0;
let err_msg_ptr = nix_err_msg(ctx, ctx, &mut len as *mut _);
if !err_msg_ptr.is_null() && len > 0 {
let err_msg = std::str::from_utf8(std::slice::from_raw_parts(
let err_msg = str::from_utf8(slice::from_raw_parts(
err_msg_ptr as *const u8,
len as usize,
))

2
nixide/src/errors/nix_error.rs
View file

@ -94,7 +94,7 @@ pub enum NixError {
/// [NixError::Undocumented] has no equivalent in the `libnix` api.
/// This is solely a language difference between C++ and Rust, since
/// [sys::NixErr] is defined over the *"continuous" (not realy)*
/// type [std::os::raw::c_int].
/// type [::core::ffi::c_int].
Undocumented(sys::NixErr),
}

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

@ -77,7 +77,6 @@ impl EvalStateBuilder {
}
// XXX: TODO: use `flakes()` instead
#[deprecated]
#[cfg(feature = "flakes")]
pub fn set_flake_settings(self, settings: &FlakeSettings) -> NixideResult<Self> {
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
@ -93,7 +92,6 @@ impl EvalStateBuilder {
#[cfg(feature = "flakes")]
pub fn flakes(self) -> NixideResult<Self> {
#[allow(deprecated)]
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 super::{FlakeReference, FlakeSettings};
use super::{FlakeRef, FlakeSettings};
use crate::NixideResult;
use crate::errors::ErrorContext;
use crate::stdext::AsCPtr as _;
@ -67,7 +67,6 @@ impl AsInnerPtr<sys::NixFlakeLockFlags> for FlakeLockFlags {
}
impl FlakeLockFlags {
// XXX: TODO: what is the default FlakeLockMode?
pub fn new(settings: &FlakeSettings) -> NixideResult<Self> {
let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_flake_lock_flags_new(ctx.as_ptr(), settings.as_ptr())
@ -76,7 +75,7 @@ impl FlakeLockFlags {
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| {
match mode {
FlakeLockMode::WriteAsNeeded => unsafe {
@ -89,7 +88,9 @@ impl FlakeLockFlags {
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.
@ -104,7 +105,7 @@ impl FlakeLockFlags {
///
/// * `path` - The input name/path to override (must not be empty)
/// * `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()?;
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {

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

@ -1,18 +1,19 @@
use std::ffi::c_void;
use std::os::raw::c_char;
use std::ffi::{c_char, c_void};
use std::ptr::{NonNull, null_mut};
use super::{FetchersSettings, FlakeReferenceParseFlags, FlakeSettings};
use super::{FetchersSettings, FlakeRefParseFlags, FlakeSettings};
use crate::NixideError;
use crate::errors::{ErrorContext, new_nixide_error};
use crate::sys;
use crate::util::wrap;
use crate::util::wrappers::AsInnerPtr;
// XXX: TODO: rename FlakeReference -> FlakeRef
pub struct FlakeReference {
pub struct FlakeRef {
inner: NonNull<sys::NixFlakeReference>,
fragment: String,
fetch_settings: FetchersSettings,
flake_settings: FlakeSettings,
}
// impl Clone for FlakeReference {
@ -29,7 +30,7 @@ pub struct FlakeReference {
// }
// }
impl Drop for FlakeReference {
impl Drop for FlakeRef {
fn drop(&mut self) {
unsafe {
sys::nix_flake_reference_free(self.as_ptr());
@ -37,7 +38,7 @@ impl Drop for FlakeReference {
}
}
impl AsInnerPtr<sys::NixFlakeReference> for FlakeReference {
impl AsInnerPtr<sys::NixFlakeReference> for FlakeRef {
#[inline]
unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReference {
self.inner.as_ptr()
@ -54,17 +55,16 @@ impl AsInnerPtr<sys::NixFlakeReference> for FlakeReference {
}
}
impl FlakeReference {
impl FlakeRef {
/// Parse a flake reference from a string.
/// 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`,
/// in which case, the returned string will contain the fragment.
pub fn parse(
fetch_settings: &FetchersSettings,
flake_settings: &FlakeSettings,
flags: &FlakeReferenceParseFlags,
reference: &str,
) -> Result<FlakeReference, NixideError> {
pub fn parse<S: AsRef<str>>(reference: S) -> Result<FlakeRef, NixideError> {
let fetch_settings = FetchersSettings::new()?;
let flake_settings = FlakeSettings::new()?;
let parse_flags = FlakeRefParseFlags::new(&flake_settings)?;
let mut ptr: *mut sys::NixFlakeReference = null_mut();
let fragment = wrap::nix_string_callback!(
|callback, userdata: *mut __UserData, ctx: &ErrorContext| unsafe {
@ -72,9 +72,9 @@ impl FlakeReference {
ctx.as_ptr(),
fetch_settings.as_ptr(),
flake_settings.as_ptr(),
flags.as_ptr(),
reference.as_ptr() as *const c_char,
reference.len(),
parse_flags.as_ptr(),
reference.as_ref().as_ptr() as *const c_char,
reference.as_ref().len(),
&mut ptr,
Some(callback),
userdata as *mut c_void,
@ -83,7 +83,12 @@ impl FlakeReference {
)?;
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)),
}
}

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

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