cartographer/flake.nix

{
  description = "A TUI for the Canvas LMS";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";

    crane.url = "github:ipetkov/crane";

    fenix = {
      # url = "github:nix-community/fenix";
      url = "github:Defelo/fenix/staging";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.rust-analyzer-src.follows = "";
    };

    flake-parts.url = "github:hercules-ci/flake-parts";

    advisory-db = {
      url = "github:rustsec/advisory-db";
      flake = false;
    };

    devenv.url = "github:cachix/devenv";
  };

  outputs =
    inputs@{
      flake-parts,
      crane,
      fenix,
      advisory-db,
      ...
    }:
    flake-parts.lib.mkFlake { inherit inputs; } {
      imports = [
        inputs.devenv.flakeModule
      ];
      systems = [
        "x86_64-linux"
        "aarch64-linux"
        "x86_64-darwin"
        "aarch64-darwin"
      ];
      perSystem =
        {
          config,
          pkgs,
          system,
          ...
        }:
        let
          inherit (pkgs) lib;

          craneLib = crane.mkLib pkgs;
          src = craneLib.cleanCargoSource ./.;

          # Common arguments can be set here to avoid repeating them later
          commonArgs = {
            inherit src;
            strictDeps = true;

            nativeBuildInputs = with pkgs; [
              pkg-config
            ];

            buildInputs = with pkgs; [
              openssl
            ];

            # Additional environment variables can be set directly
            # MY_CUSTOM_VAR = "some value";
          };

          craneLibLLvmTools = craneLib.overrideToolchain (
            fenix.packages.${system}.complete.withComponents [
              "cargo"
              "llvm-tools"
              "rustc"
            ]
          );

          # Build *just* the cargo dependencies, so we can reuse
          # all of that work (e.g. via cachix) when running in CI
          cargoArtifacts = craneLib.buildDepsOnly commonArgs;

          # Build the actual crate itself, reusing the dependency
          # artifacts from above.
          cartographer = craneLib.buildPackage (
            commonArgs
            // {
              inherit cargoArtifacts;
            }
          );
        in
        {
          checks = {
            # Build the crate as part of `nix flake check` for convenience
            inherit cartographer;

            # Run clippy (and deny all warnings) on the crate source,
            # again, reusing the dependency artifacts from above.
            #
            # Note that this is done as a separate derivation so that
            # we can block the CI if there are issues here, but not
            # prevent downstream consumers from building our crate by itself.
            cartographer-clippy = craneLib.cargoClippy (
              commonArgs
              // {
                inherit cargoArtifacts;
                cargoClippyExtraArgs = "--all-targets -- --deny warnings";
              }
            );

            cartographer-doc = craneLib.cargoDoc (
              commonArgs
              // {
                inherit cargoArtifacts;
              }
            );

            # Check formatting
            cartographer-fmt = craneLib.cargoFmt {
              inherit src;
            };

            cartographer-toml-fmt = craneLib.taploFmt {
              src = pkgs.lib.sources.sourceFilesBySuffices src [ ".toml" ];
              # taplo arguments can be further customized below as needed
              # taploExtraArgs = "--config ./taplo.toml";
            };

            # Audit dependencies
            cartographer-audit = craneLib.cargoAudit {
              inherit src advisory-db;
            };

            # Audit licenses
            cartographer-deny = craneLib.cargoDeny {
              inherit src;
            };

            # Run tests with cargo-nextest
            # Consider setting `doCheck = false` on `cartographer` if you do not want
            # the tests to run twice
            cartographer-nextest = craneLib.cargoNextest (
              commonArgs
              // {
                inherit cargoArtifacts;
                partitions = 1;
                partitionType = "count";
              }
            );
          };

          packages =
            {
              default = cartographer;
            }
            // lib.optionalAttrs (!pkgs.stdenv.isDarwin) {
              cartographer-llvm-coverage = craneLibLLvmTools.cargoLlvmCov (
                commonArgs
                // {
                  inherit cargoArtifacts;
                }
              );
            };

          devenv.shells.default = {
            enterShell = ''
              export LD_LIBRARY_PATH=${pkgs.lib.makeLibraryPath [ pkgs.openssl ]}:$LD_LIBRARY_PATH
            '';
            packages = [
              (fenix.packages.${system}.complete.withComponents [
                "cargo"
                "llvm-tools"
                "rustc"
                "clippy"
                "rustfmt"
                "rust-analyzer"
              ])
            ] ++ config.packages.default.nativeBuildInputs ++ config.packages.default.buildInputs;
          };
        };
    };
}