feat: add flake module for users

Author: Pacman99

flake.nix

@@ -62,6 +62,8 @@
       ./nix/perSystem-tools/flake-module.nix
       ./crate2nix/flake-module.nix
       ./docs/flake-module.nix
+      ./nix/public-flake-module.nix
+      ./nix/crate-overrides.nix
     ];
 
     flake = { lib, ... }: {

nix/public-flake-module.nix

@@ -0,0 +1,180 @@
+ourArgs:
+{
+  flake.flakeModule = 
+    {
+      lib,
+      flake-parts-lib,
+      inputs,
+      ...
+    }: let
+      inherit (flake-parts-lib) mkPerSystemOption;
+      inherit (lib) types;
+    in {
+      _file = ./public-flake-module.nix;
+
+      options.perSystem = mkPerSystemOption (
+        perSystem@{
+          config,
+          options,
+          pkgs,
+          system,
+          ...
+        }: let
+          cfg = config.crate2nix;
+
+          crate2nix = ourArgs.self.packages.${pkgs.system}.default;
+
+          importCargoNix =
+            {
+              pkgs ? perSystem.pkgs
+            , rust ? cfg.toolchain.rust
+            , cargo ? cfg.toolchain.cargo
+            , target ? null
+            , path
+            , ...
+            }:
+            import path {
+              pkgs =
+                if target == null then pkgs
+                else import pkgs.path {
+                  inherit (pkgs) system config overlays;
+                  crossSystem =
+                    if lib.isString target
+                    then { config = target; }
+                    else target;
+                };
+
+              buildRustCrateForPkgs = _: pkgs.buildRustCrate.override {
+                inherit cargo;
+                rustc = rust;
+              };
+              defaultCrateOverrides = pkgs.defaultCrateOverrides // cfg.crateOverrides;
+            };
+
+          # Handle possible cross compiling requests in crateOverrides
+          fixCrossMemberBuild = path: name: member:
+            let
+              crateOverrides =
+                if cfg.crateOverrides ? ${name}
+                then cfg.crateOverrides.${name} {}
+                else {};
+              importArgs = crateOverrides // {inherit path;};
+              overrideAttrNames = builtins.attrNames crateOverrides;
+              isInOverride = n: lib.elem n overrideAttrNames;
+              globalBuildAttrs = [ "pkgs" "rust" "cargo" "target" ];
+              build = (importCargoNix importArgs).workspaceMembers.${name}.build;
+            in
+            if lib.any isInOverride globalBuildAttrs
+            then member // { inherit build; }
+            else member;
+
+          mkCargoNix = path:
+            let
+              default = importCargoNix { inherit path; };
+              final = default // {
+                workspaceMembers =
+                  lib.mapAttrs
+                  (fixCrossMemberBuild path)
+                  default.workspaceMembers;
+                inherit path;
+              };
+            in final // {
+              # fix allWorkspaceMembers to use final workspaceMembers
+              allWorkspaceMembers = pkgs.symlinkJoin {
+                name = "all-workspace-members";
+                paths =
+                  let members = builtins.attrValues final.workspaceMembers;
+                  in builtins.map (m: m.build) members;
+              };
+            };
+              
+                  in {
+          options.crate2nix = {
+            cargoNix = lib.mkOption {
+              type = types.nullOr types.path;
+              apply = x: if x == null then {} else mkCargoNix x;
+              default = null;
+              description = ''
+                Path to Cargo.nix.
+              '';
+            };
+            toolchain = {
+              rust = lib.mkOption {
+                type = types.package;
+                default = pkgs.rustc;
+                description = ''
+                  Rust compiler to build with.
+                '';
+              };
+              cargo = lib.mkOption {
+                type = types.package;
+                default = pkgs.cargo;
+                description = ''
+                  Cargo command to make available to build processes.
+                '';
+              };
+            };
+            crateOverrides = lib.mkOption {
+              type = types.attrsOf (types.anything);
+              default = {};
+              description = ''
+                Crate overrides.
+              '';
+              example = ''
+                {
+                  openssl = attrs: {
+                    nativeBuildInputs = [ pkgs.openssl ];
+                  };
+                }
+              '';
+            };
+            devshell = lib.mkOption {
+              type = types.nullOr types.str;
+              default = null;
+              description = ''
+                Name of devshell to add update-cargo-nix command to.
+              '';
+            };
+            exportAll = lib.mkEnableOption ''
+              export all crate packages to packages output.
+            '';
+            packages = lib.mkOption {
+              type = types.attrsOf types.package;
+              readOnly = true;
+              description = ''
+                All crate packages in project.
+                Set `perSystem.packages = config.crate2nix.packages`
+                to export all packages.
+                Or use inherit to selectively export packages:
+                  `perSystem.packages = { inherit (config.crate2nix.packages) package; }`
+              '';
+            };
+          };
+          config = lib.mkMerge [
+            (lib.mkIf (options ? devshells && cfg.devshell != null) (
+              (lib.optionalAttrs (options ? devshells) {
+                devshells.${cfg.devshell} = {
+                  commands = [
+                    {
+                      category = "development";
+                      name = "update-cargo-nix";
+                      help = "Update Cargo.nix";
+                      command = "${lib.getExe crate2nix} generate";
+                    }
+                  ];
+                };
+              })
+            ))
+            {
+              crate2nix.packages =
+                lib.mapAttrs (_: lib.getAttr "build") cfg.cargoNix.workspaceMembers;
+              crate2nix.crateOverrides = ourArgs.self.tools.${pkgs.system}.crateOverrides;
+            }
+            (lib.mkIf cfg.exportAll {
+              inherit (cfg) packages;
+            })
+          ];
+        }
+      );
+    };
+}