diff --git a/.clang-format b/.clang-format deleted file mode 100644 index 6132176..0000000 --- a/.clang-format +++ /dev/null @@ -1,39 +0,0 @@ -#-* 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 deleted file mode 100644 index b3ded5e..0000000 --- a/.clang-tidy +++ /dev/null @@ -1,96 +0,0 @@ -#-* 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 new file mode 100644 index 0000000..5473e64 --- /dev/null +++ b/TODO.md @@ -0,0 +1,3 @@ +- [ ] 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 e6cfded..b17dd36 100644 --- a/flake.lock +++ b/flake.lock @@ -23,16 +23,16 @@ }, "nixpkgs": { "locked": { - "lastModified": 1775036866, - "narHash": "sha256-ZojAnPuCdy657PbTq5V0Y+AHKhZAIwSIT2cb8UgAz/U=", + "lastModified": 1773222311, + "narHash": "sha256-BHoB/XpbqoZkVYZCfXJXfkR+GXFqwb/4zbWnOr2cRcU=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "6201e203d09599479a3b3450ed24fa81537ebc4e", + "rev": "0590cd39f728e129122770c029970378a79d076a", "type": "github" }, "original": { "owner": "NixOS", - "ref": "nixos-unstable", + "ref": "nixos-25.11", "repo": "nixpkgs", "type": "github" } diff --git a/flake.nix b/flake.nix index a64229f..925f948 100644 --- a/flake.nix +++ b/flake.nix @@ -2,7 +2,7 @@ description = "rust wrapper for libnix"; inputs = { - nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; + nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.11"; systems.url = "github:nix-systems/default"; fenix = { @@ -49,7 +49,7 @@ ... }: { default = let - nixForBindings = pkgs.nixVersions.nix_2_34; + nixForBindings = pkgs.nixVersions.nix_2_32; inherit (pkgs.rustc) llvmPackages; in pkgs.mkShell rec { @@ -113,7 +113,7 @@ }; nightly = let - nixForBindings = pkgs.nixVersions.nix_2_34; + nixForBindings = pkgs.nixVersions.nix_2_32; inherit (pkgs.rustc) llvmPackages; in pkgs.mkShell rec { diff --git a/nixide-sys/build.rs b/nixide-sys/build.rs index 59bd10e..79d68ad 100644 --- a/nixide-sys/build.rs +++ b/nixide-sys/build.rs @@ -23,6 +23,11 @@ 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, @@ -38,11 +43,6 @@ 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,9 +57,7 @@ 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) - .or_else(|_| strip_variant_prefix("N", enum_name, &variant)) - .unwrap(), + "ValueType" => strip_variant_prefix("NixType", enum_name, &variant).unwrap(), _ => variant, }) } @@ -108,38 +106,14 @@ fn main() { .unique() .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(); + 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(); 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) @@ -150,44 +124,25 @@ 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") - - // .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 + // Wrap all unsafe operations in unsafe blocks + .layout_tests(true) .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) // DEBUG (comment this) + .use_distinct_char16_t(false) .generate_comments(false) .generate_cstr(true) // use &CStr instead of &[u8] - .fit_macro_constants(true) // DEBUG (comment this) + .fit_macro_constants(true) .explicit_padding(true) .enable_cxx_namespaces() - .represent_cxx_operators(false) // DEBUG (comment this) + .represent_cxx_operators(true) .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 2e6d976..48858cc 100644 --- a/nixide-sys/include/nix-fetchers.h +++ b/nixide-sys/include/nix-fetchers.h @@ -1,10 +1,9 @@ #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 e615ce0..1340fa4 100644 --- a/nixide-sys/include/nix-flake.h +++ b/nixide-sys/include/nix-flake.h @@ -1,10 +1,9 @@ #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 deleted file mode 100644 index a8cd4e0..0000000 --- a/nixide-sys/libnixide-c/nixide_api_fetchers.cc +++ /dev/null @@ -1,86 +0,0 @@ -#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 deleted file mode 100644 index 572eaff..0000000 --- a/nixide-sys/libnixide-c/nixide_api_fetchers.h +++ /dev/null @@ -1,36 +0,0 @@ -#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 deleted file mode 100644 index 4b9ec00..0000000 --- a/nixide-sys/libnixide-c/nixide_api_flake.cc +++ /dev/null @@ -1,154 +0,0 @@ -// #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 deleted file mode 100644 index 1cd279e..0000000 --- a/nixide-sys/libnixide-c/nixide_api_flake.h +++ /dev/null @@ -1,47 +0,0 @@ -#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 1a8f58a..e90dcbe 100644 --- a/nixide-sys/tests/eval.rs +++ b/nixide-sys/tests/eval.rs @@ -1,9 +1,8 @@ #![cfg(feature = "nix-expr-c")] #![cfg(test)] -use ::core::ffi::{CStr, c_char, c_uint, c_void}; -use ::std::ffi::CString; -use ::std::{f64, ptr, slice}; +use std::ffi::{CStr, CString}; +use std::ptr; use serial_test::serial; @@ -24,7 +23,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, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -59,7 +58,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, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -120,9 +119,12 @@ 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, f64::consts::PI), NixErr::Ok); + assert_eq!( + nix_init_float(ctx, float_val, std::f64::consts::PI), + NixErr::Ok + ); assert_eq!(nix_get_type(ctx, float_val), ValueType::Float); - assert!((nix_get_float(ctx, float_val) - f64::consts::PI).abs() < 1e-10); + assert!((nix_get_float(ctx, float_val) - std::f64::consts::PI).abs() < 1e-10); // Bool let bool_val = nix_alloc_value(ctx, state); @@ -143,9 +145,13 @@ 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 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(); + 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(); let out = user_data.cast::>(); unsafe { *out = Some(s.to_string()) }; } @@ -393,7 +399,8 @@ 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 = str::from_utf8(slice::from_raw_parts(buf.cast::(), len)).unwrap(); + let realised_str = + std::str::from_utf8(std::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); @@ -489,7 +496,7 @@ fn multi_argument_function_calls() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -577,7 +584,7 @@ fn curried_function_evaluation() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -706,7 +713,7 @@ fn thunk_creation_with_init_apply() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -785,7 +792,7 @@ fn lookup_path_configuration() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -799,7 +806,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(ptr::null()); + lookup_path_ptrs_null_terminated.push(std::ptr::null()); let set_lookup_err = nix_eval_state_builder_set_lookup_path( ctx, @@ -862,7 +869,7 @@ fn complex_nested_evaluation() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -985,7 +992,7 @@ fn evaluation_error_handling() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -1036,10 +1043,10 @@ fn evaluation_error_handling() { assert_ne!(error_code, NixErr::Ok); // Try to get error message - let mut error_len: c_uint = 0; + let mut error_len: std::os::raw::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 = str::from_utf8(slice::from_raw_parts( + let error_msg = std::str::from_utf8(std::slice::from_raw_parts( error_msg_ptr as *const u8, error_len as usize, )) @@ -1116,7 +1123,7 @@ fn builtin_function_calls() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::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 db82064..c7b83db 100644 --- a/nixide-sys/tests/memory.rs +++ b/nixide-sys/tests/memory.rs @@ -1,9 +1,7 @@ #![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; @@ -25,7 +23,7 @@ fn value_reference_counting() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -89,7 +87,7 @@ fn general_gc_reference_counting() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -113,7 +111,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 c_void); + let gc_incref_err = nix_gc_incref(ctx, value as *const ::std::os::raw::c_void); assert_eq!(gc_incref_err, NixErr::Ok); // Value should still be accessible @@ -121,7 +119,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 c_void); + let gc_decref_err = nix_gc_decref(ctx, value as *const ::std::os::raw::c_void); assert_eq!(gc_decref_err, NixErr::Ok); // Final cleanup @@ -149,7 +147,7 @@ fn manual_garbage_collection() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -207,7 +205,7 @@ fn value_copying_and_memory_management() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -242,12 +240,12 @@ fn value_copying_and_memory_management() { // Test string contents using callback unsafe extern "C" fn string_callback( - start: *const c_char, - n: c_uint, - user_data: *mut c_void, + start: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_uint, + user_data: *mut ::std::os::raw::c_void, ) { - let s = unsafe { slice::from_raw_parts(start.cast::(), n as usize) }; - let s = str::from_utf8(s).unwrap_or(""); + let s = unsafe { std::slice::from_raw_parts(start.cast::(), n as usize) }; + let s = std::str::from_utf8(s).unwrap_or(""); let result = unsafe { &mut *(user_data as *mut Option) }; *result = Some(s.to_string()); } @@ -259,14 +257,14 @@ fn value_copying_and_memory_management() { ctx, original, Some(string_callback), - &mut original_string as *mut Option as *mut c_void, + &mut original_string as *mut Option as *mut ::std::os::raw::c_void, ); let _ = nix_get_string( ctx, copy, Some(string_callback), - &mut copy_string as *mut Option as *mut c_void, + &mut copy_string as *mut Option as *mut ::std::os::raw::c_void, ); // Both should have the same string content @@ -317,7 +315,7 @@ fn complex_value_memory_management() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -444,20 +442,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, ptr::null() as *const c_void); + let null_incref_err = nix_gc_incref(ctx, std::ptr::null() as *const ::std::os::raw::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, ptr::null() as *const c_void); + let null_decref_err = nix_gc_decref(ctx, std::ptr::null() as *const ::std::os::raw::c_void); assert!(null_decref_err == NixErr::Ok || null_decref_err == NixErr::Unknown); - let null_value_incref_err = nix_value_incref(ctx, ptr::null_mut()); + let null_value_incref_err = nix_value_incref(ctx, std::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, ptr::null_mut()); + let null_value_decref_err = nix_value_decref(ctx, std::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); @@ -471,7 +469,7 @@ fn memory_management_error_conditions() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -487,10 +485,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, ptr::null_mut()); + let copy_from_null_err = nix_copy_value(ctx, valid_value, std::ptr::null_mut()); assert_ne!(copy_from_null_err, NixErr::Ok); - let copy_to_null_err = nix_copy_value(ctx, ptr::null_mut(), valid_value); + let copy_to_null_err = nix_copy_value(ctx, std::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 4417621..2a0b62a 100644 --- a/nixide-sys/tests/primop.rs +++ b/nixide-sys/tests/primop.rs @@ -1,10 +1,8 @@ #![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; @@ -18,7 +16,7 @@ struct TestPrimOpData { // Simple PrimOp that adds 1 to an integer argument unsafe extern "C" fn add_one_primop( - user_data: *mut c_void, + user_data: *mut ::std::os::raw::c_void, context: *mut NixCContext, state: *mut EvalState, args: *mut *mut NixValue, @@ -83,7 +81,7 @@ unsafe extern "C" fn add_one_primop( // PrimOp that returns a constant string unsafe extern "C" fn hello_world_primop( - _user_data: *mut c_void, + _user_data: *mut ::std::os::raw::c_void, context: *mut NixCContext, _state: *mut EvalState, _args: *mut *mut NixValue, @@ -95,7 +93,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 c_void, + _user_data: *mut ::std::os::raw::c_void, context: *mut NixCContext, state: *mut EvalState, args: *mut *mut NixValue, @@ -137,12 +135,12 @@ unsafe extern "C" fn concat_strings_primop( // Get string value using callback unsafe extern "C" fn string_callback( - start: *const c_char, - n: c_uint, - user_data: *mut c_void, + start: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_uint, + user_data: *mut ::std::os::raw::c_void, ) { - let s = unsafe { slice::from_raw_parts(start.cast::(), n as usize) }; - let s = str::from_utf8(s).unwrap_or(""); + let s = unsafe { std::slice::from_raw_parts(start.cast::(), n as usize) }; + let s = std::str::from_utf8(s).unwrap_or(""); let result = unsafe { &mut *(user_data as *mut String) }; result.push_str(s); } @@ -152,7 +150,7 @@ unsafe extern "C" fn concat_strings_primop( context, arg, Some(string_callback), - &mut result as *mut String as *mut c_void, + &mut result as *mut String as *mut ::std::os::raw::c_void, ) }; } @@ -177,7 +175,7 @@ fn primop_allocation_and_registration() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -200,7 +198,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(ptr::null()); + arg_name_ptrs_null_terminated.push(std::ptr::null()); let name = CString::new("addOne").unwrap(); let doc = CString::new("Add 1 to the argument").unwrap(); @@ -213,7 +211,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 c_void, + test_data_ptr as *mut ::std::os::raw::c_void, ); if !primop.is_null() { @@ -261,7 +259,7 @@ fn primop_function_call() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -283,7 +281,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 c_char> = vec![ptr::null()]; + let mut empty_args: Vec<*const ::std::os::raw::c_char> = vec![std::ptr::null()]; let hello_primop = nix_alloc_primop( ctx, @@ -292,7 +290,7 @@ fn primop_function_call() { name.as_ptr(), empty_args.as_mut_ptr(), doc.as_ptr(), - ptr::null_mut(), + std::ptr::null_mut(), ); if !hello_primop.is_null() { @@ -307,7 +305,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, ptr::null_mut(), result); + let call_err = nix_value_call(ctx, state, primop_value, std::ptr::null_mut(), result); if call_err == NixErr::Ok { // Force the result let force_err = nix_value_force(ctx, state, result); @@ -318,12 +316,13 @@ fn primop_function_call() { if result_type == ValueType::String { // Get string value unsafe extern "C" fn string_callback( - start: *const c_char, - n: c_uint, - user_data: *mut c_void, + start: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_uint, + user_data: *mut ::std::os::raw::c_void, ) { - let s = unsafe { slice::from_raw_parts(start.cast::(), n as usize) }; - let s = str::from_utf8(s).unwrap_or(""); + let s = + unsafe { std::slice::from_raw_parts(start.cast::(), n as usize) }; + let s = std::str::from_utf8(s).unwrap_or(""); let result = unsafe { &mut *(user_data as *mut Option) }; *result = Some(s.to_string()); } @@ -333,7 +332,7 @@ fn primop_function_call() { ctx, result, Some(string_callback), - &mut string_result as *mut Option as *mut c_void, + &mut string_result as *mut Option as *mut ::std::os::raw::c_void, ); // Verify we got the expected string @@ -375,7 +374,7 @@ fn primop_with_arguments() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -398,7 +397,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(ptr::null()); + arg_name_ptrs_null_terminated.push(std::ptr::null()); let name = CString::new("addOne").unwrap(); let doc = CString::new("Add 1 to the argument").unwrap(); @@ -410,7 +409,7 @@ fn primop_with_arguments() { name.as_ptr(), arg_name_ptrs_null_terminated.as_mut_ptr(), doc.as_ptr(), - test_data_ptr as *mut c_void, + test_data_ptr as *mut ::std::os::raw::c_void, ); if !add_primop.is_null() { @@ -481,7 +480,7 @@ fn primop_multi_argument() { let err = nix_libexpr_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let builder = nix_eval_state_builder_new(ctx, store); @@ -497,7 +496,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(ptr::null()); + arg_name_ptrs_null_terminated.push(std::ptr::null()); let name = CString::new("concatStrings").unwrap(); let doc = CString::new("Concatenate two strings").unwrap(); @@ -509,7 +508,7 @@ fn primop_multi_argument() { name.as_ptr(), arg_name_ptrs_null_terminated.as_mut_ptr(), doc.as_ptr(), - ptr::null_mut(), + std::ptr::null_mut(), ); if !concat_primop.is_null() { @@ -549,12 +548,13 @@ 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 c_char, - n: c_uint, - user_data: *mut c_void, + start: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_uint, + user_data: *mut ::std::os::raw::c_void, ) { - let s = unsafe { slice::from_raw_parts(start.cast::(), n as usize) }; - let s = str::from_utf8(s).unwrap_or(""); + let s = + unsafe { std::slice::from_raw_parts(start.cast::(), n as usize) }; + let s = std::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 c_void, + &mut string_result as *mut Option as *mut ::std::os::raw::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, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::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 c_char> = vec![ptr::null()]; + let mut empty_args: Vec<*const ::std::os::raw::c_char> = vec![std::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(), - ptr::null_mut(), + std::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 31cbfab..1e85322 100644 --- a/nixide-sys/tests/store.rs +++ b/nixide-sys/tests/store.rs @@ -1,9 +1,8 @@ #![cfg(feature = "nix-store-c")] #![cfg(test)] -use core::ffi::{c_char, c_uint, c_void}; use std::ffi::CString; -use std::{ptr, slice, str}; +use std::ptr; use serial_test::serial; @@ -62,9 +61,13 @@ fn parse_and_clone_free_store_path() { #[test] #[serial] fn store_get_uri_and_storedir() { - 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(); + 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(); let out = user_data.cast::>(); unsafe { *out = Some(s.to_string()) }; } @@ -113,9 +116,13 @@ fn libstore_init_no_load_config() { #[test] #[serial] fn store_is_valid_path_and_real_path() { - 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(); + 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(); let out = user_data.cast::>(); unsafe { *out = Some(s.to_string()) }; } @@ -126,7 +133,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, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); // Use a dummy path (should not be valid, but should not crash) @@ -157,9 +164,13 @@ fn store_is_valid_path_and_real_path() { #[test] #[serial] fn store_path_name() { - 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(); + 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(); let out = user_data.cast::>(); unsafe { *out = Some(s.to_string()) }; } @@ -170,7 +181,7 @@ fn store_path_name() { let err = nix_libstore_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let path_str = CString::new("/nix/store/foo-bar-baz").unwrap(); @@ -191,9 +202,13 @@ fn store_path_name() { #[test] #[serial] fn store_get_version() { - 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(); + 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(); let out = user_data.cast::>(); unsafe { *out = Some(s.to_string()) }; } @@ -204,7 +219,7 @@ fn store_get_version() { let err = nix_libstore_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); let mut version: Option = None; @@ -223,8 +238,8 @@ fn store_get_version() { #[serial] fn store_realise_and_copy_closure() { unsafe extern "C" fn realise_callback( - _userdata: *mut c_void, - outname: *const c_char, + _userdata: *mut ::std::os::raw::c_void, + outname: *const ::std::os::raw::c_char, out: *const StorePath, ) { // Just check that callback is called with non-null pointers @@ -238,7 +253,7 @@ fn store_realise_and_copy_closure() { let err = nix_libstore_init(ctx); assert_eq!(err, NixErr::Ok); - let store = nix_store_open(ctx, ptr::null(), ptr::null_mut()); + let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut()); assert!(!store.is_null()); // Use a dummy path (should not crash, may not realise) @@ -250,7 +265,7 @@ fn store_realise_and_copy_closure() { ctx, store, store_path, - ptr::null_mut(), + std::ptr::null_mut(), Some(realise_callback), ); diff --git a/nixide-sys/tests/util.rs b/nixide-sys/tests/util.rs index 70a2872..5abfbf7 100644 --- a/nixide-sys/tests/util.rs +++ b/nixide-sys/tests/util.rs @@ -1,9 +1,7 @@ #![cfg(feature = "nix-util-c")] #![cfg(test)] -use core::ffi::{CStr, c_char, c_uint, c_void}; -use std::ffi::CString; -use std::{slice, str}; +use std::ffi::{CStr, CString}; use serial_test::serial; @@ -49,9 +47,13 @@ fn version_get() { #[test] #[serial] fn setting_set_and_get() { - 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(); + 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(); let out = user_data.cast::>(); *unsafe { &mut *out } = Some(s.to_string()); } @@ -96,9 +98,13 @@ fn setting_set_and_get() { #[test] #[serial] fn error_handling_apis() { - 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(); + 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(); let out = user_data.cast::>(); *unsafe { &mut *out } = Some(s.to_string()); } @@ -119,10 +125,10 @@ fn error_handling_apis() { assert_eq!(code, NixErr::Unknown); // Get error message - let mut len: c_uint = 0; + let mut len: std::os::raw::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 = str::from_utf8(slice::from_raw_parts( + let err_msg = std::str::from_utf8(std::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 a2c7789..c239e5f 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 [::core::ffi::c_int]. + /// type [std::os::raw::c_int]. Undocumented(sys::NixErr), } diff --git a/nixide/src/expr/eval_state_builder.rs b/nixide/src/expr/eval_state_builder.rs index 117cf8a..f1a09e6 100644 --- a/nixide/src/expr/eval_state_builder.rs +++ b/nixide/src/expr/eval_state_builder.rs @@ -77,6 +77,7 @@ 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 { @@ -92,6 +93,7 @@ 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 06f3554..d471987 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::{FlakeRef, FlakeSettings}; +use super::{FlakeReference, FlakeSettings}; use crate::NixideResult; use crate::errors::ErrorContext; use crate::stdext::AsCPtr as _; @@ -67,6 +67,7 @@ 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()) @@ -75,7 +76,7 @@ impl FlakeLockFlags { Ok(FlakeLockFlags { inner }) } - pub fn set_mode(self, mode: FlakeLockMode) -> NixideResult { + pub fn set_mode(&mut self, mode: &FlakeLockMode) -> NixideResult<()> { wrap::nix_fn!(|ctx: &ErrorContext| { match mode { FlakeLockMode::WriteAsNeeded => unsafe { @@ -88,9 +89,7 @@ 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. @@ -105,7 +104,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: &FlakeRef) -> NixideResult<()> { + pub fn override_input(&mut self, path: &str, flakeref: &FlakeReference) -> 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 bfe44c5..2872578 100644 --- a/nixide/src/flake/flake_reference.rs +++ b/nixide/src/flake/flake_reference.rs @@ -1,19 +1,18 @@ -use std::ffi::{c_char, c_void}; +use std::ffi::c_void; +use std::os::raw::c_char; use std::ptr::{NonNull, null_mut}; -use super::{FetchersSettings, FlakeRefParseFlags, FlakeSettings}; +use super::{FetchersSettings, FlakeReferenceParseFlags, FlakeSettings}; use crate::NixideError; use crate::errors::{ErrorContext, new_nixide_error}; use crate::sys; use crate::util::wrap; use crate::util::wrappers::AsInnerPtr; -pub struct FlakeRef { +// XXX: TODO: rename FlakeReference -> FlakeRef +pub struct FlakeReference { inner: NonNull, fragment: String, - - fetch_settings: FetchersSettings, - flake_settings: FlakeSettings, } // impl Clone for FlakeReference { @@ -30,7 +29,7 @@ pub struct FlakeRef { // } // } -impl Drop for FlakeRef { +impl Drop for FlakeReference { fn drop(&mut self) { unsafe { sys::nix_flake_reference_free(self.as_ptr()); @@ -38,7 +37,7 @@ impl Drop for FlakeRef { } } -impl AsInnerPtr for FlakeRef { +impl AsInnerPtr for FlakeReference { #[inline] unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReference { self.inner.as_ptr() @@ -55,16 +54,17 @@ impl AsInnerPtr for FlakeRef { } } -impl FlakeRef { +impl FlakeReference { /// 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>(reference: S) -> Result { - let fetch_settings = FetchersSettings::new()?; - let flake_settings = FlakeSettings::new()?; - let parse_flags = FlakeRefParseFlags::new(&flake_settings)?; - + pub fn parse( + fetch_settings: &FetchersSettings, + flake_settings: &FlakeSettings, + flags: &FlakeReferenceParseFlags, + reference: &str, + ) -> Result { 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 FlakeRef { ctx.as_ptr(), fetch_settings.as_ptr(), flake_settings.as_ptr(), - parse_flags.as_ptr(), - reference.as_ref().as_ptr() as *const c_char, - reference.as_ref().len(), + flags.as_ptr(), + reference.as_ptr() as *const c_char, + reference.len(), &mut ptr, Some(callback), userdata as *mut c_void, @@ -83,12 +83,7 @@ impl FlakeRef { )?; match NonNull::new(ptr) { - Some(inner) => Ok(FlakeRef { - inner, - fragment, - fetch_settings, - flake_settings, - }), + Some(inner) => Ok(FlakeReference { inner, fragment }), 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 f3bec84..2b47aea 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::ffi::c_char; +use std::os::raw::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 FlakeRefParseFlags { +pub struct FlakeReferenceParseFlags { inner: NonNull, } @@ -27,7 +27,7 @@ pub struct FlakeRefParseFlags { // } // } -impl Drop for FlakeRefParseFlags { +impl Drop for FlakeReferenceParseFlags { fn drop(&mut self) { unsafe { sys::nix_flake_reference_parse_flags_free(self.inner.as_ptr()); @@ -35,7 +35,7 @@ impl Drop for FlakeRefParseFlags { } } -impl AsInnerPtr for FlakeRefParseFlags { +impl AsInnerPtr for FlakeReferenceParseFlags { #[inline] unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReferenceParseFlags { self.inner.as_ptr() @@ -52,7 +52,7 @@ impl AsInnerPtr for FlakeRefParseFlags { } } -impl FlakeRefParseFlags { +impl FlakeReferenceParseFlags { 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 3a76880..4192b8f 100644 --- a/nixide/src/flake/locked_flake.rs +++ b/nixide/src/flake/locked_flake.rs @@ -1,10 +1,8 @@ // 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, FlakeLockMode, FlakeRef, FlakeSettings}; +use super::{FetchersSettings, FlakeLockFlags, FlakeReference, FlakeSettings}; use crate::errors::ErrorContext; use crate::sys; use crate::util::wrap; @@ -14,13 +12,31 @@ use crate::{EvalState, NixideResult, Value}; pub struct LockedFlake { inner: NonNull, - flakeref: FlakeRef, - state: Rc>>, - lock_flags: FlakeLockFlags, + flakeref: FlakeReference, + state: EvalState, + 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 { @@ -48,33 +64,30 @@ impl AsInnerPtr for LockedFlake { impl LockedFlake { pub fn lock( - mode: FlakeLockMode, - flakeref: FlakeRef, + fetch_settings: &FetchersSettings, + flake_settings: &FlakeSettings, 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_inner.borrow().as_ptr(), - lock_flags.as_ptr(), + state.as_ptr(), + flags.as_ptr(), flakeref.as_ptr(), ) })?; Ok(Self { inner, - flakeref, - state: state_inner.clone(), - lock_flags, - fetch_settings, - flake_settings, + flakeref: flakeref.clone(), + state: state.clone(), + flags: flags.clone(), + fetch_settings: fetch_settings.clone(), + flake_settings: flake_settings.clone(), }) } @@ -84,12 +97,12 @@ impl LockedFlake { sys::nix_locked_flake_get_output_attrs( ctx.as_ptr(), self.flake_settings.as_ptr(), - self.state.borrow().as_ptr(), + self.state.as_ptr(), self.inner.as_ptr(), ) })?; - Ok(Value::from((value, self.state.clone()))) + Ok(Value::from((value, &self.state))) } } @@ -98,8 +111,8 @@ mod tests { use std::fs; use std::sync::Once; - use super::{FetchersSettings, FlakeLockFlags, FlakeRef, FlakeSettings, LockedFlake}; - use crate::flake::{FlakeLockMode, FlakeRefParseFlags}; + use super::{FetchersSettings, FlakeLockFlags, FlakeReference, FlakeSettings, LockedFlake}; + use crate::flake::{FlakeLockMode, FlakeReferenceParseFlags}; use crate::{EvalStateBuilder, Store, Value, set_global_setting}; static INIT: Once = Once::new(); @@ -154,19 +167,36 @@ mod tests { let store_ref = Store::default().unwrap(); let flake_settings = FlakeSettings::new().unwrap(); - let eval_state = EvalStateBuilder::new(store_ref.clone()) + let mut eval_state = EvalStateBuilder::new(store_ref.clone()) .unwrap() .set_flake_settings(&flake_settings) .unwrap() .build() .unwrap(); - let flakeref = - FlakeRef::parse(&format!("path:{}#subthing", tmp_dir.path().display())).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(); assert_eq!(flakeref.fragment(), "subthing"); - let outputs = LockedFlake::lock(, flakeref, &eval_state).unwrap().outputs().unwrap(); + let locked_flake = LockedFlake::lock( + &fetchers_settings, + &flake_settings, + &eval_state, + &flake_lock_flags, + &flakeref, + ) + .unwrap(); + + let outputs = locked_flake.outputs().unwrap(); assert!(matches!(outputs, Value::Attrs(_))); if let Value::Attrs(outputs) = outputs { @@ -186,7 +216,7 @@ mod tests { let store_ref = Store::default().unwrap(); let fetchers_settings = FetchersSettings::new().unwrap(); let flake_settings = FlakeSettings::new().unwrap(); - let eval_state = EvalStateBuilder::new(store_ref.clone()) + let mut eval_state = EvalStateBuilder::new(store_ref.clone()) .unwrap() .set_flake_settings(&flake_settings) .unwrap() @@ -251,20 +281,33 @@ mod tests { let mut flake_lock_flags = FlakeLockFlags::new(&flake_settings).unwrap(); - let mut flake_reference_parse_flags = FlakeRefParseFlags::new(&flake_settings).unwrap(); + let mut flake_reference_parse_flags = + FlakeReferenceParseFlags::new(&flake_settings).unwrap(); flake_reference_parse_flags .set_base_directory(tmp_dir.path().to_str().unwrap()) .unwrap(); - let flakeref_a = FlakeRef::parse(&format!("path:{}", &flake_dir_a_str)).unwrap(); + let flakeref_a = FlakeReference::parse( + &fetchers_settings, + &flake_settings, + &flake_reference_parse_flags, + &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(flake_lock_flags, flakeref_a, &eval_state); + let locked_flake = LockedFlake::lock( + &fetchers_settings, + &flake_settings, + &eval_state, + &flake_lock_flags, + &flakeref_a, + ); // Has not been locked and would need to write a lock file. assert!(locked_flake.is_err()); let saved_err = match locked_flake { @@ -275,7 +318,14 @@ mod tests { // Step 2: Update but do not write, succeeds flake_lock_flags.set_mode(&FlakeLockMode::Virtual).unwrap(); - let locked_flake = LockedFlake::lock(flake_lock_flags, flakeref_a, &eval_state).unwrap(); + let locked_flake = LockedFlake::lock( + &fetchers_settings, + &flake_settings, + &eval_state, + &flake_lock_flags, + &flakeref_a, + ) + .unwrap(); let outputs = locked_flake.outputs().unwrap(); @@ -292,7 +342,13 @@ 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(flake_lock_flags, flakeref_a, &eval_state); + let locked_flake = LockedFlake::lock( + &fetchers_settings, + &flake_settings, + &eval_state, + &flake_lock_flags, + &flakeref_a, + ); // Has not been locked and would need to write a lock file. match locked_flake { Ok(_) => panic!("Expected error, but got Ok"), @@ -306,7 +362,14 @@ mod tests { .set_mode(&FlakeLockMode::WriteAsNeeded) .unwrap(); - let locked_flake = LockedFlake::lock(flake_lock_flags, flakeref_a, &eval_state).unwrap(); + let locked_flake = LockedFlake::lock( + &fetchers_settings, + &flake_settings, + &eval_state, + &flake_lock_flags, + &flakeref_a, + ) + .unwrap(); let outputs = locked_flake.outputs().unwrap(); @@ -323,7 +386,14 @@ mod tests { // Step 5: Lock was written, so Step 1 succeeds flake_lock_flags.set_mode(&FlakeLockMode::Check).unwrap(); - let locked_flake = LockedFlake::lock(flake_lock_flags, flakeref_a, &eval_state).unwrap(); + let locked_flake = LockedFlake::lock( + &fetchers_settings, + &flake_settings, + &eval_state, + &flake_lock_flags, + &flakeref_a, + ) + .unwrap(); let outputs = locked_flake.outputs().unwrap(); @@ -344,12 +414,25 @@ mod tests { .set_mode(&FlakeLockMode::WriteAsNeeded) .unwrap(); - let flakeref_c = FlakeRef::parse(&format!("path:{}", &flake_dir_c_str)).unwrap(); + let flakeref_c = FlakeReference::parse( + &fetchers_settings, + &flake_settings, + &flake_reference_parse_flags, + &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(flake_lock_flags, flakeref_a, &eval_state).unwrap(); + let locked_flake = LockedFlake::lock( + &fetchers_settings, + &flake_settings, + &eval_state, + &flake_lock_flags, + &flakeref_a, + ) + .unwrap(); let outputs = locked_flake.outputs().unwrap(); @@ -369,7 +452,14 @@ 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(flake_lock_flags, flakeref_a, &eval_state).unwrap(); + let locked_flake = LockedFlake::lock( + &fetchers_settings, + &flake_settings, + &eval_state, + &flake_lock_flags, + &flakeref_a, + ) + .unwrap(); let outputs = locked_flake.outputs().unwrap(); diff --git a/nixide/src/flake/mod.rs b/nixide/src/flake/mod.rs index 53f858c..314173e 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::FlakeRef; -use flake_reference_parse_flags::FlakeRefParseFlags; +use flake_reference::FlakeReference; +use flake_reference_parse_flags::FlakeReferenceParseFlags; pub use flake_settings::FlakeSettings; pub use locked_flake::LockedFlake;