dev: rebase on a less personalized neovim flake

modules/lib/booleans.nix

@@ -0,0 +1,9 @@
+# From home-manager: https://github.com/nix-community/home-manager/blob/master/modules/lib/booleans.nix
+{lib}: {
+  # Converts a boolean to a yes/no string. This is used in lots of
+  # configuration formats.
+  yesNo = value:
+    if value
+    then "yes"
+    else "no";
+}

modules/lib/dag.nix

@@ -0,0 +1,105 @@
+# From home-manager: https://github.com/nix-community/home-manager/blob/master/modules/lib/dag.nix
+# A generalization of Nixpkgs's `strings-with-deps.nix`.
+#
+# The main differences from the Nixpkgs version are
+#
+#  - not specific to strings, i.e., any payload is OK,
+#
+#  - the addition of the function `entryBefore` indicating a "wanted
+#    by" relationship.
+{lib}: let
+  inherit (lib) all filterAttrs nvim mapAttrs toposort;
+in {
+  empty = {};
+
+  isEntry = e: e ? data && e ? after && e ? before;
+  isDag = dag:
+    builtins.isAttrs dag && all nvim.dag.isEntry (builtins.attrValues dag);
+
+  # Takes an attribute set containing entries built by entryAnywhere,
+  # entryAfter, and entryBefore to a topologically sorted list of
+  # entries.
+  #
+  # Internally this function uses the `toposort` function in
+  # `<nixpkgs/lib/lists.nix>` and its value is accordingly.
+  #
+  # Specifically, the result on success is
+  #
+  #    { result = [ { name = ?; data = ?; } … ] }
+  #
+  # For example
+  #
+  #    nix-repl> topoSort {
+  #                a = entryAnywhere "1";
+  #                b = entryAfter [ "a" "c" ] "2";
+  #                c = entryBefore [ "d" ] "3";
+  #                d = entryBefore [ "e" ] "4";
+  #                e = entryAnywhere "5";
+  #              } == {
+  #                result = [
+  #                  { data = "1"; name = "a"; }
+  #                  { data = "3"; name = "c"; }
+  #                  { data = "2"; name = "b"; }
+  #                  { data = "4"; name = "d"; }
+  #                  { data = "5"; name = "e"; }
+  #                ];
+  #              }
+  #    true
+  #
+  # And the result on error is
+  #
+  #    {
+  #      cycle = [ { after = ?; name = ?; data = ? } … ];
+  #      loops = [ { after = ?; name = ?; data = ? } … ];
+  #    }
+  #
+  # For example
+  #
+  #    nix-repl> topoSort {
+  #                a = entryAnywhere "1";
+  #                b = entryAfter [ "a" "c" ] "2";
+  #                c = entryAfter [ "d" ] "3";
+  #                d = entryAfter [ "b" ] "4";
+  #                e = entryAnywhere "5";
+  #              } == {
+  #                cycle = [
+  #                  { after = [ "a" "c" ]; data = "2"; name = "b"; }
+  #                  { after = [ "d" ]; data = "3"; name = "c"; }
+  #                  { after = [ "b" ]; data = "4"; name = "d"; }
+  #                ];
+  #                loops = [
+  #                  { after = [ "a" "c" ]; data = "2"; name = "b"; }
+  #                ];
+  #              }
+  #    true
+  topoSort = dag: let
+    dagBefore = dag: name:
+      builtins.attrNames
+      (filterAttrs (n: v: builtins.elem name v.before) dag);
+    normalizedDag =
+      mapAttrs (n: v: {
+        name = n;
+        data = v.data;
+        after = v.after ++ dagBefore dag n;
+      })
+      dag;
+    before = a: b: builtins.elem a.name b.after;
+    sorted = toposort before (builtins.attrValues normalizedDag);
+  in
+    if sorted ? result
+    then {
+      result = map (v: {inherit (v) name data;}) sorted.result;
+    }
+    else sorted;
+
+  # Applies a function to each element of the given DAG.
+  map = f: mapAttrs (n: v: v // {data = f n v.data;});
+
+  entryBetween = before: after: data: {inherit data before after;};
+
+  # Create a DAG entry with no particular dependency information.
+  entryAnywhere = nvim.dag.entryBetween [] [];
+
+  entryAfter = nvim.dag.entryBetween [];
+  entryBefore = before: nvim.dag.entryBetween before [];
+}

modules/lib/default.nix

@@ -0,0 +1,5 @@
+{lib}: {
+  dag = import ./dag.nix {inherit lib;};
+  booleans = import ./booleans.nix {inherit lib;};
+  types = import ./types.nix {inherit lib;};
+}

modules/lib/stdlib-extended.nix

@@ -0,0 +1,13 @@
+# From home-manager: https://github.com/nix-community/home-manager/blob/master/modules/lib/stdlib-extended.nix
+# Just a convenience function that returns the given Nixpkgs standard
+# library extended with the HM library.
+nixpkgsLib: let
+  mkNvimLib = import ./.;
+in
+  nixpkgsLib.extend (self: super: {
+    nvim = mkNvimLib {lib = self;};
+
+    # For forward compatibility.
+    literalExpression = super.literalExpression or super.literalExample;
+    literalDocBook = super.literalDocBook or super.literalExample;
+  })

modules/lib/types-dag.nix

@@ -0,0 +1,68 @@
+# From home-manager: https://github.com/nix-community/home-manager/blob/master/modules/lib/types-dag.nix
+# Used for ordering config text.
+{lib}: let
+  inherit
+    (lib)
+    defaultFunctor
+    nvim
+    mkIf
+    mkOrder
+    mkOption
+    mkOptionType
+    types
+    ;
+
+  dagEntryOf = elemType: let
+    submoduleType = types.submodule ({name, ...}: {
+      options = {
+        data = mkOption {type = elemType;};
+        after = mkOption {type = with types; listOf str;};
+        before = mkOption {type = with types; listOf str;};
+      };
+      config = mkIf (elemType.name == "submodule") {
+        data._module.args.dagName = name;
+      };
+    });
+    maybeConvert = def:
+      if nvim.dag.isEntry def.value
+      then def.value
+      else
+        nvim.dag.entryAnywhere (
+          if def ? priority
+          then mkOrder def.priority def.value
+          else def.value
+        );
+  in
+    mkOptionType {
+      name = "dagEntryOf";
+      description = "DAG entry of ${elemType.description}";
+      # leave the checking to the submodule type
+      merge = loc: defs:
+        submoduleType.merge loc (map (def: {
+            inherit (def) file;
+            value = maybeConvert def;
+          })
+          defs);
+    };
+in rec {
+  # A directed acyclic graph of some inner type.
+  #
+  # Note, if the element type is a submodule then the `name` argument
+  # will always be set to the string "data" since it picks up the
+  # internal structure of the DAG values. To give access to the
+  # "actual" attribute name a new submodule argument is provided with
+  # the name `dagName`.
+  dagOf = elemType: let
+    attrEquivalent = types.attrsOf (dagEntryOf elemType);
+  in
+    mkOptionType rec {
+      name = "dagOf";
+      description = "DAG of ${elemType.description}";
+      inherit (attrEquivalent) check merge emptyValue;
+      getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name>"]);
+      getSubModules = elemType.getSubModules;
+      substSubModules = m: dagOf (elemType.substSubModules m);
+      functor = (defaultFunctor name) // {wrapped = elemType;};
+      nestedTypes.elemType = elemType;
+    };
+}

modules/lib/types-plugin.nix

@@ -0,0 +1,55 @@
+{lib}:
+with lib; let
+  # Plugin must be same as input name
+  availablePlugins = [
+    "nvim-treesitter-context"
+    "gitsigns-nvim"
+    "plenary-nvim"
+    "nvim-lspconfig"
+    "nvim-treesitter"
+    "lspsaga"
+    "lspkind"
+    "nvim-lightbulb"
+    "lsp-signature"
+    "nvim-tree-lua"
+    "nvim-bufferline-lua"
+    "lualine"
+    "nvim-compe"
+    "nvim-autopairs"
+    "nvim-ts-autotag"
+    "nvim-web-devicons"
+    "tokyonight"
+    "bufdelete-nvim"
+    "nvim-cmp"
+    "cmp-nvim-lsp"
+    "cmp-buffer"
+    "cmp-vsnip"
+    "cmp-path"
+    "cmp-treesitter"
+    "crates-nvim"
+    "vim-vsnip"
+    "nvim-code-action-menu"
+    "trouble"
+    "null-ls"
+    "which-key"
+    "indent-blankline"
+    "nvim-cursorline"
+    "sqls-nvim"
+    "glow-nvim"
+    "telescope"
+    "rust-tools"
+    "onedark"
+    "catppuccin"
+  ];
+
+  pluginsType = with types; listOf (nullOr (either (enum availablePlugins) package));
+in {
+  pluginsOpt = {
+    description,
+    default ? [],
+  }:
+    mkOption {
+      inherit description default;
+      type = pluginsType;
+    };
+}

modules/lib/types.nix

@@ -0,0 +1,7 @@
+{lib}: let
+  typesDag = import ./types-dag.nix {inherit lib;};
+  typesPlugin = import ./types-plugin.nix {inherit lib;};
+in {
+  inherit (typesDag) dagOf;
+  inherit (typesPlugin) pluginsOpt;
+}