Merge 65c4e4aafd into da5c91424e

flake.nix

@@ -4,16 +4,8 @@
     flake-parts,
     self,
     ...
-  } @ inputs: let
+  } @ inputs:
-    # Call the extended library with `inputs`.
+    flake-parts.lib.mkFlake {inherit inputs;} {
-    # inputs is used to get the original standard library, and to pass inputs
-    # to the plugin autodiscovery function
-    lib = import ./lib/stdlib-extended.nix {inherit inputs self;};
-  in
-    flake-parts.lib.mkFlake {
-      inherit inputs;
-      specialArgs = {inherit lib;};
-    } {
       # Allow users to bring their own systems.
       # «https://github.com/nix-systems/nix-systems»
       systems = import inputs.systems;
@@ -24,16 +16,19 @@
         ./flake/develop.nix
       ];
 
-      flake = {
+      flake = {lib, ...}: let
+        # inputs is passed for the plugin autodiscovery function
+        nvf-lib = lib.fixedPoints.makeExtensible (import ./lib {inherit inputs self;});
+      in {
         lib = {
-          inherit (lib) nvim;
+          nvim = nvf-lib;
-          inherit (lib.nvim) neovimConfiguration;
+          inherit (nvf-lib) neovimConfiguration;
         };
 
         inherit (lib.importJSON ./npins/sources.json) pins;
 
         homeManagerModules = {
-          nvf = import ./flake/modules/home-manager.nix {inherit lib inputs;};
+          nvf = import ./flake/modules/home-manager.nix {inherit inputs;};
           default = self.homeManagerModules.nvf;
           neovim-flake =
             lib.warn ''
@@ -44,7 +39,7 @@
         };
 
         nixosModules = {
-          nvf = import ./flake/modules/nixos.nix {inherit lib inputs;};
+          nvf = import ./flake/modules/nixos.nix {inherit inputs;};
           default = self.nixosModules.nvf;
           neovim-flake =
             lib.warn ''

flake/develop.nix

@@ -1,4 +1,4 @@
-{lib, ...}: {
+{self, ...}: {
   perSystem = {
     pkgs,
     config,
@@ -20,7 +20,7 @@
     packages.dev = let
       configuration = {};
 
-      customNeovim = lib.nvim.neovimConfiguration {
+      customNeovim = self.lib.nvim.neovimConfiguration {
         inherit pkgs;
         modules = [configuration];
       };

flake/modules/home-manager.nix

@@ -1,9 +1,7 @@
 # Home Manager module
-{
+{inputs}: {
-  inputs,
-  lib,
-}: {
   config,
+  lib,
   pkgs,
   ...
 }: let

flake/modules/nixos.nix

@@ -1,9 +1,7 @@
 # NixOS module
-{
+{inputs}: {
-  inputs,
-  lib,
-}: {
   config,
+  lib,
   pkgs,
   ...
 }: let

lib/attrsets.nix

@@ -1,4 +1,4 @@
-{lib}: let
+_: let
   inherit (builtins) listToAttrs;
 in {
   mapListToAttrs = f: list: listToAttrs (map f list);

lib/binds.nix

@@ -1,4 +1,4 @@
-{lib}: let
+{lib, ...}: let
   inherit (lib.options) mkOption;
   inherit (lib.modules) mkIf mkDefault;
   inherit (lib.types) nullOr str;

lib/config.nix

@@ -1,4 +1,4 @@
-{lib}: let
+{lib, ...}: let
   inherit (lib.options) mkOption;
   inherit (lib.types) bool;
   inherit (lib.modules) mkRenamedOptionModule;

lib/dag.nix

@@ -7,11 +7,15 @@
 #
 #  - the addition of the function `entryBefore` indicating a "wanted
 #    by" relationship.
-{lib}: let
+{
+  lib,
+  nvf-lib,
+  ...
+}: let
   inherit (builtins) isAttrs attrValues attrNames elem all head tail length toJSON isString removeAttrs;
   inherit (lib.attrsets) filterAttrs mapAttrs;
   inherit (lib.lists) toposort;
-  inherit (lib.nvim.dag) empty isEntry entryBetween entryAfter entriesBetween entryAnywhere topoSort;
+  inherit (nvf-lib.dag) empty isEntry entryBetween entryAfter entriesBetween entryAnywhere topoSort;
 in {
   empty = {};
 

lib/default.nix

@@ -1,16 +1,22 @@
 {
-  self,
   inputs,
-  lib,
+  self,
-  ...
+}: final: let
-}: {
+  # Modeled after nixpkgs' lib.
-  types = import ./types {inherit lib self;};
+  callLibs = file:
-  config = import ./config.nix {inherit lib;};
+    import file {
-  binds = import ./binds.nix {inherit lib;};
+      nvf-lib = final;
-  dag = import ./dag.nix {inherit lib;};
+      inherit inputs self;
-  languages = import ./languages.nix {inherit lib;};
+      inherit (inputs.nixpkgs) lib;
-  lists = import ./lists.nix {inherit lib;};
+    };
-  attrsets = import ./attrsets.nix {inherit lib;};
+in {
-  lua = import ./lua.nix {inherit lib;};
+  types = callLibs ./types;
-  neovimConfiguration = import ../modules {inherit self inputs lib;};
+  config = callLibs ./config.nix;
+  binds = callLibs ./binds.nix;
+  dag = callLibs ./dag.nix;
+  languages = callLibs ./languages.nix;
+  lists = callLibs ./lists.nix;
+  attrsets = callLibs ./attrsets.nix;
+  lua = callLibs ./lua.nix;
+  neovimConfiguration = callLibs ../modules;
 }

lib/languages.nix

@@ -1,9 +1,13 @@
-{lib}: let
+{
+  lib,
+  nvf-lib,
+  ...
+}: let
   inherit (builtins) isString getAttr;
   inherit (lib.options) mkOption;
   inherit (lib.types) listOf bool str submodule attrsOf anything either nullOr uniq;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (nvf-lib.attrsets) mapListToAttrs;
-  inherit (lib.nvim.types) luaInline;
+  inherit (nvf-lib.types) luaInline;
 in {
   # TODO: remove
   diagnosticsToLua = {

lib/lists.nix

@@ -1,4 +1,4 @@
-{lib}: let
+{lib, ...}: let
   inherit (lib.lists) elem all;
 in {
   /*

lib/lua.nix

@@ -1,5 +1,5 @@
 # Helpers for converting values to lua
-{lib}: let
+{lib, ...}: let
   isLuaInline = object: (object._type or null) == "lua-inline";
 
   toLuaObject = args:

lib/stdlib-extended.nix

@@ -1,21 +0,0 @@
-# Convenience function that returns the given Nixpkgs standard library
-# extended with our functions using `lib.extend`.
-{inputs, ...} @ args:
-inputs.nixpkgs.lib.extend (self: super: {
-  # WARNING: New functions should not be added here, but to files
-  # imported by `./default.nix` under their own categories. If your
-  # function does not fit to any of the existing categories, create
-  # a new file and import it in `./default.nix.`
-
-  # Makes our custom functions available under `lib.nvim` where stdlib-extended.nix is imported
-  # with the appropriate arguments. For end-users, a `lib` output will be accessible from the flake.
-  # E.g. for an input called `nvf`, `inputs.nvf.lib.nvim` will return the set
-  # below.
-  nvim = import ./. {
-    inherit (args) inputs self;
-    lib = self;
-  };
-
-  # For forward compatibility.
-  literalExpression = super.literalExpression or super.literalExample;
-})

lib/types/custom.nix

@@ -1,4 +1,4 @@
-{lib}: let
+{lib, ...}: let
   inherit (lib.options) mergeEqualOption;
   inherit (lib.lists) singleton;
   inherit (lib.strings) isString stringLength match;

lib/types/dag.nix

@@ -1,33 +1,31 @@
 # From home-manager: https://github.com/nix-community/home-manager/blob/master/modules/lib/types-dag.nix
 # Used for ordering configuration text.
-{lib}: let
+{
-  inherit
+  lib,
-    (lib)
+  nvf-lib,
-    defaultFunctor
+  ...
-    nvim
+}: let
-    mkIf
+  inherit (lib.types) attrsOf defaultFunctor listOf mkOptionType str submodule;
-    mkOrder
+  inherit (lib.modules) mkIf mkOrder;
-    mkOption
+  inherit (lib.options) mkOption;
-    mkOptionType
+  inherit (nvf-lib.dag) isEntry entryAnywhere;
-    types
-    ;
 
   dagEntryOf = elemType: let
-    submoduleType = types.submodule ({name, ...}: {
+    submoduleType = submodule ({name, ...}: {
       options = {
         data = mkOption {type = elemType;};
-        after = mkOption {type = with types; listOf str;};
+        after = mkOption {type = listOf str;};
-        before = mkOption {type = with types; listOf str;};
+        before = mkOption {type = listOf str;};
       };
       config = mkIf (elemType.name == "submodule") {
         data._module.args.dagName = name;
       };
     });
     maybeConvert = def:
-      if nvim.dag.isEntry def.value
+      if isEntry def.value
       then def.value
       else
-        nvim.dag.entryAnywhere (
+        entryAnywhere (
           if def ? priority
           then mkOrder def.priority def.value
           else def.value
@@ -53,7 +51,7 @@ in rec {
   # "actual" attribute name a new submodule argument is provided with
   # the name `dagName`.
   dagOf = elemType: let
-    attrEquivalent = types.attrsOf (dagEntryOf elemType);
+    attrEquivalent = attrsOf (dagEntryOf elemType);
   in
     mkOptionType rec {
       name = "dagOf";

lib/types/default.nix

@@ -1,14 +1,6 @@
-{
+args: {
-  lib,
+  inherit (import ./dag.nix args) dagOf;
-  self,
+  inherit (import ./plugins.nix args) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
-}: let
+  inherit (import ./languages.nix args) diagnostics mkGrammarOption;
-  typesDag = import ./dag.nix {inherit lib;};
+  inherit (import ./custom.nix args) char hexColor mergelessListOf singleOrListOf;
-  typesPlugin = import ./plugins.nix {inherit lib self;};
-  typesLanguage = import ./languages.nix {inherit lib;};
-  customTypes = import ./custom.nix {inherit lib;};
-in {
-  inherit (typesDag) dagOf;
-  inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
-  inherit (typesLanguage) diagnostics mkGrammarOption;
-  inherit (customTypes) char hexColor mergelessListOf singleOrListOf;
 }

lib/types/languages.nix

@@ -1,4 +1,4 @@
-{lib}: let
+{lib, ...}: let
   inherit (lib.options) mkOption mkPackageOption;
   inherit (lib.attrsets) attrNames;
   inherit (lib.types) listOf either enum submodule package;

lib/types/plugins.nix

@@ -1,11 +1,14 @@
 {
   lib,
+  nvf-lib,
   self,
+  ...
 }: let
   inherit (lib.options) mkOption;
   inherit (lib.attrsets) attrNames mapAttrs' filterAttrs nameValuePair;
   inherit (lib.strings) hasPrefix removePrefix;
-  inherit (lib.types) submodule either package enum str lines anything listOf nullOr;
+  inherit (lib.types) submodule either package enum str lines anything listOf nullOr mkOptionType;
+  inherit (nvf-lib.lua) isLuaInline;
 
   # Get the names of all flake inputs that start with the given prefix.
   fromInputs = {
@@ -64,9 +67,9 @@ in {
       type = pluginsType;
     };
 
-  luaInline = lib.mkOptionType {
+  luaInline = mkOptionType {
     name = "luaInline";
-    check = x: lib.nvim.lua.isLuaInline x;
+    check = x: isLuaInline x;
   };
 
   /*

modules/default.nix

@@ -1,7 +1,7 @@
 {
   self,
   inputs,
-  lib,
+  ...
 }: {
   pkgs,
   extraSpecialArgs ? {},
@@ -10,17 +10,20 @@
   extraModules ? [],
   configuration ? {},
 }: let
+  inherit (pkgs) lib;
+  inherit (lib.modules) evalModules;
   inherit (lib.strings) toString;
-  inherit (lib.lists) concatLists;
+  inherit (lib.trivial) warn;
+  inherit (lib.lists) concatLists optional optionals;
 
-  # import modules.nix with `check`, `pkgs` and `lib` as arguments
+  # import modules.nix with `check` and `pkgs` as arguments
   # check can be disabled while calling this file is called
   # to avoid checking in all modules
-  nvimModules = import ./modules.nix {inherit pkgs lib;};
+  nvimModules = import ./modules.nix {inherit pkgs;};
 
   # evaluate the extended library with the modules
   # optionally with any additional modules passed by the user
-  module = lib.evalModules {
+  module = evalModules {
     specialArgs =
       extraSpecialArgs
       // {
@@ -30,12 +33,12 @@
     modules = concatLists [
       nvimModules
       modules
-      (lib.optional (configuration != {}) (lib.warn ''
+      (optional (configuration != {}) (warn ''
           nvf: passing 'configuration' to lib.neovimConfiguration is deprecated.
         ''
         configuration))
 
-      (lib.optionals (extraModules != []) (lib.warn ''
+      (optionals (extraModules != []) (warn ''
           nvf: passing 'extraModules' to lib.neovimConfiguration is deprecated, use 'modules' instead.
         ''
         extraModules))