ngipkgs/default.nix at 0b0c567828165a0c49b1f199e4f51f0b25d51eac · ngi-nix/ngipkgs · 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
{
  flake-inputs ? import (fetchTarball {
    url = "https://github.com/fricklerhandwerk/flake-inputs/tarball/4.1.0";
    sha256 = "1j57avx2mqjnhrsgq3xl7ih8v7bdhz1kj3min6364f486ys048bm";
  }),
  flake ? flake-inputs.import-flake { src = ./.; },
  sources ? flake.inputs,
  system ? builtins.currentSystem,
  pkgs ? import sources.nixpkgs {
    config = { };
    overlays = import ./pkgs/overlays.nix { inherit lib; };
    inherit system;
  },
  lib ? import "${sources.nixpkgs}/lib",
}:
let
  devLib = import ./pkgs/lib.nix { inherit lib sources system; };

  flakeAttrs = default.import ./maintainers/flake { };

  default = devLib.customScope pkgs.newScope (self: {
    lib = lib.extend self.overlays.devLib;

    inherit
      devLib
      pkgs
      system
      sources
      flake
      default # expose final scope
      flakeAttrs
      ;

    ngipkgs = self.import ./pkgs/by-name { };

    shell = self.import ./maintainers/shells/default.nix { };

    overlays = {
      default =
        final: prev:
        self.import ./pkgs/by-name {
          pkgs = prev;
        };

      devLib = _: _: devLib;

      fixups = self.call ./pkgs/overlays.nix { };
    };

    optionsDoc = pkgs.nixosOptionsDoc {
      inherit (self.project-utils.eval-projects) options;
    };

    overview = self.import ./overview {
      self = flake;
      pkgs = pkgs.extend self.overlays.default;
      options = self.optionsDoc.optionsNix;
    };

    nixos-modules =
      # TODO: this is a weird shape for what we need: ngipkgs, services, modules?
      {
        # Allow using packages from `ngipkgs` to be used alongside regular `pkgs`
        ngipkgs =
          { ... }:
          {
            nixpkgs.overlays = [ self.overlays.default ] ++ self.overlays.fixups;
          };
      }
      // lib.foldl lib.recursiveUpdate { } (
        map (project: project.nixos.modules) (lib.attrValues self.hydrated-projects)
      );

    project-utils = self.import ./projects {
      pkgs = pkgs.extend default.overlays.default;
      sources = {
        inputs = sources;
        modules = default.nixos-modules;
        examples = lib.mapAttrs (
          _: project: lib.mapAttrs (_: example: example.module) project.nixos.examples
        ) self.hydrated-projects;
        demos = lib.mapAttrs (
            _: project: lib.filterAttrs (_: v: v != null) {
              vm = project.nixos.demo.vm.module or null;
              shell = project.nixos.demo.shell.module or null;
            }
          ) self.hydrated-projects;
      };
    };

    inherit (self.project-utils)
      checks
      projects
      hydrated-projects
      ;

    demo-utils = self.import ./overview/demo {
      ngipkgs-modules = lib.attrValues (devLib.flattenAttrs "." self.nixos-modules);
    };

    inherit (self.demo-utils)
      # for demo code activation. used in the overview code snippets
      demo-shell
      demo-vm
      # - $(nix-build -A demos.PROJECT_NAME)
      # - nix run .#demos.PROJECT_NAME
      demos
      ;

    metrics = self.import ./maintainers/metrics.nix {
      raw-projects = self.hydrated-projects;
    };

    report = self.import ./maintainers/report { };
  });
in
default
# required for update scripts
// default.ngipkgs