riceware/flake.nix at main · triarius/riceware · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
{
  description = "Riceware, a passphrase generator in rust";

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

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

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

    flake-utils.url = "github:numtide/flake-utils";

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

  outputs = { self
  , nixpkgs
  , crane
  , fenix
  , flake-utils
  , advisory-db
  , ...
  }: flake-utils.lib.eachDefaultSystem (system:
    let
      pkgs = nixpkgs.legacyPackages.${system};

      inherit (pkgs) lib;

      craneLib = crane.mkLib pkgs;

      fixturesFilter = path: _type: builtins.match ".*/fixtures/.*" path != null;
      fixturesOrCargo = path: type: (fixturesFilter path type) || (craneLib.filterCargoSources path type);

      src = lib.cleanSourceWith { src = craneLib.path ./.; filter = fixturesOrCargo; };

      commonArgs = {
        inherit src;
        strictDeps = true;

        buildInputs = lib.optionals pkgs.stdenv.isDarwin [
          pkgs.libiconv
        ];
      };

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

      cargoArtifacts = craneLib.buildDepsOnly commonArgs;

      riceware = craneLib.buildPackage (commonArgs // {
        inherit cargoArtifacts;
        doCheck = false;
      });
    in {
      checks = {
        inherit riceware;

        riceware-clippy = craneLib.cargoClippy (commonArgs // {
          inherit cargoArtifacts;
          cargoClippyExtraArgs = "--all-targets -- --deny warnings --deny clippy::pedantic --deny clippy::all";
        });

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

        riceware-fmt = craneLib.cargoFmt {
          inherit src;
        };

        riceware-toml-fmt = craneLib.taploFmt {
          src = pkgs.lib.sources.sourceFilesBySuffices src [ ".toml" ];
        };

        riceware-audit = craneLib.cargoAudit {
          inherit src advisory-db;
        };

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

        riceware-nextest = craneLib.cargoNextest (commonArgs // {
          inherit cargoArtifacts;
          partitions = 1;
          partitionType = "count";
          cargoNextestPartitionsExtraArgs = "--no-tests=pass";
        });
      };

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

      apps.default = flake-utils.lib.mkApp {
        drv = riceware;
      };

      devShells.default = craneLib.devShell {
        checks = self.checks.${system};

        packages = [
          pkgs.taplo
        ];
      };
    }
  );
}