treewide: Use nixpkgs fetchers for npins

Author: Gerg-L

.editorconfig

@@ -26,3 +26,6 @@ trim_trailing_whitespace = unset
 
 [*.lock]
 indent_size = unset
+
+[npins/sources.json]
+insert_final_newline = unset

.github/typos.toml

@@ -1,2 +1,5 @@
 
 default.extend-ignore-words-re = ["(?i)(noice)", "befores", "annote", "viw"]
+files.extend-exclude = [
+"npins/sources.json"
+]

docs/manual/configuring.md

@@ -3,7 +3,7 @@
 ```{=include=} chapters
 configuring/custom-package.md
 configuring/custom-plugins.md
-configuring/custom-inputs.md
+configuring/overriding-plugins.md
 configuring/languages.md
 configuring/dags.md
 configuring/dag-entries.md

docs/manual/configuring/custom-inputs.md

@@ -0,0 +1,35 @@
+# Overriding plugins {#ch-overriding-plugins}
+
+The [additional plugins section](#sec-additional-plugins) details the addition
+of new plugins to nvf under regular circumstances, i.e. while making a pull
+request to the project. You may _override_ those plugins in your config
+to change source versions, e.g., to use newer versions of plugins
+that are not yet updated in **nvf**.
+
+```nix
+vim.pluginOverrides = {
+  lazydev-nvim = pkgs.fetchFromGitHub {
+    owner = "folke";
+    repo = "lazydev.nvim";
+    rev = "";
+    hash = "";
+  };
+ # It's also possible to use a flake input
+ lazydev-nvim = inputs.lazydev-nvim;
+ # Or a local path 
+ lazydev-nvim = ./lazydev;
+ # Or a npins pin... etc
+};
+```
+
+This will override the source for the `neodev.nvim` plugin that is used in nvf
+with your own plugin.
+
+::: {.warning}
+
+While updating plugin inputs, make sure that any configuration that has been
+deprecated in newer versions is changed in the plugin's `setupOpts`. If you
+depend on a new version, requesting a version bump in the issues section is a
+more reliable option.
+
+:::

docs/manual/configuring/overriding-plugins.md

@@ -1,36 +1,25 @@
 # Adding Plugins {#sec-additional-plugins}
 
-To add a new Neovim plugin, first add the source url in the inputs section of
-`flake.nix` with the prefix `plugin-`
+To add a new Neovim plugin, use `npins`
 
-```nix
-{
-  inputs = {
-    # ...
-    plugin-neodev-nvim = {
-      url = "github:folke/neodev.nvim";
-      flake = false;
-    };
-    # ...
-  };
-}
-```
+Use:
+
+`nix-shell -p npins` or `nix shell nixpkgs#npins`
+
+Then run:
+
+`npins --name <plugin name> github <owner> <repo> -b <branch>`
+
+Be sure to replace any non-alphanumeric characters with `-` for `--name`
 
-Prepending `plugin-` to the name of the input will allow nvf to automatically
-discover inputs that are marked as plugins, and make them available in
-`vim.startPlugins` or other areas that require a very specific plugin type as it
-is defined in `@NVF_REPO@/lib/types/plugins.nix`
+For example 
 
-The addition of the `plugin-` prefix will allow **nvf** to autodiscover the
-input from the flake inputs automatically, allowing you to refer to it in areas
-that require a very specific plugin type as defined in `lib/types/plugins.nix`
+`npins --name lazydev-nvim github folke laztdev.nvim -b main`
 
-You can now reference this plugin using its string name, the plugin will be
-built with the name and source URL from the flake input, allowing you to refer
-to it as a **string**.
+You can now reference this plugin as a **string**.
 
 ```nix
-config.vim.startPlugins = ["neodev-nvim"];
+config.vim.startPlugins = ["lazydev-nvim"];
 ```
 
 ## Modular setup options {#sec-modular-setup-options}

docs/manual/hacking/additional-plugins.md

@@ -23,15 +23,17 @@ An example flake that exposes your custom Neovim configuration might look like
     nvf.url = "github:notashelf/nvf";
   };
 
-  outputs = {
-    self,
-    nixpkgs,
-    ...
-  } @ inputs: {
-    packages."x86_64-linux" = let
-        neovimConfigured = (inputs.nvf.lib.neovimConfiguration {
-          inherit (nixpkgs.legacyPackages."x86_64-linux") pkgs;
-          modules = [{
+  outputs = {nixpkgs, ...} @ inputs: {
+    packages.x86_64-linux = {
+      # Set the default package to the wrapped instance of Neovim.
+      # This will allow running your Neovim configuration with
+      # `nix run` and in addition, sharing your configuration with
+      # other users in case your repository is public.
+      default =
+        (inputs.nvf.lib.neovimConfiguration {
+          pkgs = nixpkgs.legacyPackages.x86_64-linux;
+          modules = [
+            {
               config.vim = {
                 # Enable custom theming options
                 theme.enable = true;
@@ -43,14 +45,10 @@ An example flake that exposes your custom Neovim configuration might look like
                 # reference in Appendix B of the nvf manual.
                 # ...
               };
-          }];
-        });
-    in {
-      # Set the default package to the wrapped instance of Neovim.
-      # This will allow running your Neovim configuration with
-      # `nix run` and in addition, sharing your configuration with
-      # other users in case your repository is public.
-      default = neovimConfigured.neovim;
+            }
+          ];
+        })
+        .neovim;
     };
   };
 }

docs/manual/installation/custom-configuration.md

@@ -49,13 +49,10 @@ Followed by importing the home-manager module somewhere in your configuration.
     nvf.url = "github:notashelf/nvf";
   };
 
-  outputs = { nixpkgs, home-manager, nvf, ... }: let
-    system = "x86_64-linux";
-    pkgs = nixpkgs.legacyPackages.${system};
-  in {
+  outputs = { nixpkgs, home-manager, nvf, ... }: {
     # ↓ this is your home output in the flake schema, expected by home-manager
     "your-username@your-hostname" = home-manager.lib.homeManagerConfiguration {
-      inherit pkgs;
+      pkgs = nixpkgs.legacyPackages.x86_64-linux;
       modules = [
         nvf.homeManagerModules.default # <- this imports the home-manager module that provides the options
         ./home.nix # <- your home entrypoint, `programs.nvf.*` may be defined here

docs/manual/installation/modules/home-manager.md

@@ -16,38 +16,46 @@ the default theme enabled. You may use other options inside `config.vim` in
     nvf.url = "github:notashelf/nvf";
   };
 
-  outputs = {nixpkgs, nvf, ...}: let
-    system = "x86_64-linux";
-    pkgs = nixpkgs.legacyPackages.${system};
-    configModule = {
-      # Add any custom options (and do feel free to upstream them!)
-      # options = { ... };
-
-      config.vim = {
-        theme.enable = true;
-        # and more options as you see fit...
-      };
-    };
-
-    customNeovim = nvf.lib.neovimConfiguration {
-      inherit pkgs;
-      modules = [configModule];
-    };
-  in {
+  outputs = {
+    nixpkgs,
+    nvf,
+    self,
+    ...
+  }: {
     # This will make the package available as a flake output under 'packages'
-    packages.${system}.my-neovim = customNeovim.neovim;
+    packages.x86_64-linux.my-neovim =
+      (nvf.lib.neovimConfiguration {
+        pkgs = nixpkgs.legacyPackages.x86_64-linux;
+        modules = [
+          # Or move this to a seperate file and add it's path here instead
+          # IE: ./nvf_module.nix
+          (
+            {pkgs, ...}: {
+              # Add any custom options (and do feel free to upstream them!)
+              # options = { ... };
+              config.vim = {
+                theme.enable = true;
+                # and more options as you see fit...
+              };
+            }
+          )
+        ];
+      })
+      .neovim;
 
     # Example nixosConfiguration using the configured Neovim package
     nixosConfigurations = {
       yourHostName = nixpkgs.lib.nixosSystem {
         # ...
         modules = [
           # This will make wrapped neovim available in your system packages
-          {environment.systemPackages = [customNeovim.neovim];}
+          # Can also move this to another config file if you pass inputs/self around with specialArgs
+          ({pkgs, ...}: {
+            environment.systemPackages = [self.packages.${pkgs.stdenv.system}.neovim];
+          })
         ];
         # ...
       };
     };
   };
-}
-```
+}```

docs/manual/installation/standalone/nixos.md

@@ -52,7 +52,7 @@
             self.nixosModules.nvf;
         };
 
-        pins = import ./npins;
+        inherit (lib.importJSON ./npins/sources.json) pins;
       };
 
       perSystem = {pkgs, ...}: {

flake.nix

@@ -9,7 +9,7 @@
       default = self'.devShells.lsp;
       nvim-nix = pkgs.mkShellNoCC {packages = [config.packages.nix];};
       lsp = pkgs.mkShellNoCC {
-        packages = with pkgs; [nil statix deadnix alejandra];
+        packages = with pkgs; [nil statix deadnix alejandra npins];
       };
     };
 

flake/develop.nix

@@ -4,8 +4,7 @@
   lib,
   ...
 }: {
-  types = import ./types {inherit self inputs lib;};
-
+  types = import ./types {inherit lib;};
   config = import ./config.nix {inherit lib;};
   binds = import ./binds.nix {inherit lib;};
   dag = import ./dag.nix {inherit lib;};

lib/default.nix

@@ -1,11 +1,6 @@
-{
-  self,
-  inputs,
-  lib,
-  ...
-}: let
+{lib}: let
   typesDag = import ./dag.nix {inherit lib;};
-  typesPlugin = import ./plugins.nix {inherit self inputs lib;};
+  typesPlugin = import ./plugins.nix {inherit lib;};
   typesLanguage = import ./languages.nix {inherit lib;};
   customTypes = import ./custom.nix {inherit lib;};
 in {

lib/types/default.nix

@@ -1,12 +1,7 @@
-{
-  self,
-  inputs,
-  lib,
-  ...
-}: let
+{lib}: let
   inherit (lib.options) mkOption;
   inherit (lib.attrsets) attrNames mapAttrs' filterAttrs nameValuePair;
-  inherit (lib.strings) hasPrefix removePrefix replaceStrings toLower;
+  inherit (lib.strings) hasPrefix removePrefix;
   inherit (lib.types) submodule either package enum str lines anything listOf nullOr;
 
   # Get the names of all flake inputs that start with the given prefix.
@@ -16,8 +11,8 @@
   }:
     mapAttrs' (n: v: nameValuePair (removePrefix prefix n) {src = v;}) (filterAttrs (n: _: hasPrefix prefix n) inputs);
 
-  #  Get the names of all flake inputs that start with the given prefix.
-  pluginInputNames = map (pin: replaceStrings ["." "_"] ["-" "-"] (toLower pin)) (attrNames self.pins);
+  #  Get the names of all npins
+  pluginInputNames = attrNames (lib.importJSON ../../npins/sources.json).pins;
 
   # You can either use the name of the plugin or a package.
   pluginType = nullOr (