nixvim-config/flake.nix at main · rummik/nixvim-config · 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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
{
  description = "*Kim's Neovim configuration flake";

  inputs = {
    devenv-root = {
      url = "file+file:///dev/null";
      flake = false;
    };

    nixpkgs.follows = "nixvim/nixpkgs";
    nixvim.url = "github:nix-community/nixvim";
    flake-parts.url = "github:hercules-ci/flake-parts";
    flake-parts.inputs.nixpkgs-lib.follows = "nixvim/nixpkgs";
  };

  nixConfig = {
    extra-trusted-public-keys = "devenv.cachix.org-1:w1cLUi8dv3hnoSPGAuibQv+f9TZLr6cv/Hm9XgU50cw=";
    extra-substituters = "https://devenv.cachix.org";
  };

  outputs = inputs@{ self, flake-parts, ... }:
    flake-parts.lib.mkFlake { inherit inputs; }
      ({ withSystem, flake-parts-lib, ... }:
        let

          inherit (flake-parts-lib) importApply;

          nixvimModules = {
            default = ./config;
            typescript = ./config/environments/typescript.nix;
            python = ./config/environments/python.nix;
            rust = ./config/environments/rust.nix;
            docker = ./config/environments/docker.nix;
            godot = ./config/environments/godot.nix;
            obsidian = ./config/environments/obsidian.nix;
          };

          flakeModules.default = importApply ./flake-module.nix {
            inherit withSystem;
            inherit nixvimModules;
            inputs.nixvim = inputs.nixvim;
          };

          nixvimConfig = options@{ system, modules ? [], ... }:
            inputs.nixvim.lib.evalNixvim (
              options // {
                modules = modules ++ [
                  nixvimModules.default
                  nixvimModules.typescript
                  nixvimModules.python
                  nixvimModules.rust
                  nixvimModules.docker
                  nixvimModules.godot
                ];
              }
            );

        in

        {
          imports = [
            flakeModules.default
            inputs.flake-parts.flakeModules.partitions
          ];

          # systems = inputs.nixpkgs.lib.systems.flakeExposed;
          systems = [ "x86_64-linux" "i686-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ];

          perSystem = { config, self', inputs', pkgs, system, ... }: {
            # Per-system attributes can be defined here. The self' and inputs'
            # module parameters provide easy access to attributes of the same
            # system.

            nixvimConfigurations = {
              default = nixvimConfig {
                inherit system;
              };
            };

            packages = {
              default = self'.packages.nvim;
              nvimpager = pkgs.nvimpager.override {
                neovim = self'.packages.nvim;
              };
            };
          };

          flake = {
            # The usual flake attributes can be defined here, including system-
            # agnostic ones like nixosModule and system-enumerating ones, although
            # those are more easily expressed in perSystem.

            inherit flakeModules;
            inherit nixvimModules;

            lib = {
              nixvimConfig = nixvimConfig;
            };
          };

          partitionedAttrs = {
            devShells = "dev";
            #templates = "dev";
          };

          partitions.dev = {
            extraInputsFlake = ./dev;

            module = { inputs, ... }: {
              imports = [ inputs.devenv.flakeModule ];

              perSystem = { config, self', inputs', pkgs, system, ... }: {
                devenv.shells.default = {
                  name = "nixvim-config";

                  # https://devenv.sh/reference/options/
                  packages = [
                    config.packages.default
                  ];

                  languages.nix.enable = true;

                  git-hooks.hooks = {
                    commitizen.enable = true;

                    markdownlint = {
                      enable = true;
                      settings.configuration = {
                        MD013.line_length = 120;
                      };
                    };

                    nil.enable = true;
                  };
                };
              };

#              flake.templates = inputs.haumea.lib.load {
#                src = ./templates;
#                loader = [({ matches = _: false; })];
#
#                transformer = cursor: mod:
#                  if builtins.length cursor > 0 then
#                    ./. + "/${builtins.head cursor}"
#                  else
#                    mod;
#              };
            };
          };
        }
      );
}