diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..6132176 --- /dev/null +++ b/.clang-format @@ -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 diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 0000000..b3ded5e --- /dev/null +++ b/.clang-tidy @@ -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::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 diff --git a/TODO.md b/TODO.md deleted file mode 100644 index 5473e64..0000000 --- a/TODO.md +++ /dev/null @@ -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 diff --git a/flake.lock b/flake.lock index b17dd36..e6cfded 100644 --- a/flake.lock +++ b/flake.lock @@ -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" } diff --git a/flake.nix b/flake.nix index 925f948..a64229f 100644 --- a/flake.nix +++ b/flake.nix @@ -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 { diff --git a/nixide-sys/build.rs b/nixide-sys/build.rs index 79d68ad..59bd10e 100644 --- a/nixide-sys/build.rs +++ b/nixide-sys/build.rs @@ -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 = 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 = 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) */"); diff --git a/nixide-sys/include/nix-fetchers.h b/nixide-sys/include/nix-fetchers.h index 48858cc..2e6d976 100644 --- a/nixide-sys/include/nix-fetchers.h +++ b/nixide-sys/include/nix-fetchers.h @@ -1,9 +1,10 @@ #ifndef NIXIDE_FETCHERS #define NIXIDE_FETCHERS +// #include + // Nix C API for fetcher operations. // #include -// #include #endif diff --git a/nixide-sys/include/nix-flake.h b/nixide-sys/include/nix-flake.h index 1340fa4..e615ce0 100644 --- a/nixide-sys/include/nix-flake.h +++ b/nixide-sys/include/nix-flake.h @@ -1,9 +1,10 @@ #ifndef NIXIDE_FLAKE #define NIXIDE_FLAKE +// #include + // Nix C API for flake support. // #include -// #include #endif diff --git a/nixide-sys/libnixide-c/nixide_api_fetchers.cc b/nixide-sys/libnixide-c/nixide_api_fetchers.cc new file mode 100644 index 0000000..a8cd4e0 --- /dev/null +++ b/nixide-sys/libnixide-c/nixide_api_fetchers.cc @@ -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" diff --git a/nixide-sys/libnixide-c/nixide_api_fetchers.h b/nixide-sys/libnixide-c/nixide_api_fetchers.h new file mode 100644 index 0000000..572eaff --- /dev/null +++ b/nixide-sys/libnixide-c/nixide_api_fetchers.h @@ -0,0 +1,36 @@ +#ifndef NIXIDE_API_FETCHERS_H +#define NIXIDE_API_FETCHERS_H + +#include "nix_api_fetchers.h" +#include + +#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 diff --git a/nixide-sys/libnixide-c/nixide_api_flake.cc b/nixide-sys/libnixide-c/nixide_api_flake.cc new file mode 100644 index 0000000..4b9ec00 --- /dev/null +++ b/nixide-sys/libnixide-c/nixide_api_flake.cc @@ -0,0 +1,154 @@ +// #include + +// #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" diff --git a/nixide-sys/libnixide-c/nixide_api_flake.h b/nixide-sys/libnixide-c/nixide_api_flake.h new file mode 100644 index 0000000..1cd279e --- /dev/null +++ b/nixide-sys/libnixide-c/nixide_api_flake.h @@ -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 diff --git a/nixide-sys/tests/eval.rs b/nixide-sys/tests/eval.rs index e90dcbe..1a8f58a 100644 --- a/nixide-sys/tests/eval.rs +++ b/nixide-sys/tests/eval.rs @@ -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::(), 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::(), n as usize) }; + let s = str::from_utf8(s).unwrap(); let out = user_data.cast::>(); 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::(), len)).unwrap(); + let realised_str = str::from_utf8(slice::from_raw_parts(buf.cast::(), 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); diff --git a/nixide-sys/tests/memory.rs b/nixide-sys/tests/memory.rs index c7b83db..db82064 100644 --- a/nixide-sys/tests/memory.rs +++ b/nixide-sys/tests/memory.rs @@ -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::(), n as usize) }; - let s = std::str::from_utf8(s).unwrap_or(""); + let s = unsafe { slice::from_raw_parts(start.cast::(), n as usize) }; + let s = str::from_utf8(s).unwrap_or(""); let result = unsafe { &mut *(user_data as *mut Option) }; *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 as *mut ::std::os::raw::c_void, + &mut original_string as *mut Option as *mut c_void, ); let _ = nix_get_string( ctx, copy, Some(string_callback), - &mut copy_string as *mut Option as *mut ::std::os::raw::c_void, + &mut copy_string as *mut Option 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 diff --git a/nixide-sys/tests/primop.rs b/nixide-sys/tests/primop.rs index 2a0b62a..4417621 100644 --- a/nixide-sys/tests/primop.rs +++ b/nixide-sys/tests/primop.rs @@ -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::(), n as usize) }; - let s = std::str::from_utf8(s).unwrap_or(""); + let s = unsafe { slice::from_raw_parts(start.cast::(), 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::(), n as usize) }; - let s = std::str::from_utf8(s).unwrap_or(""); + let s = unsafe { slice::from_raw_parts(start.cast::(), n as usize) }; + let s = str::from_utf8(s).unwrap_or(""); let result = unsafe { &mut *(user_data as *mut Option) }; *result = Some(s.to_string()); } @@ -332,7 +333,7 @@ fn primop_function_call() { ctx, result, Some(string_callback), - &mut string_result as *mut Option as *mut ::std::os::raw::c_void, + &mut string_result as *mut Option 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::(), n as usize) }; - let s = std::str::from_utf8(s).unwrap_or(""); + let s = unsafe { slice::from_raw_parts(start.cast::(), n as usize) }; + let s = str::from_utf8(s).unwrap_or(""); let result = unsafe { &mut *(user_data as *mut Option) }; *result = Some(s.to_string()); } @@ -564,7 +564,7 @@ fn primop_multi_argument() { ctx, result, Some(string_callback), - &mut string_result as *mut Option as *mut ::std::os::raw::c_void, + &mut string_result as *mut Option 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) diff --git a/nixide-sys/tests/store.rs b/nixide-sys/tests/store.rs index 1e85322..31cbfab 100644 --- a/nixide-sys/tests/store.rs +++ b/nixide-sys/tests/store.rs @@ -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::(), 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::(), n as usize) }; + let s = str::from_utf8(s).unwrap(); let out = user_data.cast::>(); 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::(), 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::(), n as usize) }; + let s = str::from_utf8(s).unwrap(); let out = user_data.cast::>(); 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::(), 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::(), n as usize) }; + let s = str::from_utf8(s).unwrap(); let out = user_data.cast::>(); 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::(), 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::(), n as usize) }; + let s = str::from_utf8(s).unwrap(); let out = user_data.cast::>(); 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 = 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), ); diff --git a/nixide-sys/tests/util.rs b/nixide-sys/tests/util.rs index 5abfbf7..70a2872 100644 --- a/nixide-sys/tests/util.rs +++ b/nixide-sys/tests/util.rs @@ -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::(), 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::(), n as usize) }; + let s = str::from_utf8(s).unwrap(); let out = user_data.cast::>(); *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::(), 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::(), n as usize) }; + let s = str::from_utf8(s).unwrap(); let out = user_data.cast::>(); *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, )) diff --git a/nixide/src/errors/nix_error.rs b/nixide/src/errors/nix_error.rs index c239e5f..a2c7789 100644 --- a/nixide/src/errors/nix_error.rs +++ b/nixide/src/errors/nix_error.rs @@ -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), } diff --git a/nixide/src/expr/eval_state_builder.rs b/nixide/src/expr/eval_state_builder.rs index f1a09e6..117cf8a 100644 --- a/nixide/src/expr/eval_state_builder.rs +++ b/nixide/src/expr/eval_state_builder.rs @@ -77,7 +77,6 @@ impl EvalStateBuilder { } // XXX: TODO: use `flakes()` instead - #[deprecated] #[cfg(feature = "flakes")] pub fn set_flake_settings(self, settings: &FlakeSettings) -> NixideResult { wrap::nix_fn!(|ctx: &ErrorContext| unsafe { @@ -93,7 +92,6 @@ impl EvalStateBuilder { #[cfg(feature = "flakes")] pub fn flakes(self) -> NixideResult { - #[allow(deprecated)] self.set_flake_settings(&FlakeSettings::new()?) } diff --git a/nixide/src/flake/flake_lock_flags.rs b/nixide/src/flake/flake_lock_flags.rs index d471987..06f3554 100644 --- a/nixide/src/flake/flake_lock_flags.rs +++ b/nixide/src/flake/flake_lock_flags.rs @@ -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 for FlakeLockFlags { } impl FlakeLockFlags { - // XXX: TODO: what is the default FlakeLockMode? pub fn new(settings: &FlakeSettings) -> NixideResult { 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 { 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 { diff --git a/nixide/src/flake/flake_reference.rs b/nixide/src/flake/flake_reference.rs index 2872578..bfe44c5 100644 --- a/nixide/src/flake/flake_reference.rs +++ b/nixide/src/flake/flake_reference.rs @@ -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, 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 for FlakeReference { +impl AsInnerPtr for FlakeRef { #[inline] unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReference { self.inner.as_ptr() @@ -54,17 +55,16 @@ impl AsInnerPtr 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 { + pub fn parse>(reference: S) -> Result { + 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)), } } diff --git a/nixide/src/flake/flake_reference_parse_flags.rs b/nixide/src/flake/flake_reference_parse_flags.rs index 2b47aea..f3bec84 100644 --- a/nixide/src/flake/flake_reference_parse_flags.rs +++ b/nixide/src/flake/flake_reference_parse_flags.rs @@ -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, } @@ -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 for FlakeReferenceParseFlags { +impl AsInnerPtr for FlakeRefParseFlags { #[inline] unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReferenceParseFlags { self.inner.as_ptr() @@ -52,7 +52,7 @@ impl AsInnerPtr for FlakeReferenceParseFlags { } } -impl FlakeReferenceParseFlags { +impl FlakeRefParseFlags { pub fn new(settings: &FlakeSettings) -> NixideResult { let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe { sys::nix_flake_reference_parse_flags_new(ctx.as_ptr(), settings.as_ptr()) diff --git a/nixide/src/flake/locked_flake.rs b/nixide/src/flake/locked_flake.rs index 4192b8f..3a76880 100644 --- a/nixide/src/flake/locked_flake.rs +++ b/nixide/src/flake/locked_flake.rs @@ -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, - flakeref: FlakeReference, - state: EvalState, - flags: FlakeLockFlags, + flakeref: FlakeRef, + state: Rc>>, + 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 for LockedFlake { impl LockedFlake { pub fn lock( - fetch_settings: &FetchersSettings, - flake_settings: &FlakeSettings, + mode: FlakeLockMode, + flakeref: FlakeRef, state: &EvalState, - flags: &FlakeLockFlags, - flakeref: &FlakeReference, ) -> NixideResult { + 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(); diff --git a/nixide/src/flake/mod.rs b/nixide/src/flake/mod.rs index 314173e..53f858c 100644 --- a/nixide/src/flake/mod.rs +++ b/nixide/src/flake/mod.rs @@ -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;