nix-community.nixvim/plugins/pluginmanagers/packer.nix

{
  lib,
  helpers,
  config,
  pkgs,
  ...
}:
with lib; let
  cfg = config.plugins.packer;
in {
  options = {
    plugins.packer = {
      enable = mkEnableOption "packer.nvim";

      plugins = with types; let
        pluginType =
          either
          str
          (submodule {
            options = {
              name = mkOption {
                type = str;
                description = "Name of the plugin to install";
              };

              disable = helpers.mkNullOrOption bool "Mark plugin as inactive";

              as =
                helpers.mkNullOrOption str
                "Specifies an alias under which to install the plugin";

              installer = helpers.defaultNullOpts.mkLuaFn "nil" "A custom installer";

              updater = helpers.defaultNullOpts.mkLuaFn "nil" "A custom updater";

              after =
                helpers.mkNullOrOption (either str (listOf str))
                "Plugins to load after this plugin";

              rtp =
                helpers.mkNullOrOption str
                "Specifies a subdirectory of the plugin to add to runtimepath";

              opt = helpers.mkNullOrOption bool "Marks a plugin as optional";

              branch = helpers.mkNullOrOption str "Git branch to use";

              tag = helpers.mkNullOrOption str "Git tag to use";

              commit = helpers.mkNullOrOption str "Git commit to use";

              lock = helpers.mkNullOrOption bool "Skip this plugin in updates";

              run =
                helpers.mkNullOrOption
                (oneOf [
                  str
                  helpers.nixvimTypes.rawLua
                  (listOf (either str helpers.nixvimTypes.rawLua))
                ])
                "Post-install hook";

              requires =
                helpers.mkNullOrOption (helpers.nixvimTypes.eitherRecursive str listOfPlugins)
                "Plugin dependencies";

              rocks =
                helpers.mkNullOrOption (either str (listOf (either str attrs)))
                "Luarocks dependencies";

              config =
                helpers.mkNullOrOption (either str helpers.nixvimTypes.rawLua)
                "Code to run after this plugin is loaded";

              setup =
                helpers.mkNullOrOption (either str helpers.nixvimTypes.rawLua)
                "Code to be run before this plugin is loaded";

              cmd =
                helpers.mkNullOrOption (either str (listOf str))
                "Commands which load this plugin";

              ft =
                helpers.mkNullOrOption (either str (listOf str))
                "Filetypes which load this plugin";

              keys =
                helpers.mkNullOrOption (either str (listOf str))
                "Keymaps which load this plugin";

              event =
                helpers.mkNullOrOption (either str (listOf str))
                "Autocommand events which load this plugin";

              fn =
                helpers.mkNullOrOption (either str (listOf str))
                "Functions which load this plugin";

              cond =
                helpers.mkNullOrOption
                (oneOf [
                  str
                  helpers.nixvimTypes.rawLua
                  (listOf (either str helpers.nixvimTypes.rawLua))
                ])
                "Conditional test to load this plugin";

              module =
                helpers.mkNullOrOption (either str (listOf str))
                "Patterns of module names which load this plugin";
            };
          });

        listOfPlugins = types.listOf pluginType;
      in
        mkOption {
          type = listOfPlugins;
          default = [];
          description = "List of plugins";
        };

      rockPlugins = mkOption {
        type = with types; listOf (either str attrs);
        description = "List of lua rock plugins";
        default = [];
        example = ''
          [
            "penlight"
            "lua-resty-http"
            "lpeg"
          ]
        '';
      };
    };
  };

  config = mkIf cfg.enable {
    extraPlugins = [(pkgs.vimPlugins.packer-nvim.overrideAttrs (_: {pname = "packer.nvim";}))];
    extraPackages = [pkgs.git];

    extraConfigLua = let
      luaRockPluginToLua = luaRockPlugin:
        if isAttrs luaRockPlugin
        then
          mapAttrs'
          (k: v: {
            name =
              if k == "name"
              then "__unkeyed"
              else k;
            value = v;
          })
          luaRockPlugin
        else luaRockPlugin;
      luaRockListToLua = map luaRockPluginToLua;

      pluginToLua = plugin:
        if isAttrs plugin
        then {
          "__unkeyed" = plugin.name;

          inherit
            (plugin)
            disable
            as
            installer
            updater
            after
            rtp
            opt
            branch
            tag
            commit
            lock
            run
            ;

          requires =
            helpers.ifNonNull' plugin.requires
            (
              if isList plugin.requires
              then (pluginListToLua plugin.requires)
              else plugin.requires
            );

          rocks =
            helpers.ifNonNull' plugin.rocks
            (
              if isList plugin.rocks
              then luaRockListToLua plugin.rocks
              else plugin.rocks
            );

          inherit
            (plugin)
            config
            setup
            cmd
            ft
            keys
            event
            fn
            cond
            module
            ;
        }
        else plugin;

      pluginListToLua = map pluginToLua;

      plugins = pluginListToLua cfg.plugins;

      packedPlugins =
        if length plugins == 1
        then head plugins
        else plugins;

      luaRockPlugins = luaRockListToLua cfg.rockPlugins;
      luaRocksString =
        optionalString (cfg.rockPlugins != [])
        "use_rocks ${helpers.toLuaObject luaRockPlugins}";
    in
      mkIf (cfg.plugins != []) ''
        require('packer').startup(function()
          use ${helpers.toLuaObject packedPlugins}
          ${luaRocksString}
        end)
      '';
  };
}