face-detector/flake.nix

{
  description = "A simple rust flake using rust-overlay and craneLib";

  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
    crane.url = "github:ipetkov/crane";
    nix-github-actions = {
      url = "github:nix-community/nix-github-actions";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    rust-overlay = {
      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    advisory-db = {
      url = "github:rustsec/advisory-db";
      flake = false;
    };
    mnn-overlay = {
      url = "github:uttarayan21/mnn-nix-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    mnn-src = {
      url = "github:alibaba/MNN/3.2.2";
      flake = false;
    };
  };

  outputs =
    {
      self,
      crane,
      flake-utils,
      nixpkgs,
      rust-overlay,
      advisory-db,
      nix-github-actions,
      mnn-overlay,
      mnn-src,
      ...
    }:
    flake-utils.lib.eachDefaultSystem (
      system:
      let
        pkgs = import nixpkgs {
          inherit system;
          overlays = [
            rust-overlay.overlays.default
            (final: prev: {
              mnn = mnn-overlay.packages.${system}.mnn.override {
                src = mnn-src;
                buildConverter = true;
                enableMetal = true;
                enableOpencl = true;
              };
            })
          ];
        };
        inherit (pkgs) lib;
        cargoToml = builtins.fromTOML (builtins.readFile ./Cargo.toml);
        name = cargoToml.package.name;

        stableToolchain = pkgs.rust-bin.stable.latest.default;
        stableToolchainWithLLvmTools = stableToolchain.override {
          extensions = [
            "rust-src"
            "llvm-tools"
          ];
        };
        stableToolchainWithRustAnalyzer = stableToolchain.override {
          extensions = [
            "rust-src"
            "rust-analyzer"
          ];
        };
        craneLib = (crane.mkLib pkgs).overrideToolchain stableToolchain;
        craneLibLLvmTools = (crane.mkLib pkgs).overrideToolchain stableToolchainWithLLvmTools;

        src =
          let
            filterBySuffix = path: exts: lib.any (ext: lib.hasSuffix ext path) exts;
            sourceFilters =
              path: type:
              (craneLib.filterCargoSources path type)
              || filterBySuffix path [
                ".c"
                ".h"
                ".hpp"
                ".cpp"
                ".cc"
              ];
          in
          lib.cleanSourceWith {
            filter = sourceFilters;
            src = ./.;
          };
        commonArgs = {
          inherit src;
          pname = name;
          stdenv = pkgs.clangStdenv;
          doCheck = false;
          LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
          # nativeBuildInputs = with pkgs; [
          #   cmake
          #   llvmPackages.libclang.lib
          # ];
          buildInputs =
            with pkgs;
            [ ]
            ++ (lib.optionals pkgs.stdenv.isDarwin [
              libiconv
              apple-sdk_13
            ]);
        }
        // (lib.optionalAttrs pkgs.stdenv.isLinux {
          # BINDGEN_EXTRA_CLANG_ARGS = "-I${pkgs.llvmPackages.libclang.lib}/lib/clang/18/include";
        });
        cargoArtifacts = craneLib.buildPackage commonArgs;
      in
      {
        checks = {
          "${name}-clippy" = craneLib.cargoClippy (
            commonArgs
            // {
              inherit cargoArtifacts;
              cargoClippyExtraArgs = "--all-targets -- --deny warnings";
            }
          );
          "${name}-docs" = craneLib.cargoDoc (commonArgs // { inherit cargoArtifacts; });
          "${name}-fmt" = craneLib.cargoFmt { inherit src; };
          "${name}-toml-fmt" = craneLib.taploFmt {
            src = pkgs.lib.sources.sourceFilesBySuffices src [ ".toml" ];
          };
          # Audit dependencies
          "${name}-audit" = craneLib.cargoAudit {
            inherit src advisory-db;
          };

          # Audit licenses
          "${name}-deny" = craneLib.cargoDeny {
            inherit src;
          };
          "${name}-nextest" = craneLib.cargoNextest (
            commonArgs
            // {
              inherit cargoArtifacts;
              partitions = 1;
              partitionType = "count";
            }
          );
        }
        // lib.optionalAttrs (!pkgs.stdenv.isDarwin) {
          "${name}-llvm-cov" = craneLibLLvmTools.cargoLlvmCov (commonArgs // { inherit cargoArtifacts; });
        };

        packages =
          let
            pkg = craneLib.buildPackage (
              commonArgs
              // {
                inherit cargoArtifacts;
              }
              // {
                nativeBuildInputs = with pkgs; [
                  installShellFiles
                ];
                postInstall = ''
                  installShellCompletion --cmd ${name} \
                    --bash <($out/bin/${name} completions bash) \
                    --fish <($out/bin/${name} completions fish) \
                    --zsh <($out/bin/${name} completions zsh)
                '';
              }
            );
          in
          {
            "${name}" = pkg;
            default = pkg;
          };

        devShells = {
          default = pkgs.mkShell.override { stdenv = pkgs.clangStdenv; } (
            commonArgs
            // {
              LLDB_DEBUGSERVER_PATH = "/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Versions/A/Resources/debugserver";
              packages =
                with pkgs;
                [
                  stableToolchainWithRustAnalyzer
                  cargo-nextest
                  cargo-deny
                  cmake
                  mnn
                  cargo-make
                ]
                ++ (lib.optionals pkgs.stdenv.isDarwin [
                  apple-sdk_13
                ]);
            }
          );
        };
      }
    )
    // {
      githubActions = nix-github-actions.lib.mkGithubMatrix {
        checks = nixpkgs.lib.getAttrs [ "x86_64-linux" ] self.checks;
      };
    };
}