From b92df7b443bd5c81ad04bdf838afaa4015319fae Mon Sep 17 00:00:00 2001 From: Savanni D'Gerinel Date: Thu, 13 Apr 2023 19:13:02 -0400 Subject: [PATCH] Add the nix flake for the cyberpunk splash screen --- cyberpunk-splash/Cargo.nix | 2836 ++++++++++++++++++++++++++++++++++++ flake.nix | 5 + 2 files changed, 2841 insertions(+) create mode 100644 cyberpunk-splash/Cargo.nix diff --git a/cyberpunk-splash/Cargo.nix b/cyberpunk-splash/Cargo.nix new file mode 100644 index 0000000..4e8e832 --- /dev/null +++ b/cyberpunk-splash/Cargo.nix @@ -0,0 +1,2836 @@ + +# This file was @generated by crate2nix 0.10.0 with the command: +# "generate" +# See https://github.com/kolloch/crate2nix for more info. + +{ nixpkgs ? +, pkgs ? import nixpkgs { config = {}; } +, lib ? pkgs.lib +, stdenv ? pkgs.stdenv +, buildRustCrateForPkgs ? if buildRustCrate != null + then lib.warn "crate2nix: Passing `buildRustCrate` as argument to Cargo.nix is deprecated. If you don't customize `buildRustCrate`, replace `callPackage ./Cargo.nix {}` by `import ./Cargo.nix { inherit pkgs; }`, and if you need to customize `buildRustCrate`, use `buildRustCrateForPkgs` instead." (_: buildRustCrate) + else pkgs: pkgs.buildRustCrate + # Deprecated +, buildRustCrate ? null + # This is used as the `crateOverrides` argument for `buildRustCrate`. +, defaultCrateOverrides ? pkgs.defaultCrateOverrides + # The features to enable for the root_crate or the workspace_members. +, rootFeatures ? [ "default" ] + # If true, throw errors instead of issueing deprecation warnings. +, strictDeprecation ? false + # Used for conditional compilation based on CPU feature detection. +, targetFeatures ? [] + # Whether to perform release builds: longer compile times, faster binaries. +, release ? true + # Additional crate2nix configuration if it exists. +, crateConfig + ? if builtins.pathExists ./crate-config.nix + then pkgs.callPackage ./crate-config.nix {} + else {} +}: + +rec { + # + # "public" attributes that we attempt to keep stable with new versions of crate2nix. + # + + rootCrate = rec { + packageId = "cyberpunk-splash"; + + # Use this attribute to refer to the derivation building your root crate package. + # You can override the features with rootCrate.build.override { features = [ "default" "feature1" ... ]; }. + build = internal.buildRustCrateWithFeatures { + inherit packageId; + }; + + # Debug support which might change between releases. + # File a bug if you depend on any for non-debug work! + debug = internal.debugCrate { inherit packageId; }; + }; + # Refer your crate build derivation by name here. + # You can override the features with + # workspaceMembers."${crateName}".build.override { features = [ "default" "feature1" ... ]; }. + workspaceMembers = { + "cyberpunk-splash" = rec { + packageId = "cyberpunk-splash"; + build = internal.buildRustCrateWithFeatures { + packageId = "cyberpunk-splash"; + }; + + # Debug support which might change between releases. + # File a bug if you depend on any for non-debug work! + debug = internal.debugCrate { inherit packageId; }; + }; + }; + + # A derivation that joins the outputs of all workspace members together. + allWorkspaceMembers = pkgs.symlinkJoin { + name = "all-workspace-members"; + paths = + let members = builtins.attrValues workspaceMembers; + in builtins.map (m: m.build) members; + }; + + # + # "internal" ("private") attributes that may change in every new version of crate2nix. + # + + internal = rec { + # Build and dependency information for crates. + # Many of the fields are passed one-to-one to buildRustCrate. + # + # Noteworthy: + # * `dependencies`/`buildDependencies`: similar to the corresponding fields for buildRustCrate. + # but with additional information which is used during dependency/feature resolution. + # * `resolvedDependencies`: the selected default features reported by cargo - only included for debugging. + # * `devDependencies` as of now not used by `buildRustCrate` but used to + # inject test dependencies into the build + + crates = { + "anyhow" = rec { + crateName = "anyhow"; + version = "1.0.70"; + edition = "2018"; + sha256 = "1r1py8nk0xj6h21jgww8f0zazdvjimbnl1hiacj8i3cz1xgcxs3x"; + authors = [ + "David Tolnay " + ]; + features = { + "backtrace" = [ "dep:backtrace" ]; + "default" = [ "std" ]; + }; + resolvedDefaultFeatures = [ "default" "std" ]; + }; + "autocfg" = rec { + crateName = "autocfg"; + version = "1.1.0"; + edition = "2015"; + sha256 = "1ylp3cb47ylzabimazvbz9ms6ap784zhb6syaz6c1jqpmcmq0s6l"; + authors = [ + "Josh Stone " + ]; + + }; + "bitflags" = rec { + crateName = "bitflags"; + version = "1.3.2"; + edition = "2018"; + sha256 = "12ki6w8gn1ldq7yz9y680llwk5gmrhrzszaa17g1sbrw2r2qvwxy"; + authors = [ + "The Rust Project Developers" + ]; + features = { + "compiler_builtins" = [ "dep:compiler_builtins" ]; + "core" = [ "dep:core" ]; + "rustc-dep-of-std" = [ "core" "compiler_builtins" ]; + }; + resolvedDefaultFeatures = [ "default" ]; + }; + "cairo-rs" = rec { + crateName = "cairo-rs"; + version = "0.17.0"; + edition = "2021"; + sha256 = "0wg8n0yz8p71db4iznp7949xzx92vmzgbhdd51lj5wcasksm9bx8"; + libName = "cairo"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "bitflags"; + packageId = "bitflags"; + } + { + name = "cairo-sys-rs"; + packageId = "cairo-sys-rs"; + rename = "ffi"; + } + { + name = "glib"; + packageId = "glib"; + optional = true; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "once_cell"; + packageId = "once_cell"; + } + { + name = "thiserror"; + packageId = "thiserror"; + } + ]; + features = { + "default" = [ "use_glib" ]; + "dox" = [ "ffi/dox" "glib/dox" "freetype" ]; + "freetype" = [ "ffi/freetype" "freetype-rs" ]; + "freetype-rs" = [ "dep:freetype-rs" ]; + "glib" = [ "dep:glib" ]; + "pdf" = [ "ffi/pdf" ]; + "png" = [ "ffi/png" ]; + "ps" = [ "ffi/ps" ]; + "script" = [ "ffi/script" ]; + "svg" = [ "ffi/svg" ]; + "use_glib" = [ "glib" "ffi/use_glib" ]; + "v1_16" = [ "ffi/v1_16" ]; + "v1_18" = [ "v1_16" "ffi/v1_18" ]; + "win32-surface" = [ "ffi/win32-surface" ]; + "xcb" = [ "ffi/xcb" ]; + "xlib" = [ "ffi/xlib" ]; + }; + resolvedDefaultFeatures = [ "default" "glib" "use_glib" ]; + }; + "cairo-sys-rs" = rec { + crateName = "cairo-sys-rs"; + version = "0.17.0"; + edition = "2021"; + sha256 = "0kjrcfsgp397a4kqfnsr4ssimqpm4j8jdvjy30zybr9h3nh84lzm"; + libName = "cairo_sys"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "glib-sys"; + packageId = "glib-sys"; + rename = "glib"; + optional = true; + } + { + name = "libc"; + packageId = "libc"; + } + ]; + buildDependencies = [ + { + name = "system-deps"; + packageId = "system-deps"; + } + ]; + features = { + "dox" = [ "x11/dox" "glib/dox" ]; + "glib" = [ "dep:glib" ]; + "use_glib" = [ "glib" ]; + "v1_18" = [ "v1_16" ]; + "win32-surface" = [ "winapi" ]; + "winapi" = [ "dep:winapi" ]; + "x11" = [ "dep:x11" ]; + "xlib" = [ "x11" ]; + }; + resolvedDefaultFeatures = [ "glib" "use_glib" ]; + }; + "cfg-expr" = rec { + crateName = "cfg-expr"; + version = "0.14.0"; + edition = "2021"; + sha256 = "1im4f8zrd0gaflv4sxjr2vdn2z4600lyhz32bjc342llc5a2anx3"; + authors = [ + "Embark " + "Jake Shadle " + ]; + dependencies = [ + { + name = "smallvec"; + packageId = "smallvec"; + } + ]; + features = { + "target-lexicon" = [ "dep:target-lexicon" ]; + "targets" = [ "target-lexicon" ]; + }; + resolvedDefaultFeatures = [ "default" ]; + }; + "cyberpunk-splash" = rec { + crateName = "cyberpunk-splash"; + version = "0.1.0"; + edition = "2021"; + crateBin = [ + { name = "cyberpunk-splash"; path = "src/main.rs"; } + ]; + src = lib.cleanSourceWith { filter = sourceFilter; src = ./.; }; + dependencies = [ + { + name = "cairo-rs"; + packageId = "cairo-rs"; + } + { + name = "gio"; + packageId = "gio"; + } + { + name = "glib"; + packageId = "glib"; + } + { + name = "gtk4"; + packageId = "gtk4"; + rename = "gtk"; + } + ]; + + }; + "field-offset" = rec { + crateName = "field-offset"; + version = "0.3.5"; + edition = "2015"; + sha256 = "0dc58qzbfis0i031d741aavvi7crzlb4nvfacg461s7n1y03mkx3"; + authors = [ + "Diggory Blake " + ]; + dependencies = [ + { + name = "memoffset"; + packageId = "memoffset"; + } + ]; + buildDependencies = [ + { + name = "rustc_version"; + packageId = "rustc_version"; + } + ]; + + }; + "futures-channel" = rec { + crateName = "futures-channel"; + version = "0.3.28"; + edition = "2018"; + sha256 = "1wmm9wm5zjigxz61qkscmxp7c30zp08dy63spjz5pch9gva1hmcm"; + dependencies = [ + { + name = "futures-core"; + packageId = "futures-core"; + usesDefaultFeatures = false; + } + ]; + features = { + "alloc" = [ "futures-core/alloc" ]; + "default" = [ "std" ]; + "futures-sink" = [ "dep:futures-sink" ]; + "sink" = [ "futures-sink" ]; + "std" = [ "alloc" "futures-core/std" ]; + }; + resolvedDefaultFeatures = [ "alloc" "default" "std" ]; + }; + "futures-core" = rec { + crateName = "futures-core"; + version = "0.3.28"; + edition = "2018"; + sha256 = "137fdxy5amg9zkpa1kqnj7bnha6b94fmddz59w973x96gqxmijjb"; + features = { + "default" = [ "std" ]; + "portable-atomic" = [ "dep:portable-atomic" ]; + "std" = [ "alloc" ]; + }; + resolvedDefaultFeatures = [ "alloc" "std" ]; + }; + "futures-executor" = rec { + crateName = "futures-executor"; + version = "0.3.28"; + edition = "2018"; + sha256 = "1q468di96knnla72xdvswic1ir2qkrf5czsdigc5n4l86a1fxv6c"; + dependencies = [ + { + name = "futures-core"; + packageId = "futures-core"; + usesDefaultFeatures = false; + } + { + name = "futures-task"; + packageId = "futures-task"; + usesDefaultFeatures = false; + } + { + name = "futures-util"; + packageId = "futures-util"; + usesDefaultFeatures = false; + } + ]; + features = { + "default" = [ "std" ]; + "num_cpus" = [ "dep:num_cpus" ]; + "std" = [ "futures-core/std" "futures-task/std" "futures-util/std" ]; + "thread-pool" = [ "std" "num_cpus" ]; + }; + resolvedDefaultFeatures = [ "default" "std" ]; + }; + "futures-io" = rec { + crateName = "futures-io"; + version = "0.3.28"; + edition = "2018"; + sha256 = "0r4rhkdhq1my4fahlhz59barqa511bylq813w3w4gvbidq4p9zsg"; + features = { + "default" = [ "std" ]; + }; + resolvedDefaultFeatures = [ "default" "std" ]; + }; + "futures-macro" = rec { + crateName = "futures-macro"; + version = "0.3.28"; + edition = "2018"; + sha256 = "0wpfsqxwqk5k569xl0jzz4zxy85x695mndf7y9jn66q6jid59jl9"; + procMacro = true; + dependencies = [ + { + name = "proc-macro2"; + packageId = "proc-macro2"; + } + { + name = "quote"; + packageId = "quote"; + } + { + name = "syn"; + packageId = "syn 2.0.13"; + features = [ "full" ]; + } + ]; + + }; + "futures-task" = rec { + crateName = "futures-task"; + version = "0.3.28"; + edition = "2018"; + sha256 = "0ravgihyarbplj32zp60asirfnaalw2wfsa0afhnl3kcpqrd3lvn"; + features = { + "default" = [ "std" ]; + "std" = [ "alloc" ]; + }; + resolvedDefaultFeatures = [ "alloc" "std" ]; + }; + "futures-util" = rec { + crateName = "futures-util"; + version = "0.3.28"; + edition = "2018"; + sha256 = "0cwmls9369w6q6hwlbm10q0plr6hmg8w28fpqvv4rmbjnx01xc16"; + dependencies = [ + { + name = "futures-core"; + packageId = "futures-core"; + usesDefaultFeatures = false; + } + { + name = "futures-macro"; + packageId = "futures-macro"; + optional = true; + usesDefaultFeatures = false; + } + { + name = "futures-task"; + packageId = "futures-task"; + usesDefaultFeatures = false; + } + { + name = "pin-project-lite"; + packageId = "pin-project-lite"; + } + { + name = "pin-utils"; + packageId = "pin-utils"; + } + { + name = "slab"; + packageId = "slab"; + optional = true; + } + ]; + features = { + "alloc" = [ "futures-core/alloc" "futures-task/alloc" ]; + "async-await-macro" = [ "async-await" "futures-macro" ]; + "channel" = [ "std" "futures-channel" ]; + "compat" = [ "std" "futures_01" ]; + "default" = [ "std" "async-await" "async-await-macro" ]; + "futures-channel" = [ "dep:futures-channel" ]; + "futures-io" = [ "dep:futures-io" ]; + "futures-macro" = [ "dep:futures-macro" ]; + "futures-sink" = [ "dep:futures-sink" ]; + "futures_01" = [ "dep:futures_01" ]; + "io" = [ "std" "futures-io" "memchr" ]; + "io-compat" = [ "io" "compat" "tokio-io" ]; + "memchr" = [ "dep:memchr" ]; + "portable-atomic" = [ "futures-core/portable-atomic" ]; + "sink" = [ "futures-sink" ]; + "slab" = [ "dep:slab" ]; + "std" = [ "alloc" "futures-core/std" "futures-task/std" "slab" ]; + "tokio-io" = [ "dep:tokio-io" ]; + "unstable" = [ "futures-core/unstable" "futures-task/unstable" ]; + "write-all-vectored" = [ "io" ]; + }; + resolvedDefaultFeatures = [ "alloc" "async-await" "async-await-macro" "default" "futures-macro" "slab" "std" ]; + }; + "gdk-pixbuf" = rec { + crateName = "gdk-pixbuf"; + version = "0.17.0"; + edition = "2021"; + sha256 = "1gsrgxnz3mgi20r6axm6qnfq58qdh3chgl85k0yvs1xlqvhgn8xh"; + libName = "gdk_pixbuf"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "bitflags"; + packageId = "bitflags"; + } + { + name = "gdk-pixbuf-sys"; + packageId = "gdk-pixbuf-sys"; + rename = "ffi"; + } + { + name = "gio"; + packageId = "gio"; + } + { + name = "glib"; + packageId = "glib"; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "once_cell"; + packageId = "once_cell"; + } + ]; + features = { + "dox" = [ "glib/dox" "gio/dox" "ffi/dox" ]; + "v2_40" = [ "ffi/v2_40" ]; + "v2_42" = [ "v2_40" "ffi/v2_42" ]; + }; + }; + "gdk-pixbuf-sys" = rec { + crateName = "gdk-pixbuf-sys"; + version = "0.17.0"; + edition = "2021"; + sha256 = "0fqy77sb5zrqjf0cjgllxpaqn0v3l595d4nkfy9djjgd8hmvshbv"; + libName = "gdk_pixbuf_sys"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "gio-sys"; + packageId = "gio-sys"; + rename = "gio"; + } + { + name = "glib-sys"; + packageId = "glib-sys"; + rename = "glib"; + } + { + name = "gobject-sys"; + packageId = "gobject-sys"; + rename = "gobject"; + } + { + name = "libc"; + packageId = "libc"; + } + ]; + buildDependencies = [ + { + name = "system-deps"; + packageId = "system-deps"; + } + ]; + features = { + "dox" = [ "glib/dox" "gobject/dox" "gio/dox" ]; + "v2_42" = [ "v2_40" ]; + }; + }; + "gdk4" = rec { + crateName = "gdk4"; + version = "0.6.3"; + edition = "2021"; + sha256 = "1zri4z8nxsp88mvk8vhk6xqpc4g1l69zi9w1z3fkwvm211jgkay3"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "bitflags"; + packageId = "bitflags"; + } + { + name = "cairo-rs"; + packageId = "cairo-rs"; + } + { + name = "gdk-pixbuf"; + packageId = "gdk-pixbuf"; + } + { + name = "gdk4-sys"; + packageId = "gdk4-sys"; + rename = "ffi"; + } + { + name = "gio"; + packageId = "gio"; + features = [ "v2_66" ]; + } + { + name = "glib"; + packageId = "glib"; + features = [ "v2_66" ]; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "pango"; + packageId = "pango"; + features = [ "v1_46" ]; + } + ]; + features = { + "dox" = [ "ffi/dox" "glib/dox" "gio/dox" "gdk-pixbuf/dox" "cairo-rs/dox" "pango/dox" ]; + "v4_10" = [ "ffi/v4_10" "v4_8" ]; + "v4_2" = [ "ffi/v4_2" ]; + "v4_4" = [ "ffi/v4_4" "v4_2" ]; + "v4_6" = [ "ffi/v4_6" "v4_4" ]; + "v4_8" = [ "ffi/v4_8" "v4_6" ]; + }; + }; + "gdk4-sys" = rec { + crateName = "gdk4-sys"; + version = "0.6.3"; + edition = "2021"; + sha256 = "0r7dm9vyzg2xlzdgxqa190gd1403mhw4q09x754rq24cc2hjmj8v"; + libName = "gdk4_sys"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "cairo-sys-rs"; + packageId = "cairo-sys-rs"; + rename = "cairo"; + } + { + name = "gdk-pixbuf-sys"; + packageId = "gdk-pixbuf-sys"; + rename = "gdk_pixbuf"; + } + { + name = "gio-sys"; + packageId = "gio-sys"; + rename = "gio"; + } + { + name = "glib-sys"; + packageId = "glib-sys"; + rename = "glib"; + } + { + name = "gobject-sys"; + packageId = "gobject-sys"; + rename = "gobject"; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "pango-sys"; + packageId = "pango-sys"; + rename = "pango"; + } + ]; + buildDependencies = [ + { + name = "pkg-config"; + packageId = "pkg-config"; + } + { + name = "system-deps"; + packageId = "system-deps"; + } + ]; + features = { + "dox" = [ "glib/dox" "gobject/dox" "gio/dox" "gdk_pixbuf/dox" "pango/dox" "cairo/dox" ]; + "v4_10" = [ "v4_8" ]; + "v4_4" = [ "v4_2" ]; + "v4_6" = [ "v4_4" ]; + "v4_8" = [ "v4_6" ]; + }; + }; + "gio" = rec { + crateName = "gio"; + version = "0.17.4"; + edition = "2021"; + sha256 = "09918ip09dabwllr2xcsnkfgb36331i4db173inngv12x6sa6q92"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "bitflags"; + packageId = "bitflags"; + } + { + name = "futures-channel"; + packageId = "futures-channel"; + } + { + name = "futures-core"; + packageId = "futures-core"; + usesDefaultFeatures = false; + } + { + name = "futures-io"; + packageId = "futures-io"; + } + { + name = "futures-util"; + packageId = "futures-util"; + usesDefaultFeatures = false; + } + { + name = "gio-sys"; + packageId = "gio-sys"; + rename = "ffi"; + } + { + name = "glib"; + packageId = "glib"; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "once_cell"; + packageId = "once_cell"; + } + { + name = "pin-project-lite"; + packageId = "pin-project-lite"; + } + { + name = "smallvec"; + packageId = "smallvec"; + } + { + name = "thiserror"; + packageId = "thiserror"; + } + ]; + devDependencies = [ + { + name = "futures-util"; + packageId = "futures-util"; + features = [ "io" ]; + } + ]; + features = { + "dox" = [ "ffi/dox" "glib/dox" ]; + "v2_58" = [ "ffi/v2_58" "glib/v2_58" ]; + "v2_60" = [ "v2_58" "ffi/v2_60" "glib/v2_60" ]; + "v2_62" = [ "v2_60" "ffi/v2_62" "glib/v2_62" ]; + "v2_64" = [ "v2_62" "ffi/v2_64" "glib/v2_64" ]; + "v2_66" = [ "v2_64" "ffi/v2_66" "glib/v2_66" ]; + "v2_68" = [ "v2_66" "ffi/v2_68" "glib/v2_68" ]; + "v2_70" = [ "v2_68" "ffi/v2_70" "glib/v2_70" ]; + "v2_72" = [ "v2_70" "ffi/v2_72" "glib/v2_72" ]; + "v2_74" = [ "v2_72" "ffi/v2_74" "glib/v2_74" ]; + "v2_76" = [ "v2_74" "ffi/v2_76" "glib/v2_76" ]; + }; + resolvedDefaultFeatures = [ "v2_58" "v2_60" "v2_62" "v2_64" "v2_66" ]; + }; + "gio-sys" = rec { + crateName = "gio-sys"; + version = "0.17.4"; + edition = "2021"; + sha256 = "19b2wdwdn6gbjnqac2klymbi51wj27jazv24a92li2wnsyq467bb"; + libName = "gio_sys"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "glib-sys"; + packageId = "glib-sys"; + rename = "glib"; + } + { + name = "gobject-sys"; + packageId = "gobject-sys"; + rename = "gobject"; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "winapi"; + packageId = "winapi"; + target = { target, features }: (target."windows" or false); + features = [ "ws2def" "winsock2" ]; + } + ]; + buildDependencies = [ + { + name = "system-deps"; + packageId = "system-deps"; + } + ]; + features = { + "dox" = [ "glib/dox" "gobject/dox" ]; + "v2_60" = [ "v2_58" ]; + "v2_62" = [ "v2_60" ]; + "v2_64" = [ "v2_62" ]; + "v2_66" = [ "v2_64" ]; + "v2_68" = [ "v2_66" ]; + "v2_70" = [ "v2_68" ]; + "v2_72" = [ "v2_70" ]; + "v2_74" = [ "v2_72" ]; + "v2_76" = [ "v2_74" ]; + }; + resolvedDefaultFeatures = [ "v2_58" "v2_60" "v2_62" "v2_64" "v2_66" ]; + }; + "glib" = rec { + crateName = "glib"; + version = "0.17.5"; + edition = "2021"; + sha256 = "0ws7hmiaywwvdjp9njjjfs92a0cy68p2sb19d5lxg5b1fmhk1dfg"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "bitflags"; + packageId = "bitflags"; + } + { + name = "futures-channel"; + packageId = "futures-channel"; + } + { + name = "futures-core"; + packageId = "futures-core"; + usesDefaultFeatures = false; + } + { + name = "futures-executor"; + packageId = "futures-executor"; + } + { + name = "futures-task"; + packageId = "futures-task"; + usesDefaultFeatures = false; + } + { + name = "futures-util"; + packageId = "futures-util"; + } + { + name = "gio-sys"; + packageId = "gio-sys"; + rename = "gio_ffi"; + optional = true; + } + { + name = "glib-macros"; + packageId = "glib-macros"; + } + { + name = "glib-sys"; + packageId = "glib-sys"; + rename = "ffi"; + } + { + name = "gobject-sys"; + packageId = "gobject-sys"; + rename = "gobject_ffi"; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "memchr"; + packageId = "memchr"; + } + { + name = "once_cell"; + packageId = "once_cell"; + } + { + name = "smallvec"; + packageId = "smallvec"; + } + { + name = "thiserror"; + packageId = "thiserror"; + } + ]; + features = { + "default" = [ "gio" ]; + "dox" = [ "ffi/dox" "gobject_ffi/dox" "log_macros" ]; + "gio" = [ "gio_ffi" ]; + "gio_ffi" = [ "dep:gio_ffi" ]; + "log" = [ "rs-log" ]; + "log_macros" = [ "log" ]; + "rs-log" = [ "dep:rs-log" ]; + "v2_58" = [ "ffi/v2_58" "gobject_ffi/v2_58" ]; + "v2_60" = [ "v2_58" "ffi/v2_60" ]; + "v2_62" = [ "v2_60" "ffi/v2_62" "gobject_ffi/v2_62" ]; + "v2_64" = [ "v2_62" "ffi/v2_64" ]; + "v2_66" = [ "v2_64" "ffi/v2_66" "gobject_ffi/v2_66" ]; + "v2_68" = [ "v2_66" "ffi/v2_68" "gobject_ffi/v2_68" ]; + "v2_70" = [ "v2_68" "ffi/v2_70" "gobject_ffi/v2_70" ]; + "v2_72" = [ "v2_70" "ffi/v2_72" "gobject_ffi/v2_72" ]; + "v2_74" = [ "v2_72" "ffi/v2_74" "gobject_ffi/v2_74" ]; + "v2_76" = [ "v2_74" "ffi/v2_76" "gobject_ffi/v2_76" ]; + }; + resolvedDefaultFeatures = [ "default" "gio" "gio_ffi" "v2_58" "v2_60" "v2_62" "v2_64" "v2_66" ]; + }; + "glib-macros" = rec { + crateName = "glib-macros"; + version = "0.17.7"; + edition = "2021"; + sha256 = "1vyrx239ggyj8qcv1yivykaxp43ik1cam0q74sbg31i0293g6k5w"; + procMacro = true; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "anyhow"; + packageId = "anyhow"; + } + { + name = "heck"; + packageId = "heck"; + } + { + name = "proc-macro-crate"; + packageId = "proc-macro-crate"; + } + { + name = "proc-macro-error"; + packageId = "proc-macro-error"; + } + { + name = "proc-macro2"; + packageId = "proc-macro2"; + } + { + name = "quote"; + packageId = "quote"; + } + { + name = "syn"; + packageId = "syn 1.0.109"; + features = [ "full" ]; + } + ]; + + }; + "glib-sys" = rec { + crateName = "glib-sys"; + version = "0.17.4"; + edition = "2021"; + sha256 = "19c0ars1rpcyfx7k63k2pghxjh898f1mvwgzmmhqwm5zl780mw29"; + libName = "glib_sys"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "libc"; + packageId = "libc"; + } + ]; + buildDependencies = [ + { + name = "system-deps"; + packageId = "system-deps"; + } + ]; + features = { + "v2_60" = [ "v2_58" ]; + "v2_62" = [ "v2_60" ]; + "v2_64" = [ "v2_62" ]; + "v2_66" = [ "v2_64" ]; + "v2_68" = [ "v2_66" ]; + "v2_70" = [ "v2_68" ]; + "v2_72" = [ "v2_70" ]; + "v2_74" = [ "v2_72" ]; + "v2_76" = [ "v2_74" ]; + }; + resolvedDefaultFeatures = [ "v2_58" "v2_60" "v2_62" "v2_64" "v2_66" ]; + }; + "gobject-sys" = rec { + crateName = "gobject-sys"; + version = "0.17.4"; + edition = "2021"; + sha256 = "1l4kcw17y6dxb6b6wkw4f2ly624kmxbghg6av2r34im60005prqm"; + libName = "gobject_sys"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "glib-sys"; + packageId = "glib-sys"; + rename = "glib"; + } + { + name = "libc"; + packageId = "libc"; + } + ]; + buildDependencies = [ + { + name = "system-deps"; + packageId = "system-deps"; + } + ]; + features = { + "dox" = [ "glib/dox" ]; + "v2_62" = [ "v2_58" ]; + "v2_66" = [ "v2_62" ]; + "v2_68" = [ "v2_66" ]; + "v2_70" = [ "v2_68" ]; + "v2_72" = [ "v2_70" ]; + "v2_74" = [ "v2_72" ]; + "v2_76" = [ "v2_74" ]; + }; + resolvedDefaultFeatures = [ "v2_58" "v2_62" "v2_66" ]; + }; + "graphene-rs" = rec { + crateName = "graphene-rs"; + version = "0.17.1"; + edition = "2021"; + sha256 = "0mk2nkhs0cad45k0177z5h5d9w19qfv7aiwxz71dzr5hbdb13kr1"; + libName = "graphene"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "glib"; + packageId = "glib"; + } + { + name = "graphene-sys"; + packageId = "graphene-sys"; + rename = "ffi"; + } + { + name = "libc"; + packageId = "libc"; + } + ]; + features = { + "dox" = [ "ffi/dox" "glib/dox" ]; + }; + }; + "graphene-sys" = rec { + crateName = "graphene-sys"; + version = "0.17.0"; + edition = "2021"; + sha256 = "1ybsw0b51dsslln1ign799zn374fcz1nzv4g190nb5cdka2a906g"; + libName = "graphene_sys"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "glib-sys"; + packageId = "glib-sys"; + rename = "glib"; + } + { + name = "libc"; + packageId = "libc"; + } + ]; + buildDependencies = [ + { + name = "pkg-config"; + packageId = "pkg-config"; + } + { + name = "system-deps"; + packageId = "system-deps"; + } + ]; + features = { + "dox" = [ "glib/dox" ]; + }; + }; + "gsk4" = rec { + crateName = "gsk4"; + version = "0.6.3"; + edition = "2021"; + sha256 = "0g1srhahmhdl6rqbz98bawzf1gp6hf9m4y4rvbi1bb3wz92fy0bg"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "bitflags"; + packageId = "bitflags"; + } + { + name = "cairo-rs"; + packageId = "cairo-rs"; + } + { + name = "gdk4"; + packageId = "gdk4"; + rename = "gdk"; + } + { + name = "glib"; + packageId = "glib"; + features = [ "v2_66" ]; + } + { + name = "graphene-rs"; + packageId = "graphene-rs"; + rename = "graphene"; + } + { + name = "gsk4-sys"; + packageId = "gsk4-sys"; + rename = "ffi"; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "pango"; + packageId = "pango"; + features = [ "v1_46" ]; + } + ]; + features = { + "dox" = [ "ffi/dox" "gdk/dox" "graphene/dox" "glib/dox" "cairo-rs/dox" "pango/dox" ]; + "v4_10" = [ "ffi/v4_10" "gdk/v4_10" "v4_6" ]; + "v4_2" = [ "ffi/v4_2" "gdk/v4_2" ]; + "v4_4" = [ "ffi/v4_4" "gdk/v4_4" "v4_2" ]; + "v4_6" = [ "ffi/v4_6" "gdk/v4_6" "v4_4" ]; + }; + }; + "gsk4-sys" = rec { + crateName = "gsk4-sys"; + version = "0.6.3"; + edition = "2021"; + sha256 = "1c013zdd0yzcfmkz1gj28dbfz2zmypi8baimjk9264yg9pxq8yn0"; + libName = "gsk4_sys"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "cairo-sys-rs"; + packageId = "cairo-sys-rs"; + rename = "cairo"; + } + { + name = "gdk4-sys"; + packageId = "gdk4-sys"; + rename = "gdk"; + } + { + name = "glib-sys"; + packageId = "glib-sys"; + rename = "glib"; + } + { + name = "gobject-sys"; + packageId = "gobject-sys"; + rename = "gobject"; + } + { + name = "graphene-sys"; + packageId = "graphene-sys"; + rename = "graphene"; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "pango-sys"; + packageId = "pango-sys"; + rename = "pango"; + } + ]; + buildDependencies = [ + { + name = "system-deps"; + packageId = "system-deps"; + } + ]; + features = { + "dox" = [ "glib/dox" "gobject/dox" "pango/dox" "cairo/dox" "graphene/dox" "gdk/dox" ]; + "v4_10" = [ "v4_6" ]; + "v4_4" = [ "v4_2" ]; + "v4_6" = [ "v4_4" ]; + }; + }; + "gtk4" = rec { + crateName = "gtk4"; + version = "0.6.4"; + edition = "2021"; + sha256 = "1vbl68q3xcqqnxxvq83vc13dflfdpxc3kc9xa7szc1d6nljf2c0y"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "bitflags"; + packageId = "bitflags"; + } + { + name = "cairo-rs"; + packageId = "cairo-rs"; + } + { + name = "field-offset"; + packageId = "field-offset"; + } + { + name = "futures-channel"; + packageId = "futures-channel"; + } + { + name = "gdk-pixbuf"; + packageId = "gdk-pixbuf"; + } + { + name = "gdk4"; + packageId = "gdk4"; + rename = "gdk"; + } + { + name = "gio"; + packageId = "gio"; + features = [ "v2_66" ]; + } + { + name = "glib"; + packageId = "glib"; + features = [ "v2_66" ]; + } + { + name = "graphene-rs"; + packageId = "graphene-rs"; + rename = "graphene"; + } + { + name = "gsk4"; + packageId = "gsk4"; + rename = "gsk"; + } + { + name = "gtk4-macros"; + packageId = "gtk4-macros"; + } + { + name = "gtk4-sys"; + packageId = "gtk4-sys"; + rename = "ffi"; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "once_cell"; + packageId = "once_cell"; + } + { + name = "pango"; + packageId = "pango"; + features = [ "v1_46" ]; + } + ]; + features = { + "blueprint" = [ "gtk4-macros/blueprint" ]; + "dox" = [ "gdk/dox" "gsk/dox" "ffi/dox" "cairo-rs/dox" "gdk-pixbuf/dox" "gio/dox" "glib/dox" "graphene/dox" "pango/dox" ]; + "gnome_42" = [ "v4_6" "cairo-rs/v1_16" "gdk-pixbuf/v2_42" "gio/v2_72" ]; + "gnome_43" = [ "v4_8" "cairo-rs/v1_16" "gdk-pixbuf/v2_42" "gio/v2_74" ]; + "gnome_44" = [ "v4_10" "cairo-rs/v1_16" "gdk-pixbuf/v2_42" "gio/v2_76" ]; + "v4_10" = [ "ffi/v4_10" "v4_8" "gdk/v4_10" "gsk/v4_10" ]; + "v4_2" = [ "ffi/v4_2" "gdk/v4_2" "gsk/v4_2" ]; + "v4_4" = [ "ffi/v4_4" "v4_2" "gdk/v4_4" "gsk/v4_4" ]; + "v4_6" = [ "ffi/v4_6" "v4_4" "gdk/v4_6" "gsk/v4_6" "pango/v1_50" ]; + "v4_8" = [ "ffi/v4_8" "v4_6" "gdk/v4_8" ]; + "xml_validation" = [ "gtk4-macros/xml_validation" ]; + }; + }; + "gtk4-macros" = rec { + crateName = "gtk4-macros"; + version = "0.6.5"; + edition = "2021"; + sha256 = "1w1f89qn5m5rlcfkzwapmyivy11n2cw1giijwh3gp2q9zfbsfhgh"; + procMacro = true; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "anyhow"; + packageId = "anyhow"; + } + { + name = "proc-macro-crate"; + packageId = "proc-macro-crate"; + } + { + name = "proc-macro-error"; + packageId = "proc-macro-error"; + } + { + name = "proc-macro2"; + packageId = "proc-macro2"; + } + { + name = "quote"; + packageId = "quote"; + } + { + name = "syn"; + packageId = "syn 1.0.109"; + features = [ "full" ]; + } + ]; + features = { + "quick-xml" = [ "dep:quick-xml" ]; + "xml_validation" = [ "quick-xml" ]; + }; + resolvedDefaultFeatures = [ "default" ]; + }; + "gtk4-sys" = rec { + crateName = "gtk4-sys"; + version = "0.6.3"; + edition = "2021"; + sha256 = "0bz26ix7pl4d1m63zacaw1vw5021vm5r7wn7fsg02zmh0zvq70jz"; + libName = "gtk4_sys"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "cairo-sys-rs"; + packageId = "cairo-sys-rs"; + rename = "cairo"; + } + { + name = "gdk-pixbuf-sys"; + packageId = "gdk-pixbuf-sys"; + rename = "gdk_pixbuf"; + } + { + name = "gdk4-sys"; + packageId = "gdk4-sys"; + rename = "gdk"; + } + { + name = "gio-sys"; + packageId = "gio-sys"; + rename = "gio"; + } + { + name = "glib-sys"; + packageId = "glib-sys"; + rename = "glib"; + } + { + name = "gobject-sys"; + packageId = "gobject-sys"; + rename = "gobject"; + } + { + name = "graphene-sys"; + packageId = "graphene-sys"; + rename = "graphene"; + } + { + name = "gsk4-sys"; + packageId = "gsk4-sys"; + rename = "gsk"; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "pango-sys"; + packageId = "pango-sys"; + rename = "pango"; + } + ]; + buildDependencies = [ + { + name = "system-deps"; + packageId = "system-deps"; + } + ]; + features = { + "dox" = [ "glib/dox" "gobject/dox" "gio/dox" "gdk_pixbuf/dox" "pango/dox" "cairo/dox" "graphene/dox" "gdk/dox" "gsk/dox" ]; + "v4_10" = [ "v4_8" ]; + "v4_12" = [ "v4_10" ]; + "v4_4" = [ "v4_2" ]; + "v4_6" = [ "v4_4" ]; + "v4_8" = [ "v4_6" ]; + }; + }; + "hashbrown" = rec { + crateName = "hashbrown"; + version = "0.12.3"; + edition = "2021"; + sha256 = "1268ka4750pyg2pbgsr43f0289l5zah4arir2k4igx5a8c6fg7la"; + authors = [ + "Amanieu d'Antras " + ]; + features = { + "ahash" = [ "dep:ahash" ]; + "ahash-compile-time-rng" = [ "ahash/compile-time-rng" ]; + "alloc" = [ "dep:alloc" ]; + "bumpalo" = [ "dep:bumpalo" ]; + "compiler_builtins" = [ "dep:compiler_builtins" ]; + "core" = [ "dep:core" ]; + "default" = [ "ahash" "inline-more" ]; + "rayon" = [ "dep:rayon" ]; + "rustc-dep-of-std" = [ "nightly" "core" "compiler_builtins" "alloc" "rustc-internal-api" ]; + "serde" = [ "dep:serde" ]; + }; + resolvedDefaultFeatures = [ "raw" ]; + }; + "heck" = rec { + crateName = "heck"; + version = "0.4.1"; + edition = "2018"; + sha256 = "1a7mqsnycv5z4z5vnv1k34548jzmc0ajic7c1j8jsaspnhw5ql4m"; + authors = [ + "Without Boats " + ]; + features = { + "unicode" = [ "unicode-segmentation" ]; + "unicode-segmentation" = [ "dep:unicode-segmentation" ]; + }; + resolvedDefaultFeatures = [ "default" ]; + }; + "indexmap" = rec { + crateName = "indexmap"; + version = "1.9.3"; + edition = "2021"; + sha256 = "16dxmy7yvk51wvnih3a3im6fp5lmx0wx76i03n06wyak6cwhw1xx"; + dependencies = [ + { + name = "hashbrown"; + packageId = "hashbrown"; + usesDefaultFeatures = false; + features = [ "raw" ]; + } + ]; + buildDependencies = [ + { + name = "autocfg"; + packageId = "autocfg"; + } + ]; + features = { + "arbitrary" = [ "dep:arbitrary" ]; + "quickcheck" = [ "dep:quickcheck" ]; + "rayon" = [ "dep:rayon" ]; + "rustc-rayon" = [ "dep:rustc-rayon" ]; + "serde" = [ "dep:serde" ]; + "serde-1" = [ "serde" ]; + }; + resolvedDefaultFeatures = [ "std" ]; + }; + "libc" = rec { + crateName = "libc"; + version = "0.2.141"; + edition = "2015"; + sha256 = "1dgl8sxpj94v2hwrcr5k2lcp8wk9s8a7l6vlk6z69fcv356sc11k"; + authors = [ + "The Rust Project Developers" + ]; + features = { + "default" = [ "std" ]; + "rustc-dep-of-std" = [ "align" "rustc-std-workspace-core" ]; + "rustc-std-workspace-core" = [ "dep:rustc-std-workspace-core" ]; + "use_std" = [ "std" ]; + }; + resolvedDefaultFeatures = [ "default" "std" ]; + }; + "memchr" = rec { + crateName = "memchr"; + version = "2.5.0"; + edition = "2018"; + sha256 = "0vanfk5mzs1g1syqnj03q8n0syggnhn55dq535h2wxr7rwpfbzrd"; + authors = [ + "Andrew Gallant " + "bluss" + ]; + features = { + "compiler_builtins" = [ "dep:compiler_builtins" ]; + "core" = [ "dep:core" ]; + "default" = [ "std" ]; + "libc" = [ "dep:libc" ]; + "rustc-dep-of-std" = [ "core" "compiler_builtins" ]; + "use_std" = [ "std" ]; + }; + resolvedDefaultFeatures = [ "default" "std" ]; + }; + "memoffset" = rec { + crateName = "memoffset"; + version = "0.8.0"; + edition = "2015"; + sha256 = "1qcdic88dhgw76pafgndpz04pig8il4advq978mxdxdwrydp276n"; + authors = [ + "Gilad Naaman " + ]; + buildDependencies = [ + { + name = "autocfg"; + packageId = "autocfg"; + } + ]; + features = { + }; + resolvedDefaultFeatures = [ "default" ]; + }; + "once_cell" = rec { + crateName = "once_cell"; + version = "1.17.1"; + edition = "2021"; + sha256 = "1lrsy9c5ikf2iwxr4iwgd3rlq9mg8alh0np1g8abnvp1k4151rdp"; + authors = [ + "Aleksey Kladov " + ]; + features = { + "alloc" = [ "race" ]; + "atomic-polyfill" = [ "critical-section" ]; + "atomic_polyfill" = [ "dep:atomic_polyfill" ]; + "critical-section" = [ "critical_section" "atomic_polyfill" ]; + "critical_section" = [ "dep:critical_section" ]; + "default" = [ "std" ]; + "parking_lot" = [ "parking_lot_core" ]; + "parking_lot_core" = [ "dep:parking_lot_core" ]; + "std" = [ "alloc" ]; + }; + resolvedDefaultFeatures = [ "alloc" "default" "race" "std" ]; + }; + "pango" = rec { + crateName = "pango"; + version = "0.17.4"; + edition = "2021"; + sha256 = "0dqdfzavw426ygqq2298fara29yygy79lddkmw4447l85aw81hjj"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "bitflags"; + packageId = "bitflags"; + } + { + name = "gio"; + packageId = "gio"; + } + { + name = "glib"; + packageId = "glib"; + } + { + name = "libc"; + packageId = "libc"; + } + { + name = "once_cell"; + packageId = "once_cell"; + } + { + name = "pango-sys"; + packageId = "pango-sys"; + rename = "ffi"; + } + ]; + features = { + "dox" = [ "ffi/dox" "glib/dox" "gio/dox" ]; + "v1_42" = [ "ffi/v1_42" ]; + "v1_44" = [ "v1_42" "ffi/v1_44" ]; + "v1_46" = [ "v1_44" "ffi/v1_46" ]; + "v1_48" = [ "v1_46" "ffi/v1_48" ]; + "v1_50" = [ "v1_48" "ffi/v1_50" ]; + "v1_52" = [ "v1_50" "ffi/v1_52" ]; + }; + resolvedDefaultFeatures = [ "v1_42" "v1_44" "v1_46" ]; + }; + "pango-sys" = rec { + crateName = "pango-sys"; + version = "0.17.0"; + edition = "2021"; + sha256 = "1s2xc94xwm3b6wzqh5pj6jkjml1cs070plrl8z1bapjjnpqd14s2"; + libName = "pango_sys"; + authors = [ + "The gtk-rs Project Developers" + ]; + dependencies = [ + { + name = "glib-sys"; + packageId = "glib-sys"; + rename = "glib"; + } + { + name = "gobject-sys"; + packageId = "gobject-sys"; + rename = "gobject"; + } + { + name = "libc"; + packageId = "libc"; + } + ]; + buildDependencies = [ + { + name = "system-deps"; + packageId = "system-deps"; + } + ]; + features = { + "dox" = [ "glib/dox" "gobject/dox" ]; + "v1_44" = [ "v1_42" ]; + "v1_46" = [ "v1_44" ]; + "v1_48" = [ "v1_46" ]; + "v1_50" = [ "v1_48" ]; + "v1_52" = [ "v1_50" ]; + }; + resolvedDefaultFeatures = [ "v1_42" "v1_44" "v1_46" ]; + }; + "pin-project-lite" = rec { + crateName = "pin-project-lite"; + version = "0.2.9"; + edition = "2018"; + sha256 = "05n1z851l356hpgqadw4ar64mjanaxq1qlwqsf2k05ziq8xax9z0"; + + }; + "pin-utils" = rec { + crateName = "pin-utils"; + version = "0.1.0"; + edition = "2018"; + sha256 = "117ir7vslsl2z1a7qzhws4pd01cg2d3338c47swjyvqv2n60v1wb"; + authors = [ + "Josef Brandl " + ]; + + }; + "pkg-config" = rec { + crateName = "pkg-config"; + version = "0.3.26"; + edition = "2015"; + sha256 = "0q2i61dhqvawc51zfzl3jich57w0cjgfa894hn6ings7ffgsbjba"; + authors = [ + "Alex Crichton " + ]; + + }; + "proc-macro-crate" = rec { + crateName = "proc-macro-crate"; + version = "1.3.1"; + edition = "2021"; + sha256 = "069r1k56bvgk0f58dm5swlssfcp79im230affwk6d9ck20g04k3z"; + authors = [ + "Bastian Köcher " + ]; + dependencies = [ + { + name = "once_cell"; + packageId = "once_cell"; + } + { + name = "toml_edit"; + packageId = "toml_edit"; + } + ]; + + }; + "proc-macro-error" = rec { + crateName = "proc-macro-error"; + version = "1.0.4"; + edition = "2018"; + sha256 = "1373bhxaf0pagd8zkyd03kkx6bchzf6g0dkwrwzsnal9z47lj9fs"; + authors = [ + "CreepySkeleton " + ]; + dependencies = [ + { + name = "proc-macro-error-attr"; + packageId = "proc-macro-error-attr"; + } + { + name = "proc-macro2"; + packageId = "proc-macro2"; + } + { + name = "quote"; + packageId = "quote"; + } + { + name = "syn"; + packageId = "syn 1.0.109"; + optional = true; + usesDefaultFeatures = false; + } + ]; + buildDependencies = [ + { + name = "version_check"; + packageId = "version_check"; + } + ]; + features = { + "default" = [ "syn-error" ]; + "syn" = [ "dep:syn" ]; + "syn-error" = [ "syn" ]; + }; + resolvedDefaultFeatures = [ "default" "syn" "syn-error" ]; + }; + "proc-macro-error-attr" = rec { + crateName = "proc-macro-error-attr"; + version = "1.0.4"; + edition = "2018"; + sha256 = "0sgq6m5jfmasmwwy8x4mjygx5l7kp8s4j60bv25ckv2j1qc41gm1"; + procMacro = true; + authors = [ + "CreepySkeleton " + ]; + dependencies = [ + { + name = "proc-macro2"; + packageId = "proc-macro2"; + } + { + name = "quote"; + packageId = "quote"; + } + ]; + buildDependencies = [ + { + name = "version_check"; + packageId = "version_check"; + } + ]; + + }; + "proc-macro2" = rec { + crateName = "proc-macro2"; + version = "1.0.56"; + edition = "2018"; + sha256 = "0ddlk2c7s9c0fhmf8cd0wikayicv9xrm9ck9vzgg9w86rnqbsqrb"; + authors = [ + "David Tolnay " + "Alex Crichton " + ]; + dependencies = [ + { + name = "unicode-ident"; + packageId = "unicode-ident"; + } + ]; + features = { + "default" = [ "proc-macro" ]; + }; + resolvedDefaultFeatures = [ "default" "proc-macro" ]; + }; + "quote" = rec { + crateName = "quote"; + version = "1.0.26"; + edition = "2018"; + sha256 = "1z521piwggwzs0rj4wjx4ma6af1g6f1h5dkp382y5akqyx5sy924"; + authors = [ + "David Tolnay " + ]; + dependencies = [ + { + name = "proc-macro2"; + packageId = "proc-macro2"; + usesDefaultFeatures = false; + } + ]; + features = { + "default" = [ "proc-macro" ]; + "proc-macro" = [ "proc-macro2/proc-macro" ]; + }; + resolvedDefaultFeatures = [ "default" "proc-macro" ]; + }; + "rustc_version" = rec { + crateName = "rustc_version"; + version = "0.4.0"; + edition = "2018"; + sha256 = "0rpk9rcdk405xhbmgclsh4pai0svn49x35aggl4nhbkd4a2zb85z"; + authors = [ + "Dirkjan Ochtman " + "Marvin Löbel " + ]; + dependencies = [ + { + name = "semver"; + packageId = "semver"; + } + ]; + + }; + "semver" = rec { + crateName = "semver"; + version = "1.0.17"; + edition = "2018"; + sha256 = "1vf03d99sikkradjj33q1l9h4fqgd1h7darjypic6pnh4qrkdgdy"; + authors = [ + "David Tolnay " + ]; + features = { + "default" = [ "std" ]; + "serde" = [ "dep:serde" ]; + }; + resolvedDefaultFeatures = [ "default" "std" ]; + }; + "serde" = rec { + crateName = "serde"; + version = "1.0.159"; + edition = "2015"; + sha256 = "0r9hd539dzp9b7h13w9akwh33pv8f3bvk449ym0yrbix7hsfh11w"; + authors = [ + "Erick Tryzelaar " + "David Tolnay " + ]; + features = { + "default" = [ "std" ]; + "derive" = [ "serde_derive" ]; + "serde_derive" = [ "dep:serde_derive" ]; + }; + resolvedDefaultFeatures = [ "default" "std" ]; + }; + "serde_spanned" = rec { + crateName = "serde_spanned"; + version = "0.6.1"; + edition = "2021"; + sha256 = "1x7wqhqay4bgkaq8dmvb9z01mk2z0j0g9jl5nb9ynv3aanpqrz8f"; + dependencies = [ + { + name = "serde"; + packageId = "serde"; + optional = true; + } + ]; + features = { + "serde" = [ "dep:serde" ]; + }; + resolvedDefaultFeatures = [ "serde" ]; + }; + "slab" = rec { + crateName = "slab"; + version = "0.4.8"; + edition = "2018"; + sha256 = "0bgwxig8gkqp6gz8rvrpdj6qwa10karnsxwx7wsj5ay8kcf3aa35"; + authors = [ + "Carl Lerche " + ]; + buildDependencies = [ + { + name = "autocfg"; + packageId = "autocfg"; + } + ]; + features = { + "default" = [ "std" ]; + "serde" = [ "dep:serde" ]; + }; + resolvedDefaultFeatures = [ "default" "std" ]; + }; + "smallvec" = rec { + crateName = "smallvec"; + version = "1.10.0"; + edition = "2018"; + sha256 = "1q2k15fzxgwjpcdv3f323w24rbbfyv711ayz85ila12lg7zbw1x5"; + authors = [ + "The Servo Project Developers" + ]; + features = { + "arbitrary" = [ "dep:arbitrary" ]; + "const_new" = [ "const_generics" ]; + "serde" = [ "dep:serde" ]; + }; + }; + "syn 1.0.109" = rec { + crateName = "syn"; + version = "1.0.109"; + edition = "2018"; + sha256 = "0ds2if4600bd59wsv7jjgfkayfzy3hnazs394kz6zdkmna8l3dkj"; + authors = [ + "David Tolnay " + ]; + dependencies = [ + { + name = "proc-macro2"; + packageId = "proc-macro2"; + usesDefaultFeatures = false; + } + { + name = "quote"; + packageId = "quote"; + optional = true; + usesDefaultFeatures = false; + } + { + name = "unicode-ident"; + packageId = "unicode-ident"; + } + ]; + features = { + "default" = [ "derive" "parsing" "printing" "clone-impls" "proc-macro" ]; + "printing" = [ "quote" ]; + "proc-macro" = [ "proc-macro2/proc-macro" "quote/proc-macro" ]; + "quote" = [ "dep:quote" ]; + "test" = [ "syn-test-suite/all-features" ]; + }; + resolvedDefaultFeatures = [ "clone-impls" "default" "derive" "full" "parsing" "printing" "proc-macro" "quote" ]; + }; + "syn 2.0.13" = rec { + crateName = "syn"; + version = "2.0.13"; + edition = "2021"; + sha256 = "1v68ggs5q0addc3z49kqzqfac5xcdnppdl7b6vww2ni8qmbs97ac"; + authors = [ + "David Tolnay " + ]; + dependencies = [ + { + name = "proc-macro2"; + packageId = "proc-macro2"; + usesDefaultFeatures = false; + } + { + name = "quote"; + packageId = "quote"; + optional = true; + usesDefaultFeatures = false; + } + { + name = "unicode-ident"; + packageId = "unicode-ident"; + } + ]; + features = { + "default" = [ "derive" "parsing" "printing" "clone-impls" "proc-macro" ]; + "printing" = [ "quote" ]; + "proc-macro" = [ "proc-macro2/proc-macro" "quote/proc-macro" ]; + "quote" = [ "dep:quote" ]; + "test" = [ "syn-test-suite/all-features" ]; + }; + resolvedDefaultFeatures = [ "clone-impls" "default" "derive" "full" "parsing" "printing" "proc-macro" "quote" ]; + }; + "system-deps" = rec { + crateName = "system-deps"; + version = "6.0.4"; + edition = "2018"; + sha256 = "0pxh43rd2vr3r3g1kczjkk740ch2s0xbhsx364wny9gng8achpsm"; + authors = [ + "Guillaume Desmottes " + "Josh Triplett " + ]; + dependencies = [ + { + name = "cfg-expr"; + packageId = "cfg-expr"; + } + { + name = "heck"; + packageId = "heck"; + } + { + name = "pkg-config"; + packageId = "pkg-config"; + } + { + name = "toml"; + packageId = "toml"; + usesDefaultFeatures = false; + features = [ "parse" ]; + } + { + name = "version-compare"; + packageId = "version-compare"; + } + ]; + + }; + "thiserror" = rec { + crateName = "thiserror"; + version = "1.0.40"; + edition = "2018"; + sha256 = "1b7bdhriasdsr99y39d50jz995xaz9sw3hsbb6z9kp6q9cqrm34p"; + authors = [ + "David Tolnay " + ]; + dependencies = [ + { + name = "thiserror-impl"; + packageId = "thiserror-impl"; + } + ]; + + }; + "thiserror-impl" = rec { + crateName = "thiserror-impl"; + version = "1.0.40"; + edition = "2018"; + sha256 = "17sn41kyimc6s983aypkk6a45pcyrkbkvrw6rp407n5hqm16ligr"; + procMacro = true; + authors = [ + "David Tolnay " + ]; + dependencies = [ + { + name = "proc-macro2"; + packageId = "proc-macro2"; + } + { + name = "quote"; + packageId = "quote"; + } + { + name = "syn"; + packageId = "syn 2.0.13"; + } + ]; + + }; + "toml" = rec { + crateName = "toml"; + version = "0.5.11"; + edition = "2018"; + sha256 = "0d2266nx8b3n22c7k24x4428z6di8n83a9n466jm7a2hipfz1xzl"; + authors = [ + "Alex Crichton " + ]; + dependencies = [ + { + name = "serde"; + packageId = "serde"; + } + ]; + features = { + "indexmap" = [ "dep:indexmap" ]; + "preserve_order" = [ "indexmap" ]; + }; + }; + "toml_datetime" = rec { + crateName = "toml_datetime"; + version = "0.6.1"; + edition = "2021"; + sha256 = "08lndxs1bval859mlas0k4f032s26c9k6pzd589m02z1vqpfvf1s"; + authors = [ + "Alex Crichton " + ]; + dependencies = [ + { + name = "serde"; + packageId = "serde"; + optional = true; + } + ]; + features = { + "serde" = [ "dep:serde" ]; + }; + resolvedDefaultFeatures = [ "serde" ]; + }; + "toml_edit" = rec { + crateName = "toml_edit"; + version = "0.19.8"; + edition = "2021"; + sha256 = "04ywrxn4c7q4ph1vir310nsgvcd3cdqp1ri7d52jb0cyc3411513"; + authors = [ + "Andronik Ordian " + "Ed Page " + ]; + dependencies = [ + { + name = "indexmap"; + packageId = "indexmap"; + features = [ "std" ]; + } + { + name = "serde"; + packageId = "serde"; + optional = true; + } + { + name = "serde_spanned"; + packageId = "serde_spanned"; + optional = true; + features = [ "serde" ]; + } + { + name = "toml_datetime"; + packageId = "toml_datetime"; + } + { + name = "winnow"; + packageId = "winnow"; + } + ]; + features = { + "perf" = [ "dep:kstring" ]; + "serde" = [ "dep:serde" "toml_datetime/serde" "dep:serde_spanned" ]; + }; + resolvedDefaultFeatures = [ "default" "serde" ]; + }; + "unicode-ident" = rec { + crateName = "unicode-ident"; + version = "1.0.8"; + edition = "2018"; + sha256 = "1x4v4v95fv9gn5zbpm23sa9awjvmclap1wh1lmikmw9rna3llip5"; + authors = [ + "David Tolnay " + ]; + + }; + "version-compare" = rec { + crateName = "version-compare"; + version = "0.1.1"; + edition = "2018"; + sha256 = "0acg4pmjdbmclg0m7yhijn979mdy66z3k8qrcnvn634f1gy456jp"; + authors = [ + "Tim Visee <3a4fb3964f@sinenomine.email>" + ]; + + }; + "version_check" = rec { + crateName = "version_check"; + version = "0.9.4"; + edition = "2015"; + sha256 = "0gs8grwdlgh0xq660d7wr80x14vxbizmd8dbp29p2pdncx8lp1s9"; + authors = [ + "Sergio Benitez " + ]; + + }; + "winapi" = rec { + crateName = "winapi"; + version = "0.3.9"; + edition = "2015"; + sha256 = "06gl025x418lchw1wxj64ycr7gha83m44cjr5sarhynd9xkrm0sw"; + authors = [ + "Peter Atashian " + ]; + dependencies = [ + { + name = "winapi-i686-pc-windows-gnu"; + packageId = "winapi-i686-pc-windows-gnu"; + target = { target, features }: (stdenv.hostPlatform.config == "i686-pc-windows-gnu"); + } + { + name = "winapi-x86_64-pc-windows-gnu"; + packageId = "winapi-x86_64-pc-windows-gnu"; + target = { target, features }: (stdenv.hostPlatform.config == "x86_64-pc-windows-gnu"); + } + ]; + features = { + "debug" = [ "impl-debug" ]; + }; + resolvedDefaultFeatures = [ "winsock2" "ws2def" ]; + }; + "winapi-i686-pc-windows-gnu" = rec { + crateName = "winapi-i686-pc-windows-gnu"; + version = "0.4.0"; + edition = "2015"; + sha256 = "1dmpa6mvcvzz16zg6d5vrfy4bxgg541wxrcip7cnshi06v38ffxc"; + authors = [ + "Peter Atashian " + ]; + + }; + "winapi-x86_64-pc-windows-gnu" = rec { + crateName = "winapi-x86_64-pc-windows-gnu"; + version = "0.4.0"; + edition = "2015"; + sha256 = "0gqq64czqb64kskjryj8isp62m2sgvx25yyj3kpc2myh85w24bki"; + authors = [ + "Peter Atashian " + ]; + + }; + "winnow" = rec { + crateName = "winnow"; + version = "0.4.1"; + edition = "2021"; + sha256 = "0a2b9f0n6fpn2a88jfbp1kdjj6xrhvf8arnny67qsjb6djrp12df"; + dependencies = [ + { + name = "memchr"; + packageId = "memchr"; + optional = true; + usesDefaultFeatures = false; + } + ]; + features = { + "debug" = [ "dep:anstyle" "dep:is-terminal" "dep:terminal_size" "dep:concolor" ]; + "default" = [ "std" ]; + "simd" = [ "dep:memchr" ]; + "std" = [ "alloc" "memchr?/std" ]; + "unstable-doc" = [ "alloc" "std" "simd" ]; + }; + resolvedDefaultFeatures = [ "alloc" "default" "std" ]; + }; + }; + + # +# crate2nix/default.nix (excerpt start) +# + + /* Target (platform) data for conditional dependencies. + This corresponds roughly to what buildRustCrate is setting. + */ + defaultTarget = { + unix = true; + windows = false; + fuchsia = true; + test = false; + + # This doesn't appear to be officially documented anywhere yet. + # See https://github.com/rust-lang-nursery/rust-forge/issues/101. + os = + if stdenv.hostPlatform.isDarwin + then "macos" + else stdenv.hostPlatform.parsed.kernel.name; + arch = stdenv.hostPlatform.parsed.cpu.name; + family = "unix"; + env = "gnu"; + endian = + if stdenv.hostPlatform.parsed.cpu.significantByte.name == "littleEndian" + then "little" else "big"; + pointer_width = toString stdenv.hostPlatform.parsed.cpu.bits; + vendor = stdenv.hostPlatform.parsed.vendor.name; + debug_assertions = false; + }; + + /* Filters common temp files and build files. */ + # TODO(pkolloch): Substitute with gitignore filter + sourceFilter = name: type: + let + baseName = builtins.baseNameOf (builtins.toString name); + in + ! ( + # Filter out git + baseName == ".gitignore" + || (type == "directory" && baseName == ".git") + + # Filter out build results + || ( + type == "directory" && ( + baseName == "target" + || baseName == "_site" + || baseName == ".sass-cache" + || baseName == ".jekyll-metadata" + || baseName == "build-artifacts" + ) + ) + + # Filter out nix-build result symlinks + || ( + type == "symlink" && lib.hasPrefix "result" baseName + ) + + # Filter out IDE config + || ( + type == "directory" && ( + baseName == ".idea" || baseName == ".vscode" + ) + ) || lib.hasSuffix ".iml" baseName + + # Filter out nix build files + || baseName == "Cargo.nix" + + # Filter out editor backup / swap files. + || lib.hasSuffix "~" baseName + || builtins.match "^\\.sw[a-z]$$" baseName != null + || builtins.match "^\\..*\\.sw[a-z]$$" baseName != null + || lib.hasSuffix ".tmp" baseName + || lib.hasSuffix ".bak" baseName + || baseName == "tests.nix" + ); + + /* Returns a crate which depends on successful test execution + of crate given as the second argument. + + testCrateFlags: list of flags to pass to the test exectuable + testInputs: list of packages that should be available during test execution + */ + crateWithTest = { crate, testCrate, testCrateFlags, testInputs, testPreRun, testPostRun }: + assert builtins.typeOf testCrateFlags == "list"; + assert builtins.typeOf testInputs == "list"; + assert builtins.typeOf testPreRun == "string"; + assert builtins.typeOf testPostRun == "string"; + let + # override the `crate` so that it will build and execute tests instead of + # building the actual lib and bin targets We just have to pass `--test` + # to rustc and it will do the right thing. We execute the tests and copy + # their log and the test executables to $out for later inspection. + test = + let + drv = testCrate.override + ( + _: { + buildTests = true; + } + ); + # If the user hasn't set any pre/post commands, we don't want to + # insert empty lines. This means that any existing users of crate2nix + # don't get a spurious rebuild unless they set these explicitly. + testCommand = pkgs.lib.concatStringsSep "\n" + (pkgs.lib.filter (s: s != "") [ + testPreRun + "$f $testCrateFlags 2>&1 | tee -a $out" + testPostRun + ]); + in + pkgs.runCommand "run-tests-${testCrate.name}" + { + inherit testCrateFlags; + buildInputs = testInputs; + } '' + set -ex + + export RUST_BACKTRACE=1 + + # recreate a file hierarchy as when running tests with cargo + + # the source for test data + ${pkgs.xorg.lndir}/bin/lndir ${crate.src} + + # build outputs + testRoot=target/debug + mkdir -p $testRoot + + # executables of the crate + # we copy to prevent std::env::current_exe() to resolve to a store location + for i in ${crate}/bin/*; do + cp "$i" "$testRoot" + done + chmod +w -R . + + # test harness executables are suffixed with a hash, like cargo does + # this allows to prevent name collision with the main + # executables of the crate + hash=$(basename $out) + for file in ${drv}/tests/*; do + f=$testRoot/$(basename $file)-$hash + cp $file $f + ${testCommand} + done + ''; + in + pkgs.runCommand "${crate.name}-linked" + { + inherit (crate) outputs crateName; + passthru = (crate.passthru or { }) // { + inherit test; + }; + } '' + echo tested by ${test} + ${lib.concatMapStringsSep "\n" (output: "ln -s ${crate.${output}} ${"$"}${output}") crate.outputs} + ''; + + /* A restricted overridable version of builtRustCratesWithFeatures. */ + buildRustCrateWithFeatures = + { packageId + , features ? rootFeatures + , crateOverrides ? defaultCrateOverrides + , buildRustCrateForPkgsFunc ? null + , runTests ? false + , testCrateFlags ? [ ] + , testInputs ? [ ] + # Any command to run immediatelly before a test is executed. + , testPreRun ? "" + # Any command run immediatelly after a test is executed. + , testPostRun ? "" + }: + lib.makeOverridable + ( + { features + , crateOverrides + , runTests + , testCrateFlags + , testInputs + , testPreRun + , testPostRun + }: + let + buildRustCrateForPkgsFuncOverriden = + if buildRustCrateForPkgsFunc != null + then buildRustCrateForPkgsFunc + else + ( + if crateOverrides == pkgs.defaultCrateOverrides + then buildRustCrateForPkgs + else + pkgs: (buildRustCrateForPkgs pkgs).override { + defaultCrateOverrides = crateOverrides; + } + ); + builtRustCrates = builtRustCratesWithFeatures { + inherit packageId features; + buildRustCrateForPkgsFunc = buildRustCrateForPkgsFuncOverriden; + runTests = false; + }; + builtTestRustCrates = builtRustCratesWithFeatures { + inherit packageId features; + buildRustCrateForPkgsFunc = buildRustCrateForPkgsFuncOverriden; + runTests = true; + }; + drv = builtRustCrates.crates.${packageId}; + testDrv = builtTestRustCrates.crates.${packageId}; + derivation = + if runTests then + crateWithTest + { + crate = drv; + testCrate = testDrv; + inherit testCrateFlags testInputs testPreRun testPostRun; + } + else drv; + in + derivation + ) + { inherit features crateOverrides runTests testCrateFlags testInputs testPreRun testPostRun; }; + + /* Returns an attr set with packageId mapped to the result of buildRustCrateForPkgsFunc + for the corresponding crate. + */ + builtRustCratesWithFeatures = + { packageId + , features + , crateConfigs ? crates + , buildRustCrateForPkgsFunc + , runTests + , target ? defaultTarget + } @ args: + assert (builtins.isAttrs crateConfigs); + assert (builtins.isString packageId); + assert (builtins.isList features); + assert (builtins.isAttrs target); + assert (builtins.isBool runTests); + let + rootPackageId = packageId; + mergedFeatures = mergePackageFeatures + ( + args // { + inherit rootPackageId; + target = target // { test = runTests; }; + } + ); + # Memoize built packages so that reappearing packages are only built once. + builtByPackageIdByPkgs = mkBuiltByPackageIdByPkgs pkgs; + mkBuiltByPackageIdByPkgs = pkgs: + let + self = { + crates = lib.mapAttrs (packageId: value: buildByPackageIdForPkgsImpl self pkgs packageId) crateConfigs; + build = mkBuiltByPackageIdByPkgs pkgs.buildPackages; + }; + in + self; + buildByPackageIdForPkgsImpl = self: pkgs: packageId: + let + features = mergedFeatures."${packageId}" or [ ]; + crateConfig' = crateConfigs."${packageId}"; + crateConfig = + builtins.removeAttrs crateConfig' [ "resolvedDefaultFeatures" "devDependencies" ]; + devDependencies = + lib.optionals + (runTests && packageId == rootPackageId) + (crateConfig'.devDependencies or [ ]); + dependencies = + dependencyDerivations { + inherit features target; + buildByPackageId = depPackageId: + # proc_macro crates must be compiled for the build architecture + if crateConfigs.${depPackageId}.procMacro or false + then self.build.crates.${depPackageId} + else self.crates.${depPackageId}; + dependencies = + (crateConfig.dependencies or [ ]) + ++ devDependencies; + }; + buildDependencies = + dependencyDerivations { + inherit features target; + buildByPackageId = depPackageId: + self.build.crates.${depPackageId}; + dependencies = crateConfig.buildDependencies or [ ]; + }; + filterEnabledDependenciesForThis = dependencies: filterEnabledDependencies { + inherit dependencies features target; + }; + dependenciesWithRenames = + lib.filter (d: d ? "rename") + ( + filterEnabledDependenciesForThis + ( + (crateConfig.buildDependencies or [ ]) + ++ (crateConfig.dependencies or [ ]) + ++ devDependencies + ) + ); + # Crate renames have the form: + # + # { + # crate_name = [ + # { version = "1.2.3"; rename = "crate_name01"; } + # ]; + # # ... + # } + crateRenames = + let + grouped = + lib.groupBy + (dependency: dependency.name) + dependenciesWithRenames; + versionAndRename = dep: + let + package = crateConfigs."${dep.packageId}"; + in + { inherit (dep) rename; version = package.version; }; + in + lib.mapAttrs (name: choices: builtins.map versionAndRename choices) grouped; + in + buildRustCrateForPkgsFunc pkgs + ( + crateConfig // { + src = crateConfig.src or ( + pkgs.fetchurl rec { + name = "${crateConfig.crateName}-${crateConfig.version}.tar.gz"; + # https://www.pietroalbini.org/blog/downloading-crates-io/ + # Not rate-limited, CDN URL. + url = "https://static.crates.io/crates/${crateConfig.crateName}/${crateConfig.crateName}-${crateConfig.version}.crate"; + sha256 = + assert (lib.assertMsg (crateConfig ? sha256) "Missing sha256 for ${name}"); + crateConfig.sha256; + } + ); + extraRustcOpts = lib.lists.optional (targetFeatures != [ ]) "-C target-feature=${lib.concatMapStringsSep "," (x: "+${x}") targetFeatures}"; + inherit features dependencies buildDependencies crateRenames release; + } + ); + in + builtByPackageIdByPkgs; + + /* Returns the actual derivations for the given dependencies. */ + dependencyDerivations = + { buildByPackageId + , features + , dependencies + , target + }: + assert (builtins.isList features); + assert (builtins.isList dependencies); + assert (builtins.isAttrs target); + let + enabledDependencies = filterEnabledDependencies { + inherit dependencies features target; + }; + depDerivation = dependency: buildByPackageId dependency.packageId; + in + map depDerivation enabledDependencies; + + /* Returns a sanitized version of val with all values substituted that cannot + be serialized as JSON. + */ + sanitizeForJson = val: + if builtins.isAttrs val + then lib.mapAttrs (n: v: sanitizeForJson v) val + else if builtins.isList val + then builtins.map sanitizeForJson val + else if builtins.isFunction val + then "function" + else val; + + /* Returns various tools to debug a crate. */ + debugCrate = { packageId, target ? defaultTarget }: + assert (builtins.isString packageId); + let + debug = rec { + # The built tree as passed to buildRustCrate. + buildTree = buildRustCrateWithFeatures { + buildRustCrateForPkgsFunc = _: lib.id; + inherit packageId; + }; + sanitizedBuildTree = sanitizeForJson buildTree; + dependencyTree = sanitizeForJson + ( + buildRustCrateWithFeatures { + buildRustCrateForPkgsFunc = _: crate: { + "01_crateName" = crate.crateName or false; + "02_features" = crate.features or [ ]; + "03_dependencies" = crate.dependencies or [ ]; + }; + inherit packageId; + } + ); + mergedPackageFeatures = mergePackageFeatures { + features = rootFeatures; + inherit packageId target; + }; + diffedDefaultPackageFeatures = diffDefaultPackageFeatures { + inherit packageId target; + }; + }; + in + { internal = debug; }; + + /* Returns differences between cargo default features and crate2nix default + features. + + This is useful for verifying the feature resolution in crate2nix. + */ + diffDefaultPackageFeatures = + { crateConfigs ? crates + , packageId + , target + }: + assert (builtins.isAttrs crateConfigs); + let + prefixValues = prefix: lib.mapAttrs (n: v: { "${prefix}" = v; }); + mergedFeatures = + prefixValues + "crate2nix" + (mergePackageFeatures { inherit crateConfigs packageId target; features = [ "default" ]; }); + configs = prefixValues "cargo" crateConfigs; + combined = lib.foldAttrs (a: b: a // b) { } [ mergedFeatures configs ]; + onlyInCargo = + builtins.attrNames + (lib.filterAttrs (n: v: !(v ? "crate2nix") && (v ? "cargo")) combined); + onlyInCrate2Nix = + builtins.attrNames + (lib.filterAttrs (n: v: (v ? "crate2nix") && !(v ? "cargo")) combined); + differentFeatures = lib.filterAttrs + ( + n: v: + (v ? "crate2nix") + && (v ? "cargo") + && (v.crate2nix.features or [ ]) != (v."cargo".resolved_default_features or [ ]) + ) + combined; + in + builtins.toJSON { + inherit onlyInCargo onlyInCrate2Nix differentFeatures; + }; + + /* Returns an attrset mapping packageId to the list of enabled features. + + If multiple paths to a dependency enable different features, the + corresponding feature sets are merged. Features in rust are additive. + */ + mergePackageFeatures = + { crateConfigs ? crates + , packageId + , rootPackageId ? packageId + , features ? rootFeatures + , dependencyPath ? [ crates.${packageId}.crateName ] + , featuresByPackageId ? { } + , target + # Adds devDependencies to the crate with rootPackageId. + , runTests ? false + , ... + } @ args: + assert (builtins.isAttrs crateConfigs); + assert (builtins.isString packageId); + assert (builtins.isString rootPackageId); + assert (builtins.isList features); + assert (builtins.isList dependencyPath); + assert (builtins.isAttrs featuresByPackageId); + assert (builtins.isAttrs target); + assert (builtins.isBool runTests); + let + crateConfig = crateConfigs."${packageId}" or (builtins.throw "Package not found: ${packageId}"); + expandedFeatures = expandFeatures (crateConfig.features or { }) features; + enabledFeatures = enableFeatures (crateConfig.dependencies or [ ]) expandedFeatures; + depWithResolvedFeatures = dependency: + let + packageId = dependency.packageId; + features = dependencyFeatures enabledFeatures dependency; + in + { inherit packageId features; }; + resolveDependencies = cache: path: dependencies: + assert (builtins.isAttrs cache); + assert (builtins.isList dependencies); + let + enabledDependencies = filterEnabledDependencies { + inherit dependencies target; + features = enabledFeatures; + }; + directDependencies = map depWithResolvedFeatures enabledDependencies; + foldOverCache = op: lib.foldl op cache directDependencies; + in + foldOverCache + ( + cache: { packageId, features }: + let + cacheFeatures = cache.${packageId} or [ ]; + combinedFeatures = sortedUnique (cacheFeatures ++ features); + in + if cache ? ${packageId} && cache.${packageId} == combinedFeatures + then cache + else + mergePackageFeatures { + features = combinedFeatures; + featuresByPackageId = cache; + inherit crateConfigs packageId target runTests rootPackageId; + } + ); + cacheWithSelf = + let + cacheFeatures = featuresByPackageId.${packageId} or [ ]; + combinedFeatures = sortedUnique (cacheFeatures ++ enabledFeatures); + in + featuresByPackageId // { + "${packageId}" = combinedFeatures; + }; + cacheWithDependencies = + resolveDependencies cacheWithSelf "dep" + ( + crateConfig.dependencies or [ ] + ++ lib.optionals + (runTests && packageId == rootPackageId) + (crateConfig.devDependencies or [ ]) + ); + cacheWithAll = + resolveDependencies + cacheWithDependencies "build" + (crateConfig.buildDependencies or [ ]); + in + cacheWithAll; + + /* Returns the enabled dependencies given the enabled features. */ + filterEnabledDependencies = { dependencies, features, target }: + assert (builtins.isList dependencies); + assert (builtins.isList features); + assert (builtins.isAttrs target); + + lib.filter + ( + dep: + let + targetFunc = dep.target or (features: true); + in + targetFunc { inherit features target; } + && ( + !(dep.optional or false) + || builtins.any (doesFeatureEnableDependency dep) features + ) + ) + dependencies; + + /* Returns whether the given feature should enable the given dependency. */ + doesFeatureEnableDependency = { name, rename ? null, ... }: feature: + let + prefix = "${name}/"; + len = builtins.stringLength prefix; + startsWithPrefix = builtins.substring 0 len feature == prefix; + in + (rename == null && feature == name) + || (rename != null && rename == feature) + || startsWithPrefix; + + /* Returns the expanded features for the given inputFeatures by applying the + rules in featureMap. + + featureMap is an attribute set which maps feature names to lists of further + feature names to enable in case this feature is selected. + */ + expandFeatures = featureMap: inputFeatures: + assert (builtins.isAttrs featureMap); + assert (builtins.isList inputFeatures); + let + expandFeature = feature: + assert (builtins.isString feature); + [ feature ] ++ (expandFeatures featureMap (featureMap."${feature}" or [ ])); + outFeatures = lib.concatMap expandFeature inputFeatures; + in + sortedUnique outFeatures; + + /* This function adds optional dependencies as features if they are enabled + indirectly by dependency features. This function mimics Cargo's behavior + described in a note at: + https://doc.rust-lang.org/nightly/cargo/reference/features.html#dependency-features + */ + enableFeatures = dependencies: features: + assert (builtins.isList features); + assert (builtins.isList dependencies); + let + additionalFeatures = lib.concatMap + ( + dependency: + assert (builtins.isAttrs dependency); + let + enabled = builtins.any (doesFeatureEnableDependency dependency) features; + in + if (dependency.optional or false) && enabled then [ dependency.name ] else [ ] + ) + dependencies; + in + sortedUnique (features ++ additionalFeatures); + + /* + Returns the actual features for the given dependency. + + features: The features of the crate that refers this dependency. + */ + dependencyFeatures = features: dependency: + assert (builtins.isList features); + assert (builtins.isAttrs dependency); + let + defaultOrNil = + if dependency.usesDefaultFeatures or true + then [ "default" ] + else [ ]; + explicitFeatures = dependency.features or [ ]; + additionalDependencyFeatures = + let + dependencyPrefix = (dependency.rename or dependency.name) + "/"; + dependencyFeatures = + builtins.filter (f: lib.hasPrefix dependencyPrefix f) features; + in + builtins.map (lib.removePrefix dependencyPrefix) dependencyFeatures; + in + defaultOrNil ++ explicitFeatures ++ additionalDependencyFeatures; + + /* Sorts and removes duplicates from a list of strings. */ + sortedUnique = features: + assert (builtins.isList features); + assert (builtins.all builtins.isString features); + let + outFeaturesSet = lib.foldl (set: feature: set // { "${feature}" = 1; }) { } features; + outFeaturesUnique = builtins.attrNames outFeaturesSet; + in + builtins.sort (a: b: a < b) outFeaturesUnique; + + deprecationWarning = message: value: + if strictDeprecation + then builtins.throw "strictDeprecation enabled, aborting: ${message}" + else builtins.trace message value; + + # + # crate2nix/default.nix (excerpt end) + # + }; +} + diff --git a/flake.nix b/flake.nix index 138422f..516888d 100644 --- a/flake.nix +++ b/flake.nix @@ -78,6 +78,11 @@ rootFeatures = [ "screenplay" ]; release = false; }).rootCrate.build; + cyberpunk-splash = (import ./cyberpunk-splash/Cargo.nix { + inherit pkgs; + buildRustCrateForPkgs = customBuildInfo; + release = true; + }).rootCrate.build; }; }; }