├── .github
    ├── dependabot.yml
    └── workflows
    │   └── nix.yml
├── .gitignore
├── LICENSE
├── README.md
├── allSystems.nix
├── check-utils.nix
├── default.nix
├── examples
    ├── check-utils
    │   ├── flake.lock
    │   └── flake.nix
    ├── each-system
    │   └── flake.nix
    └── simple-flake
    │   ├── flake.nix
    │   ├── overlay.nix
    │   └── shell.nix
├── filterPackages.nix
├── flake-utils.svg
├── flake.lock
├── flake.nix
├── flattenTree.nix
├── lib.nix
└── simpleFlake.nix


/.github/dependabot.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 | updates:
3 |   - package-ecosystem: "github-actions"
4 |     directory: "/"
5 |     schedule:
6 |       interval: "weekly"
7 | 


--------------------------------------------------------------------------------
/.github/workflows/nix.yml:
--------------------------------------------------------------------------------
 1 | name: Nix
 2 | on: [ push ]
 3 | 
 4 | jobs:
 5 |   build:
 6 |     runs-on: ubuntu-latest
 7 |     steps:
 8 |       - uses: actions/checkout@v4
 9 |       - uses: cachix/install-nix-action@v26
10 |       - run: nix flake check
11 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Nix
2 | result
3 | result-*
4 | 
5 | # Don't keep the example lockfile around
6 | /example/flake.lock
7 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 zimbatm
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <div align="center">
  2 | 
  3 | # flake-utils
  4 | 
  5 | <img src="flake-utils.svg" height="150"/>
  6 | 
  7 | **Pure Nix flake utility functions.**
  8 | 
  9 | *A <a href="https://numtide.com/">numtide</a> project.*
 10 | 
 11 | <p>
 12 | <a href="https://github.com/numtide/flake-utils/actions/workflows/nix.yml"><img src="https://github.com/numtide/flake-utils/actions/workflows/nix.yml/badge.svg"/></a>
 13 | <a href="https://app.element.io/#/room/#home:numtide.com"><img src="https://img.shields.io/badge/Support-%23numtide-blue"/></a>
 14 | </p>
 15 | 
 16 | </div>
 17 | 
 18 | The goal of this project is to build a collection of pure Nix functions that don't
 19 | depend on nixpkgs, and that are useful in the context of writing other Nix
 20 | flakes.
 21 | 
 22 | ## Usage
 23 | 
 24 | ### `system :: { system = system, ... }`
 25 | 
 26 | A map from system to system built from `allSystems`:
 27 | ```nix
 28 | system = {
 29 |   x86_64-linux = "x86_64-linux";
 30 |   x86_64-darwin = "x86_64-darwin";
 31 |   ...
 32 | }
 33 | ```
 34 | It's mainly useful to
 35 | detect typos and auto-complete if you use [rnix-lsp](https://github.com/nix-community/rnix-lsp).
 36 | 
 37 | Eg: instead of typing `"x86_64-linux"`, use `system.x86_64-linux`.
 38 | 
 39 | 
 40 | ### `allSystems :: [<system>]`
 41 | 
 42 | A list of all systems defined in nixpkgs. For a smaller list see `defaultSystems`.
 43 | 
 44 | ### `defaultSystems :: [<system>]`
 45 | 
 46 | The list of systems to use in `eachDefaultSystem` and `simpleFlake`.
 47 | 
 48 | The default values are `["x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin"]`.
 49 | 
 50 | It's possible to override and control that list by changing the `systems` input of this flake.
 51 | 
 52 | Eg (in your `flake.nix`):
 53 | 
 54 | ```nix
 55 | {
 56 |   # 1. Defined a "systems" inputs that maps to only ["x86_64-linux"]
 57 |   inputs.systems.url = "github:nix-systems/x86_64-linux";
 58 | 
 59 |   inputs.flake-utils.url = "github:numtide/flake-utils";
 60 |   # 2. Override the flake-utils default to your version
 61 |   inputs.flake-utils.inputs.systems.follows = "systems";
 62 | 
 63 |   outputs = { self, flake-utils, ... }:
 64 |     # Now eachDefaultSystem is only using ["x86_64-linux"], but this list can also
 65 |     # further be changed by users of your flake.
 66 |     flake-utils.lib.eachDefaultSystem (system: {
 67 |       # ...
 68 |     });
 69 | }
 70 | ```
 71 | 
 72 | For more details in this pattern, see: <https://github.com/nix-systems/nix-systems>.
 73 | 
 74 | ### `eachSystem :: [<system>] -> (<system> -> attrs)`
 75 | 
 76 | A common case is to build the same structure for each system. Instead of
 77 | building the hierarchy manually or per prefix, iterate over each systems and
 78 | then re-build the hierarchy.
 79 | 
 80 | Eg:
 81 | 
 82 | ```nix
 83 | eachSystem [ system.x86_64-linux ] (system: { hello = 42; })
 84 | # => { hello = { x86_64-linux = 42; }; }
 85 | eachSystem allSystems (system: { hello = 42; })
 86 | # => {
 87 |    hello.aarch64-darwin = 42,
 88 |    hello.aarch64-genode = 42,
 89 |    hello.aarch64-linux = 42,
 90 |    ...
 91 |    hello.x86_64-redox = 42,
 92 |    hello.x86_64-solaris = 42,
 93 |    hello.x86_64-windows = 42
 94 | }
 95 | ```
 96 | 
 97 | ### `eachSystemPassThrough :: [<system>] -> (<system> -> attrs)`
 98 | 
 99 | Unlike `eachSystem`, this function does not inject the `${system}` key by merely
100 | providing the system argument to the function.
101 | 
102 | ### `eachDefaultSystem :: (<system> -> attrs)`
103 | 
104 | `eachSystem` pre-populated with `defaultSystems`.
105 | 
106 | #### Example
107 | 
108 | [$ examples/each-system/flake.nix](examples/each-system/flake.nix) as nix
109 | ```nix
110 | {
111 |   description = "Flake utils demo";
112 | 
113 |   inputs.flake-utils.url = "github:numtide/flake-utils";
114 | 
115 |   outputs = { self, nixpkgs, flake-utils }:
116 |     flake-utils.lib.eachDefaultSystem (system:
117 |       let pkgs = nixpkgs.legacyPackages.${system}; in
118 |       {
119 |         packages = rec {
120 |           hello = pkgs.hello;
121 |           default = hello;
122 |         };
123 |         apps = rec {
124 |           hello = flake-utils.lib.mkApp { drv = self.packages.${system}.hello; };
125 |           default = hello;
126 |         };
127 |       }
128 |     );
129 | }
130 | ```
131 | 
132 | ### `eachDefaultSystemPassThrough :: (<system> -> attrs)`
133 | 
134 | `eachSystemPassThrough` pre-populated with `defaultSystems`.
135 | 
136 | #### Example
137 | 
138 | ```nix
139 | inputs.flake-utils.lib.eachDefaultSystem (system: {
140 |   checks./*<SYSTEM>.*/"<CHECK>" = /* ... */;
141 |   devShells./*<SYSTEM>.*/"<DEV_SHELL>" = /* ... */;
142 |   packages./*<SYSTEM>.*/"<PACKAGE>" = /* ... */;
143 | })
144 | // inputs.flake-utils.lib.eachDefaultSystemPassThrough (system: {
145 |   homeConfigurations."<HOME_CONFIGURATION>" = /* ... */;
146 |   nixosConfigurations."<NIXOS_CONFIGURATION>" = /* ... */;
147 | })
148 | ```
149 | 
150 | ### `meld :: attrs -> [ path ] -> attrs`
151 | 
152 | Meld merges subflakes using common inputs.  Useful when you want to
153 | split up a large flake with many different components into more
154 | manageable parts.
155 | 
156 | ### `mkApp { drv, name ? drv.pname or drv.name, exePath ? drv.passthru.exePath or "/bin/${name}"`
157 | 
158 | A small utility that builds the structure expected by the special `apps` and `defaultApp` prefixes.
159 | 
160 | 
161 | ### `flattenTree :: attrs -> attrs`
162 | 
163 | Nix flakes insists on having a flat attribute set of derivations in
164 | various places like the `packages` and `checks` attributes.
165 | 
166 | This function traverses a tree of attributes (by respecting
167 | [recurseIntoAttrs](https://noogle.dev/f/lib/recurseIntoAttrs)) and only returns their derivations, with a flattened
168 | key-space.
169 | 
170 | Eg:
171 | ```nix
172 | flattenTree { hello = pkgs.hello; gitAndTools = pkgs.gitAndTools }
173 | ```
174 | Returns:
175 | 
176 | ```nix
177 | {
178 |   hello = «derivation»;
179 |   "gitAndTools/git" = «derivation»;
180 |   "gitAndTools/hub" = «derivation»;
181 |   # ...
182 | }
183 | ```
184 | 
185 | ### `simpleFlake :: attrs -> attrs`
186 | 
187 | This function should be useful for most common use-cases where you have a
188 | simple flake that builds a package. It takes nixpkgs and a bunch of other
189 | parameters and outputs a value that is compatible as a flake output.
190 | 
191 | Input:
192 | ```nix
193 | {
194 |   # pass an instance of self
195 |   self
196 | , # pass an instance of the nixpkgs flake
197 |   nixpkgs
198 | , # we assume that the name maps to the project name, and also that the
199 |   # overlay has an attribute with the `name` prefix that contains all of the
200 |   # project's packages.
201 |   name
202 | , # nixpkgs config
203 |   config ? { }
204 | , # pass either a function or a file
205 |   overlay ? null
206 | , # use this to load other flakes overlays to supplement nixpkgs
207 |   preOverlays ? [ ]
208 | , # maps to the devShell output. Pass in a shell.nix file or function.
209 |   shell ? null
210 | , # pass the list of supported systems
211 |   systems ? [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin" ]
212 | }: null
213 | ```
214 | 
215 | #### Example
216 | 
217 | Here is how it looks like in practice:
218 | 
219 | [$ examples/simple-flake/flake.nix](examples/simple-flake/flake.nix) as nix
220 | ```nix
221 | {
222 |   description = "Flake utils demo";
223 | 
224 |   inputs.flake-utils.url = "github:numtide/flake-utils";
225 | 
226 |   outputs = { self, nixpkgs, flake-utils }:
227 |     flake-utils.lib.simpleFlake {
228 |       inherit self nixpkgs;
229 |       name = "simple-flake";
230 |       overlay = ./overlay.nix;
231 |       shell = ./shell.nix;
232 |     };
233 | }
234 | ```
235 | 
236 | ## Commercial support
237 | 
238 | Looking for help or customization?
239 | 
240 | Get in touch with Numtide to get a quote. We make it easy for companies to
241 | work with Open Source projects: <https://numtide.com/contact>
242 | 


--------------------------------------------------------------------------------
/allSystems.nix:
--------------------------------------------------------------------------------
 1 | [
 2 |   "aarch64-darwin"
 3 |   "aarch64-genode"
 4 |   "aarch64-linux"
 5 |   "aarch64-netbsd"
 6 |   "aarch64-none"
 7 |   "aarch64_be-none"
 8 |   "arm-none"
 9 |   "armv5tel-linux"
10 |   "armv6l-linux"
11 |   "armv6l-netbsd"
12 |   "armv6l-none"
13 |   "armv7a-darwin"
14 |   "armv7a-linux"
15 |   "armv7a-netbsd"
16 |   "armv7l-linux"
17 |   "armv7l-netbsd"
18 |   "avr-none"
19 |   "i686-cygwin"
20 |   "i686-darwin"
21 |   "i686-freebsd13"
22 |   "i686-genode"
23 |   "i686-linux"
24 |   "i686-netbsd"
25 |   "i686-none"
26 |   "i686-openbsd"
27 |   "i686-windows"
28 |   "javascript-ghcjs"
29 |   "m68k-linux"
30 |   "m68k-netbsd"
31 |   "m68k-none"
32 |   "microblaze-linux"
33 |   "microblaze-none"
34 |   "microblazeel-linux"
35 |   "microblazeel-none"
36 |   "mips64el-linux"
37 |   "mipsel-linux"
38 |   "mipsel-netbsd"
39 |   "mmix-mmixware"
40 |   "msp430-none"
41 |   "or1k-none"
42 |   "powerpc-netbsd"
43 |   "powerpc-none"
44 |   "powerpc64-linux"
45 |   "powerpc64le-linux"
46 |   "powerpcle-none"
47 |   "riscv32-linux"
48 |   "riscv32-netbsd"
49 |   "riscv32-none"
50 |   "riscv64-linux"
51 |   "riscv64-netbsd"
52 |   "riscv64-none"
53 |   "rx-none"
54 |   "s390-linux"
55 |   "s390-none"
56 |   "s390x-linux"
57 |   "s390x-none"
58 |   "vc4-none"
59 |   "wasm32-wasi"
60 |   "wasm64-wasi"
61 |   "x86_64-cygwin"
62 |   "x86_64-darwin"
63 |   "x86_64-freebsd13"
64 |   "x86_64-genode"
65 |   "x86_64-linux"
66 |   "x86_64-netbsd"
67 |   "x86_64-none"
68 |   "x86_64-openbsd"
69 |   "x86_64-redox"
70 |   "x86_64-solaris"
71 |   "x86_64-windows"
72 | ]
73 | 


--------------------------------------------------------------------------------
/check-utils.nix:
--------------------------------------------------------------------------------
 1 | systemOrPkgs:
 2 | let
 3 |   inherit (builtins) foldl' unsafeDiscardStringContext elemAt match split concatStringsSep isList substring stringLength length attrNames;
 4 |   system = systemOrPkgs.system or systemOrPkgs;
 5 |   pipe = val: functions: foldl' (x: f: f x) val functions;
 6 |   max = x: y: if x > y then x else y;
 7 | 
 8 |   # Minimized copy-paste https://github.com/NixOS/nixpkgs/blob/master/lib/strings.nix#L746-L762
 9 |   sanitizeDerivationName = string: pipe (toString string) [
10 |     # Get rid of string context. This is safe under the assumption that the
11 |     # resulting string is only used as a derivation name
12 |     unsafeDiscardStringContext
13 |     # Strip all leading "."
14 |     (x: elemAt (match "\\.*(.*)" x) 0)
15 |     # Split out all invalid characters
16 |     # https://github.com/NixOS/nix/blob/2.3.2/src/libstore/store-api.cc#L85-L112
17 |     # https://github.com/NixOS/nix/blob/2242be83c61788b9c0736a92bb0b5c7bbfc40803/nix-rust/src/store/path.rs#L100-L125
18 |     (split "[^[:alnum:]+._?=-]+")
19 |     # Replace invalid character ranges with a "-"
20 |     (map (s: if isList s then "-" else s))
21 |     (concatStringsSep "")
22 |     # Limit to 211 characters (minus 4 chars for ".drv")
23 |     (x: substring (max (stringLength x - 207) 0) (-1) x)
24 |     # If the result is empty, replace it with "?EMPTY?"
25 |     (x: if stringLength x == 0 then "?EMPTY?" else x)
26 |   ];
27 | 
28 |   # Minimized version of 'sanitizeDerivationName' function
29 |   str = it: if it == null then "null" else (sanitizeDerivationName it);
30 | 
31 |   test = name: command: derivation {
32 |     inherit system;
33 |     name = str name;
34 |     builder = "/bin/sh";
35 |     args = [ "-c" command ];
36 |   };
37 | 
38 |   success = test "SUCCESS" "echo success > $out";
39 | in
40 | {
41 | 
42 |   isEqual = a: b:
43 |     if a == b
44 |     then success
45 |     else test "FAILURE__${str a}__NOT_EQUAL__${str b}" "exit 1";
46 | 
47 |   hasKey = attrset: key:
48 |     if attrset ? ${str key}
49 |     then success
50 |     else test "FAILURE__${str key}__DOES_NOT_EXISTS_IN_ATTRSET_SIZE_${str(length (attrNames attrset))}" "exit 1";
51 | }
52 | 


--------------------------------------------------------------------------------
/default.nix:
--------------------------------------------------------------------------------
1 | # Used for back-compat
2 | import ./lib.nix { }
3 | 


--------------------------------------------------------------------------------
/examples/check-utils/flake.lock:
--------------------------------------------------------------------------------
 1 | {
 2 |   "nodes": {
 3 |     "flake-utils": {
 4 |       "inputs": {
 5 |         "systems": "systems"
 6 |       },
 7 |       "locked": {
 8 |         "lastModified": 0,
 9 |         "narHash": "sha256-omjHh3LT883xERMxVEXH/oeAFI2pAAy30mhZb0eN5G4=",
10 |         "path": "../..",
11 |         "type": "path"
12 |       },
13 |       "original": {
14 |         "path": "../..",
15 |         "type": "path"
16 |       }
17 |     },
18 |     "nixpkgs": {
19 |       "locked": {
20 |         "lastModified": 1685498995,
21 |         "narHash": "sha256-rdyjnkq87tJp+T2Bm1OD/9NXKSsh/vLlPeqCc/mm7qs=",
22 |         "owner": "NixOS",
23 |         "repo": "nixpkgs",
24 |         "rev": "9cfaa8a1a00830d17487cb60a19bb86f96f09b27",
25 |         "type": "github"
26 |       },
27 |       "original": {
28 |         "id": "nixpkgs",
29 |         "type": "indirect"
30 |       }
31 |     },
32 |     "root": {
33 |       "inputs": {
34 |         "flake-utils": "flake-utils",
35 |         "nixpkgs": "nixpkgs"
36 |       }
37 |     },
38 |     "systems": {
39 |       "locked": {
40 |         "lastModified": 1681028828,
41 |         "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
42 |         "owner": "nix-systems",
43 |         "repo": "default",
44 |         "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
45 |         "type": "github"
46 |       },
47 |       "original": {
48 |         "owner": "nix-systems",
49 |         "repo": "default",
50 |         "type": "github"
51 |       }
52 |     }
53 |   },
54 |   "root": "root",
55 |   "version": 7
56 | }
57 | 


--------------------------------------------------------------------------------
/examples/check-utils/flake.nix:
--------------------------------------------------------------------------------
 1 | {
 2 |   description = "Flake utils demo";
 3 | 
 4 |   inputs.flake-utils.url = "path:../..";
 5 | 
 6 |   outputs = { self, nixpkgs, flake-utils }:
 7 |     flake-utils.lib.eachDefaultSystem (system:
 8 |       let
 9 |         inherit (flake-utils.lib.check-utils system) isEqual hasKey;
10 |         testDataset = { key1 = "value1"; key2 = 123; key3 = "some>value with^invalid&characters"; };
11 |         mkHydraJobs = system: {
12 |           toplevel = derivation { name = "toplevel"; builder = "mybuilder"; inherit system; };
13 |           nested = {
14 |             attribute = derivation { name = "nested-attribute"; builder = "mybuilder"; inherit system; };
15 |           };
16 |         };
17 |       in
18 |       rec {
19 |         hydraJobs = mkHydraJobs system;
20 |         checks = {
21 |           # Successful cases
22 |           success_isEqual = isEqual testDataset.key1 "value1";
23 |           success_hasKey = hasKey testDataset "key2";
24 |           # ensure no special handling of hydraJobs
25 |           success_hydraJobs = isEqual self.hydraJobs (flake-utils.lib.eachDefaultSystemMap mkHydraJobs);
26 | 
27 |           # Failing cases
28 |           failure_isEqual = isEqual testDataset.key1 "failing-data";
29 |           failure_hasKey = hasKey testDataset "failing-data";
30 | 
31 |           # Formatting
32 |           formatting_number = isEqual testDataset.key2 123;
33 |           formatting_null = isEqual null null;
34 |           formatting_invalid_chars = isEqual testDataset.key3 "some>value with^invalid&characters";
35 | 
36 |         };
37 |       }
38 |     );
39 | }
40 | 


--------------------------------------------------------------------------------
/examples/each-system/flake.nix:
--------------------------------------------------------------------------------
 1 | {
 2 |   description = "Flake utils demo";
 3 | 
 4 |   inputs.flake-utils.url = "github:numtide/flake-utils";
 5 | 
 6 |   outputs = { self, nixpkgs, flake-utils }:
 7 |     flake-utils.lib.eachDefaultSystem (system:
 8 |       let pkgs = nixpkgs.legacyPackages.${system}; in
 9 |       {
10 |         packages = rec {
11 |           hello = pkgs.hello;
12 |           default = hello;
13 |         };
14 |         apps = rec {
15 |           hello = flake-utils.lib.mkApp { drv = self.packages.${system}.hello; };
16 |           default = hello;
17 |         };
18 |       }
19 |     );
20 | }
21 | 


--------------------------------------------------------------------------------
/examples/simple-flake/flake.nix:
--------------------------------------------------------------------------------
 1 | {
 2 |   description = "Flake utils demo";
 3 | 
 4 |   inputs.flake-utils.url = "github:numtide/flake-utils";
 5 | 
 6 |   outputs = { self, nixpkgs, flake-utils }:
 7 |     flake-utils.lib.simpleFlake {
 8 |       inherit self nixpkgs;
 9 |       name = "simple-flake";
10 |       overlay = ./overlay.nix;
11 |       shell = ./shell.nix;
12 |     };
13 | }
14 | 


--------------------------------------------------------------------------------
/examples/simple-flake/overlay.nix:
--------------------------------------------------------------------------------
 1 | final: prev:
 2 | {
 3 |   # this key should be the same as the simpleFlake name attribute.
 4 |   simple-flake = {
 5 |     # assuming that hello is a project-specific package;
 6 |     hello = prev.hello;
 7 | 
 8 |     # demonstrating recursive packages
 9 |     terraform-providers = prev.terraform-providers;
10 |   };
11 | }
12 | 


--------------------------------------------------------------------------------
/examples/simple-flake/shell.nix:
--------------------------------------------------------------------------------
1 | { pkgs ? import <nixpkgs> }:
2 | pkgs.mkShell {
3 |   buildInputs = [ pkgs.jq ];
4 | }
5 | 


--------------------------------------------------------------------------------
/filterPackages.nix:
--------------------------------------------------------------------------------
 1 | { allSystems }:
 2 | system: packages:
 3 | let
 4 |   # Adopted from nixpkgs.lib
 5 |   inherit (builtins) listToAttrs concatMap attrNames;
 6 |   nameValuePair = name: value: { inherit name value; };
 7 |   filterAttrs = pred: set:
 8 |     listToAttrs (
 9 |       concatMap
10 |         (name:
11 |           let v = set.${name}; in
12 |           if pred name v then [ (nameValuePair name v) ] else [ ]
13 |         )
14 |         (attrNames set)
15 |     );
16 | 
17 |   # Everything that nix flake check requires for the packages output
18 |   sieve = n: v:
19 |     with v;
20 |     let
21 |       inherit (builtins) isAttrs;
22 |       isDerivation = x: isAttrs x && x ? type && x.type == "derivation";
23 |       isBroken = meta.broken or false;
24 |       platforms = meta.platforms or allSystems;
25 |       badPlatforms = meta.badPlatforms or [ ];
26 |     in
27 |     # check for isDerivation, so this is independently useful of
28 |       # flattenTree, which also does filter on derivations
29 |     isDerivation v && !isBroken && (builtins.elem system platforms) &&
30 |     !(builtins.elem system badPlatforms)
31 |   ;
32 | in
33 | filterAttrs sieve packages
34 | 


--------------------------------------------------------------------------------
/flake-utils.svg:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
  2 | <svg
  3 |    id="svg16"
  4 |    version="1.1"
  5 |    viewBox="0 0 12.7 12.7"
  6 |    height="48"
  7 |    width="48"
  8 |    xml:space="preserve"
  9 |    xmlns:xlink="http://www.w3.org/1999/xlink"
 10 |    xmlns="http://www.w3.org/2000/svg"
 11 |    xmlns:svg="http://www.w3.org/2000/svg"
 12 |    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 13 |    xmlns:cc="http://creativecommons.org/ns#"
 14 |    xmlns:dc="http://purl.org/dc/elements/1.1/"><defs
 15 |      id="defs10"><linearGradient
 16 |        id="linearGradient5562"><stop
 17 |          style="stop-color:#699ad7;stop-opacity:1"
 18 |          offset="0"
 19 |          id="stop5564" /><stop
 20 |          id="stop5566"
 21 |          offset="0.24345198"
 22 |          style="stop-color:#7eb1dd;stop-opacity:1" /><stop
 23 |          style="stop-color:#7ebae4;stop-opacity:1"
 24 |          offset="1"
 25 |          id="stop5568" /></linearGradient><linearGradient
 26 |        id="linearGradient5053"><stop
 27 |          style="stop-color:#415e9a;stop-opacity:1"
 28 |          offset="0"
 29 |          id="stop5055" /><stop
 30 |          id="stop5057"
 31 |          offset="0.23168644"
 32 |          style="stop-color:#4a6baf;stop-opacity:1" /><stop
 33 |          style="stop-color:#5277c3;stop-opacity:1"
 34 |          offset="1"
 35 |          id="stop5059" /></linearGradient><linearGradient
 36 |        id="linearGradient5960"><stop
 37 |          id="stop5962"
 38 |          offset="0"
 39 |          style="stop-color:#637ddf;stop-opacity:1" /><stop
 40 |          style="stop-color:#649afa;stop-opacity:1"
 41 |          offset="0.23168644"
 42 |          id="stop5964" /><stop
 43 |          id="stop5966"
 44 |          offset="1"
 45 |          style="stop-color:#719efa;stop-opacity:1" /></linearGradient><linearGradient
 46 |        id="linearGradient5867"><stop
 47 |          style="stop-color:#7363df;stop-opacity:1"
 48 |          offset="0"
 49 |          id="stop5869" /><stop
 50 |          id="stop5871"
 51 |          offset="0.23168644"
 52 |          style="stop-color:#6478fa;stop-opacity:1" /><stop
 53 |          style="stop-color:#719efa;stop-opacity:1"
 54 |          offset="1"
 55 |          id="stop5873" /></linearGradient><linearGradient
 56 |        y2="515.97058"
 57 |        x2="282.26105"
 58 |        y1="338.62445"
 59 |        x1="213.95642"
 60 |        gradientTransform="translate(-197.75174,-337.1451)"
 61 |        gradientUnits="userSpaceOnUse"
 62 |        id="linearGradient5855-8"
 63 |        xlink:href="#linearGradient5867" /><linearGradient
 64 |        y2="247.58188"
 65 |        x2="-702.75317"
 66 |        y1="102.74675"
 67 |        x1="-775.20807"
 68 |        gradientTransform="translate(983.36076,601.38885)"
 69 |        gradientUnits="userSpaceOnUse"
 70 |        id="linearGradient4544"
 71 |        xlink:href="#linearGradient5960" /><clipPath
 72 |        id="clipPath4501"
 73 |        clipPathUnits="userSpaceOnUse"><circle
 74 |          r="241.06563"
 75 |          cy="686.09473"
 76 |          cx="335.13995"
 77 |          id="circle4503"
 78 |          style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#adadad;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:3;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" /></clipPath><clipPath
 79 |        id="clipPath5410"
 80 |        clipPathUnits="userSpaceOnUse"><circle
 81 |          r="241.13741"
 82 |          cy="340.98975"
 83 |          cx="335.98114"
 84 |          id="circle5412"
 85 |          style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:3;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" /></clipPath><linearGradient
 86 |        xlink:href="#linearGradient5053"
 87 |        id="linearGradient5137"
 88 |        gradientUnits="userSpaceOnUse"
 89 |        gradientTransform="translate(864.55062,-2197.497)"
 90 |        x1="-584.19934"
 91 |        y1="782.33563"
 92 |        x2="-496.29703"
 93 |        y2="937.71399" /><linearGradient
 94 |        xlink:href="#linearGradient5562"
 95 |        id="linearGradient5162"
 96 |        gradientUnits="userSpaceOnUse"
 97 |        gradientTransform="translate(70.505061,-1761.3076)"
 98 |        x1="200.59668"
 99 |        y1="351.41116"
100 |        x2="290.08701"
101 |        y2="506.18814" /></defs><metadata
102 |      id="metadata13"><rdf:RDF><cc:Work
103 |          rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
104 |            rdf:resource="http://purl.org/dc/dcmitype/StillImage" /></cc:Work></rdf:RDF></metadata><g
105 |      id="g14"
106 |      transform="matrix(0.20110848,0,0,0.20110848,19.474332,-5.3665187)"><g
107 |        id="g8"
108 |        style="display:inline;opacity:1;stroke:#ffffff"
109 |        transform="translate(3.0583597,-20.952346)"><rect
110 |          style="opacity:1;fill:#929497;stroke:#ffffff;stroke-width:0.59981;stroke-linecap:round;stroke-linejoin:round;paint-order:fill markers stroke"
111 |          id="rect2"
112 |          width="26.205942"
113 |          height="8.7236834"
114 |          x="-112.36734"
115 |          y="63.469101" /><rect
116 |          style="opacity:1;fill:#929497;stroke:#ffffff;stroke-width:0.59981;stroke-linecap:round;stroke-linejoin:round;paint-order:fill markers stroke"
117 |          id="rect4"
118 |          width="25.476097"
119 |          height="14.747858"
120 |          x="-86.1614"
121 |          y="60.457012" /><rect
122 |          style="opacity:1;fill:#929497;stroke:#ffffff;stroke-width:0.59981;stroke-linecap:round;stroke-linejoin:round;paint-order:fill markers stroke"
123 |          id="rect5"
124 |          width="12.302079"
125 |          height="9.5148468"
126 |          x="-60.889412"
127 |          y="63.169197" /><rect
128 |          style="opacity:1;fill:#929497;stroke:#ffffff;stroke-width:0.59981;stroke-linecap:round;stroke-linejoin:round;paint-order:fill markers stroke"
129 |          id="rect6"
130 |          width="5.1707268"
131 |          height="3.072418"
132 |          x="-74.118935"
133 |          y="55.223225" /><rect
134 |          style="opacity:1;fill:#727acf;fill-opacity:1;stroke:#ffffff;stroke-width:0.589394;stroke-linecap:round;stroke-linejoin:round;paint-order:fill markers stroke"
135 |          id="rect7"
136 |          width="18.982008"
137 |          height="8.7340975"
138 |          x="-83.12635"
139 |          y="63.463894" /><path
140 |          style="opacity:1;fill:#5d5e64;fill-opacity:1;stroke:#ffffff;stroke-width:0.59981;stroke-linecap:round;stroke-linejoin:round;paint-order:fill markers stroke"
141 |          d="m -60.693749,58.71795 v 45.50651 l -5.273818,-3.04484 -5.258715,-22.395937 V 60.457012 h 6.423993 l 0.03208,-4.635163 z"
142 |          id="path7" /><path
143 |          style="opacity:1;fill:#5d5e64;fill-opacity:1;stroke:#ffffff;stroke-width:0.59981;stroke-linecap:round;stroke-linejoin:round;paint-order:fill markers stroke"
144 |          d="m -49.088182,58.229269 v 45.674511 l 4.880753,-2.87679 5.520504,-22.659924 V 60.616729 h -6.021422 v -5.2256 z"
145 |          id="path8" /><rect
146 |          style="opacity:1;fill:#000000;fill-opacity:1;stroke:#ffffff;stroke-width:0.59981;stroke-linecap:round;stroke-linejoin:round;paint-order:fill markers stroke"
147 |          id="rect14"
148 |          width="1.4872955"
149 |          height="1.8125205"
150 |          x="-72.323875"
151 |          y="58.33213" /></g><g
152 |        id="g2"
153 |        clip-path="none"
154 |        transform="matrix(0.3683143,0.3683143,-0.3683143,0.3683143,-79.169319,73.168432)"
155 |        style="display:inline;opacity:1"><g
156 |          id="g3"
157 |          style="display:none"
158 |          transform="matrix(2.9292921,0,0,2.9292921,-9.4710101,-9.9495361)"><rect
159 |            style="display:inline;fill:#d0041c;fill-opacity:1;stroke:none;stroke-width:0.121952;stroke-linejoin:round;stroke-dasharray:none;stroke-dashoffset:0;paint-order:fill markers stroke"
160 |            id="rect1"
161 |            width="0.93638152"
162 |            height="0.93638122"
163 |            x="0.45286971"
164 |            y="-0.23547961"
165 |            clip-path="none" /><rect
166 |            style="fill:#ee7f01;fill-opacity:1;stroke:none;stroke-width:0.121952;stroke-linejoin:round;stroke-dasharray:none;stroke-dashoffset:0;paint-order:fill markers stroke"
167 |            id="rect1-6"
168 |            width="0.93638152"
169 |            height="0.93638122"
170 |            x="1.7822026"
171 |            y="-0.23547961" /><rect
172 |            style="fill:#f7ad20;fill-opacity:1;stroke:none;stroke-width:0.121952;stroke-linejoin:round;stroke-dasharray:none;stroke-dashoffset:0;paint-order:fill markers stroke"
173 |            id="rect1-5"
174 |            width="0.93638152"
175 |            height="0.93638122"
176 |            x="3.1115355"
177 |            y="-0.23547961" /><rect
178 |            style="fill:#5d5e64;fill-opacity:1;stroke:none;stroke-width:0.121952;stroke-linejoin:round;stroke-dasharray:none;stroke-dashoffset:0;paint-order:fill markers stroke"
179 |            id="rect1-6-6"
180 |            width="0.93638152"
181 |            height="0.93638122"
182 |            x="4.4408684"
183 |            y="-0.23547961" /><rect
184 |            style="fill:#929497;fill-opacity:1;stroke:none;stroke-width:0.121952;stroke-linejoin:round;stroke-dasharray:none;stroke-dashoffset:0;paint-order:fill markers stroke"
185 |            id="rect1-9"
186 |            width="0.93638152"
187 |            height="0.93638122"
188 |            x="5.7702017"
189 |            y="-0.23547961" /><rect
190 |            style="fill:#16d24d;fill-opacity:1;stroke:none;stroke-width:0.121952;stroke-linejoin:round;stroke-dasharray:none;stroke-dashoffset:0;paint-order:fill markers stroke"
191 |            id="rect1-6-1"
192 |            width="0.93638152"
193 |            height="0.93638122"
194 |            x="7.099535"
195 |            y="-0.23547961" /><rect
196 |            style="fill:#727acf;fill-opacity:1;stroke:none;stroke-width:0.121952;stroke-linejoin:round;stroke-dasharray:none;stroke-dashoffset:0;paint-order:fill markers stroke"
197 |            id="rect1-6-1-7"
198 |            width="0.93638152"
199 |            height="0.93638122"
200 |            x="8.4288683"
201 |            y="-0.23547961" /></g><g
202 |          id="g11"
203 |          transform="matrix(4.6184515,-2.5635348,2.5618766,4.5973244,-16.022286,-59.492566)"
204 |          style="display:inline;opacity:1;fill:#ffffff;stroke:#ffffff;stroke-width:0.13172;stroke-dasharray:none;stroke-dashoffset:0"><path
205 |            style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#f7ad20;fill-opacity:1;fill-rule:evenodd;stroke:#ffffff;stroke-width:7.32898;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
206 |            d="m 309.40365,-710.2521 122.19683,211.6751 -56.15706,0.5268 -32.6236,-56.8692 -32.85645,56.5653 -27.90237,-0.011 -14.29086,-24.6896 46.81047,-80.4902 -33.22946,-57.8256 z"
207 |            id="path4861"
208 |            transform="matrix(0.01739755,0.00450968,-0.00450968,0.01739755,-4.2498833,16.66452)" /><path
209 |            style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#d0041c;fill-opacity:1;fill-rule:evenodd;stroke:#ffffff;stroke-width:7.32898;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
210 |            d="m 362.88537,-628.243 244.41439,0.012 -27.62229,48.8968 -65.56199,-0.1817 32.55876,56.7371 -13.96098,24.1585 -28.52722,0.032 -46.3013,-80.7841 -66.69317,-0.1353 z"
211 |            id="use4865"
212 |            transform="matrix(0.01739755,0.00450968,-0.00450968,0.01739755,-4.2498833,16.66452)" /><path
213 |            id="use3449-5"
214 |            d="M 348.94973,212.06577 226.7529,0.39065 l 56.15706,-0.5268 32.6236,56.8692 32.85645,-56.5653 27.90237,0.011 14.29086,24.6896 -46.81047,80.4901 33.22946,57.8257 z"
215 |            style="display:inline;fill:#d0041c;fill-opacity:1;fill-rule:evenodd;stroke:#ffffff;stroke-width:7.32898;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
216 |            transform="matrix(0.01739755,0.00450968,-0.00450968,0.01739755,2.6784178,1.1343292)" /><path
217 |            style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#f7ad20;fill-opacity:1;fill-rule:evenodd;stroke:#ffffff;stroke-width:7.32898;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
218 |            d="m 294.9633,129.57046 -244.41444,-0.012 27.62231,-48.89684 65.56197,0.18174 -32.55876,-56.73718 13.96071,-24.15866 28.52725,-0.0314 46.30123,80.7841 66.69317,0.13525 z"
219 |            id="use4354-5"
220 |            transform="matrix(0.01739755,0.00450968,-0.00450968,0.01739755,2.6784178,1.1343292)" /><path
221 |            style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#f7ad20;fill-opacity:1;fill-rule:evenodd;stroke:#ffffff;stroke-width:7.32898;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
222 |            d="m 304.56645,299.22444 122.21762,-211.66312 28.53475,48.37004 -32.93837,56.68746 65.41521,0.17187 13.94166,24.16966 -14.23639,24.72105 -93.11171,-0.294 -33.46371,57.69035 z"
223 |            id="use4362-2"
224 |            transform="matrix(0.01739755,0.00450968,-0.00450968,0.01739755,2.6784178,1.1343292)" /><path
225 |            id="use3439-6"
226 |            d="M 197.31588,135.61103 75.09826,347.27415 46.56351,298.90411 79.50188,242.21664 14.08667,242.04477 0.14501,217.87511 14.3814,193.15406 l 93.11171,0.29401 33.4638,-57.69041 z"
227 |            style="display:inline;fill:#d0041c;fill-opacity:1;fill-rule:evenodd;stroke:#ffffff;stroke-width:7.32898;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
228 |            transform="matrix(0.01739755,0.00450968,-0.00450968,0.01739755,2.6784178,1.1343292)" /></g></g></g></svg>
229 | 


--------------------------------------------------------------------------------
/flake.lock:
--------------------------------------------------------------------------------
 1 | {
 2 |   "nodes": {
 3 |     "root": {
 4 |       "inputs": {
 5 |         "systems": "systems"
 6 |       }
 7 |     },
 8 |     "systems": {
 9 |       "locked": {
10 |         "lastModified": 1681028828,
11 |         "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
12 |         "owner": "nix-systems",
13 |         "repo": "default",
14 |         "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
15 |         "type": "github"
16 |       },
17 |       "original": {
18 |         "owner": "nix-systems",
19 |         "repo": "default",
20 |         "type": "github"
21 |       }
22 |     }
23 |   },
24 |   "root": "root",
25 |   "version": 7
26 | }
27 | 


--------------------------------------------------------------------------------
/flake.nix:
--------------------------------------------------------------------------------
 1 | {
 2 |   description = "Pure Nix flake utility functions";
 3 | 
 4 |   # Externally extensible flake systems. See <https://github.com/nix-systems/nix-systems>.
 5 |   inputs.systems.url = "github:nix-systems/default";
 6 | 
 7 |   outputs = { self, systems }: {
 8 |     lib = import ./lib.nix {
 9 |       defaultSystems = import systems;
10 |     };
11 |     templates = {
12 |       default = self.templates.each-system;
13 |       simple-flake = {
14 |         path = ./examples/simple-flake;
15 |         description = "A flake using flake-utils.lib.simpleFlake";
16 |       };
17 |       each-system = {
18 |         path = ./examples/each-system;
19 |         description = "A flake using flake-utils.lib.eachDefaultSystem";
20 |       };
21 |       check-utils = {
22 |         path = ./examples/check-utils;
23 |         description = "A flake with tests";
24 |       };
25 |     };
26 |   };
27 | }
28 | 


--------------------------------------------------------------------------------
/flattenTree.nix:
--------------------------------------------------------------------------------
 1 | tree:
 2 | let
 3 |   op = sum: path: val:
 4 |     let
 5 |       pathStr = builtins.concatStringsSep "/" path;
 6 |     in
 7 |     if (builtins.typeOf val) != "set" then
 8 |     # ignore that value
 9 |     # builtins.trace "${pathStr} is not of type set"
10 |       sum
11 |     else if val ? type && val.type == "derivation" then
12 |     # builtins.trace "${pathStr} is a derivation"
13 |     # we used to use the derivation outPath as the key, but that crashes Nix
14 |     # so fallback on constructing a static key
15 |       (sum // {
16 |         "${pathStr}" = val;
17 |       })
18 |     else if val ? recurseForDerivations && val.recurseForDerivations == true then
19 |     # builtins.trace "${pathStr} is a recursive"
20 |     # recurse into that attribute set
21 |       (recurse sum path val)
22 |     else
23 |     # ignore that value
24 |     # builtins.trace "${pathStr} is something else"
25 |       sum
26 |   ;
27 | 
28 |   recurse = sum: path: val:
29 |     builtins.foldl'
30 |       (sum: key: op sum (path ++ [ key ]) val.${key})
31 |       sum
32 |       (builtins.attrNames val)
33 |   ;
34 | in
35 | recurse { } [ ] tree
36 | 


--------------------------------------------------------------------------------
/lib.nix:
--------------------------------------------------------------------------------
  1 | {
  2 |   # The list of systems supported by nixpkgs and hydra
  3 |   defaultSystems ? [
  4 |     "aarch64-linux"
  5 |     "aarch64-darwin"
  6 |     "x86_64-darwin"
  7 |     "x86_64-linux"
  8 |   ]
  9 | }:
 10 | let
 11 |   inherit defaultSystems;
 12 | 
 13 |   # List of all systems defined in nixpkgs
 14 |   # Keep in sync with nixpkgs wit the following command:
 15 |   # $ nix-instantiate --json --eval --expr "with import <nixpkgs> {}; lib.platforms.all" | jq 'sort' | sed 's!,!!' > allSystems.nix
 16 |   allSystems = import ./allSystems.nix;
 17 | 
 18 |   # A map from system to system. It's useful to detect typos.
 19 |   #
 20 |   # Instead of typing `"x86_64-linux"`, type `flake-utils.lib.system.x86_64-linux`
 21 |   # and get an error back if you used a dash instead of an underscore.
 22 |   system =
 23 |     builtins.listToAttrs
 24 |       (map (system: { name = system; value = system; }) allSystems);
 25 | 
 26 |   # eachSystem using defaultSystems
 27 |   eachDefaultSystem = eachSystem defaultSystems;
 28 | 
 29 |   # eachSystemPassThrough using defaultSystems
 30 |   eachDefaultSystemPassThrough = eachSystemPassThrough defaultSystems;
 31 | 
 32 |   # Builds a map from <attr>=value to <attr>.<system>=value for each system.
 33 |   eachSystem = eachSystemOp (
 34 |     # Merge outputs for each system.
 35 |     f: attrs: system:
 36 |     let
 37 |       ret = f system;
 38 |     in
 39 |     builtins.foldl' (
 40 |       attrs: key:
 41 |       attrs
 42 |       // {
 43 |         ${key} = (attrs.${key} or { }) // {
 44 |           ${system} = ret.${key};
 45 |         };
 46 |       }
 47 |     ) attrs (builtins.attrNames ret)
 48 |   );
 49 | 
 50 |   # Applies a merge operation accross systems.
 51 |   eachSystemOp =
 52 |     op: systems: f:
 53 |     builtins.foldl' (op f) { } (
 54 |       if
 55 |         !builtins ? currentSystem || builtins.elem builtins.currentSystem systems
 56 |       then
 57 |         systems
 58 |       else
 59 |         # Add the current system if the --impure flag is used.
 60 |         systems ++ [ builtins.currentSystem ]
 61 |     );
 62 | 
 63 |   # Merely provides the system argument to the function.
 64 |   #
 65 |   # Unlike eachSystem, this function does not inject the `${system}` key.
 66 |   eachSystemPassThrough = eachSystemOp (
 67 |     f: attrs: system:
 68 |     attrs // (f system)
 69 |   );
 70 | 
 71 |   # eachSystemMap using defaultSystems
 72 |   eachDefaultSystemMap = eachSystemMap defaultSystems;
 73 | 
 74 |   # Builds a map from <attr>=value to <system>.<attr> = value.
 75 |   eachSystemMap = systems: f: builtins.listToAttrs (builtins.map (system: { name = system; value = f system; }) systems);
 76 | 
 77 |   # Nix flakes insists on having a flat attribute set of derivations in
 78 |   # various places like the `packages` and `checks` attributes.
 79 |   #
 80 |   # This function traverses a tree of attributes (by respecting
 81 |   # recurseIntoAttrs) and only returns their derivations, with a flattened
 82 |   # key-space.
 83 |   #
 84 |   # Eg:
 85 |   #
 86 |   #   flattenTree { hello = pkgs.hello; gitAndTools = pkgs.gitAndTools };
 87 |   #
 88 |   # Returns:
 89 |   #
 90 |   #   {
 91 |   #      hello = «derivation»;
 92 |   #      "gitAndTools/git" = «derivation»;
 93 |   #      "gitAndTools/hub" = «derivation»;
 94 |   #      # ...
 95 |   #   }
 96 |   flattenTree = tree: import ./flattenTree.nix tree;
 97 | 
 98 |   # Nix check functionality validates packages for various conditions, like if
 99 |   # they build for any given platform or if they are marked broken.
100 |   #
101 |   # This function filters a flattend package set for conditinos that
102 |   # would *trivially* break `nix flake check`. It does not flatten a tree and it
103 |   # does not implement advanced package validation checks.
104 |   #
105 |   # Eg:
106 |   #
107 |   #   filterPackages "x86_64-linux" {
108 |   #     hello = pkgs.hello;
109 |   #     "gitAndTools/git" = pkgs.gitAndTools // {meta.broken = true;};
110 |   #    };
111 |   #
112 |   # Returns:
113 |   #
114 |   #   {
115 |   #      hello = «derivation»;
116 |   #   }
117 |   filterPackages = import ./filterPackages.nix { inherit allSystems; };
118 | 
119 |   # Meld merges subflakes using common inputs.  Useful when you want
120 |   # to split up a large flake with many different components into more
121 |   # manageable parts.
122 |   #
123 |   # For example:
124 |   #
125 |   #   {
126 |   #     inputs = {
127 |   #       flutils.url = "github:numtide/flake-utils";
128 |   #       nixpkgs.url = "github:nixos/nixpkgs";
129 |   #     };
130 |   #     outputs = inputs@{ flutils, ... }: flutils.lib.meld inputs [
131 |   #       ./nix/packages
132 |   #       ./nix/hardware
133 |   #       ./nix/overlays
134 |   #       # ...
135 |   #     ];
136 |   #   }
137 |   #
138 |   # Where ./nix/packages/default.nix looks like just the output
139 |   # portion of a flake.
140 |   #
141 |   #   { flutils, nixpkgs, ... }: flutils.lib.eachDefaultSystem (system:
142 |   #     let pkgs = import nixpkgs { inherit system; }; in
143 |   #     {
144 |   #       packages = {
145 |   #         foo = ...;
146 |   #         bar = ...;
147 |   #         # ...
148 |   #       };
149 |   #     }
150 |   #   )
151 |   #
152 |   # You can also use meld within the subflakes to further subdivide
153 |   # your flake into a tree like structure.  For example,
154 |   # ./nix/hardware/default.nix might look like:
155 |   #
156 |   #  inputs@{ flutils, ... }: flutils.lib.meld inputs [
157 |   #    ./foobox.nix
158 |   #    ./barbox.nix
159 |   #  ]
160 |   meld = let
161 |     # Pulled from nixpkgs.lib
162 |     recursiveUpdateUntil =
163 |       # Predicate, taking the path to the current attribute as a list of strings for attribute names, and the two values at that path from the original arguments.
164 |       pred:
165 |       # Left attribute set of the merge.
166 |       lhs:
167 |       # Right attribute set of the merge.
168 |       rhs:
169 |       let
170 |         f = attrPath:
171 |           builtins.zipAttrsWith (n: values:
172 |             let here = attrPath ++ [ n ];
173 |             in if builtins.length values == 1
174 |             || pred here (builtins.elemAt values 1) (builtins.head values) then
175 |               builtins.head values
176 |             else
177 |               f here values);
178 |       in f [ ] [ rhs lhs ];
179 | 
180 |     # Pulled from nixpkgs.lib
181 |     recursiveUpdate =
182 |       # Left attribute set of the merge.
183 |       lhs:
184 |       # Right attribute set of the merge.
185 |       rhs:
186 |       recursiveUpdateUntil (path: lhs: rhs: !(builtins.isAttrs lhs && builtins.isAttrs rhs)) lhs
187 |       rhs;
188 |   in inputs:
189 |   builtins.foldl' (output: subflake:
190 |     recursiveUpdate output (import subflake inputs)) { };
191 | 
192 |   # Returns the structure used by `nix app`
193 |   mkApp =
194 |     { drv
195 |     , name ? drv.pname or drv.name
196 |     , exePath ? drv.passthru.exePath or "/bin/${name}"
197 |     }:
198 |     {
199 |       type = "app";
200 |       program = "${drv}${exePath}";
201 |     };
202 | 
203 |   # This function tries to capture a common flake pattern.
204 |   simpleFlake = import ./simpleFlake.nix { inherit lib defaultSystems; };
205 | 
206 |   # Helper functions for Nix evaluation
207 |   check-utils = import ./check-utils.nix;
208 | 
209 |   lib = {
210 |     inherit
211 |       allSystems
212 |       check-utils
213 |       defaultSystems
214 |       eachDefaultSystem
215 |       eachDefaultSystemMap
216 |       eachDefaultSystemPassThrough
217 |       eachSystem
218 |       eachSystemMap
219 |       eachSystemPassThrough
220 |       filterPackages
221 |       flattenTree
222 |       meld
223 |       mkApp
224 |       simpleFlake
225 |       system
226 |       ;
227 |   };
228 | in
229 | lib
230 | 


--------------------------------------------------------------------------------
/simpleFlake.nix:
--------------------------------------------------------------------------------
 1 | { lib
 2 | , defaultSystems ? [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin" ]
 3 | }:
 4 | # This function returns a flake outputs-compatible schema.
 5 | {
 6 |   # pass an instance of self
 7 |   self
 8 | , # pass an instance of the nixpkgs flake
 9 |   nixpkgs
10 | , # we assume that the name maps to the project name, and also that the
11 |   # overlay has an attribute with the `name` prefix that contains all of the
12 |   # project's packages.
13 |   name
14 | , # nixpkgs config
15 |   config ? { }
16 | , # pass either a function or a file
17 |   overlay ? null
18 | , # use this to load other flakes overlays to supplement nixpkgs
19 |   preOverlays ? [ ]
20 | , # maps to the devShell output. Pass in a shell.nix file or function.
21 |   shell ? null
22 | , # pass the list of supported systems
23 |   systems ? defaultSystems
24 | }:
25 | let
26 |   loadOverlay = obj:
27 |     if obj == null then
28 |       [ ]
29 |     else
30 |       [ (maybeImport obj) ]
31 |   ;
32 | 
33 |   maybeImport = obj:
34 |     if (builtins.typeOf obj == "path") || (builtins.typeOf obj == "string") then
35 |       import obj
36 |     else
37 |       obj
38 |   ;
39 | 
40 |   overlays = preOverlays ++ (loadOverlay overlay);
41 | 
42 |   shell_ = maybeImport shell;
43 | 
44 |   outputs = lib.eachSystem systems (system:
45 |     let
46 |       pkgs = import nixpkgs {
47 |         inherit
48 |           config
49 |           overlays
50 |           system
51 |           ;
52 |       };
53 | 
54 |       packages = pkgs.${name} or { };
55 |     in
56 |     {
57 |       # Use the legacy packages since it's more forgiving.
58 |       legacyPackages = packages;
59 |     }
60 |     //
61 |     (
62 |       if packages ? defaultPackage then {
63 |         defaultPackage = packages.defaultPackage;
64 |       } else { }
65 |     )
66 |     //
67 |     (
68 |       if packages ? checks then {
69 |         checks = packages.checks;
70 |       } else { }
71 |     )
72 |     //
73 |     (
74 |       if shell != null then {
75 |         devShell = shell_ { inherit pkgs; };
76 |       } else if packages ? devShell then {
77 |         devShell = packages.devShell;
78 |       } else { }
79 |     )
80 |   );
81 | in
82 | outputs
83 | 


--------------------------------------------------------------------------------