lazy equivalent to build = cf PackChanged

[n-prat]

Hi all,

Is there a way to have the same functionality as build =? eg for treesitter I would like to run :TSUpdate after install or update.

For now, I am doing:

-- https://neovim.io/doc/user/pack.html#vim.pack-events
-- Basically the equivalent of `build = ':TSUpdate'` with lazy.nvim
local hooks = function(ev)
	local name, kind = ev.data.spec.name, ev.data.kind
	-- TODO this may fail when installing the first time on new machine? Untested
	-- Probably would need to make sure the plugin is loaded before running the cmd
	if name == 'nvim-treesitter' and (kind == 'install' or kind == 'update') then
		vim.notify("nvim-treesitter updated/installed; running `:TSUpdate`", vim.log.levels.INFO)
		vim.cmd('TSUpdate')
	end
end
vim.api.nvim_create_autocmd('PackChanged', { callback = hooks })

Which seems to work just fine, but is a bit "overkill" as in this is listening to every plugin install/update/delete.

[BirdeeHub]

This is kinda more on how you wish to install it.

lze intends to be agnostic to what is used to install things.

As such, I probably will not be adding a built-in handler for this.

Also I would add that the snippet you showed is already lazy. However it does run for every PackChanged not just nvim-treesitter

---

How to do it like build = idk within your spec:

If you want to set build = ':TSUpdate' from within your spec, rather than having a whole separate thing for each time you want to do it you can do this yourself with a handler.

The following only accepts a function, not a string. You can do that, this is just an example

But for a proof of concept, you could do something like this.

Turns out that pattern gets the path to the plugin.

I haven't tested this I use nix for this stuff, but if its not correct its very close

local augroup = nil
local build_handler = {
  spec_field = "build",
  set_lazy = false,
  init = function() -- called when you register the handler
    augroup = vim.api.nvim_create_augroup("lze_build_handler", { clear = true })
  end,
  cleanup = function() -- called if you deregister the handler (you probably wont)
    if augroup then
      vim.api.nvim_del_augroup_by_id(augroup)
    end
  end,
  add = function(plugin) -- called for every plugin (you cannot modify the plugin here)
    if type(plugin.build) == "function" then
      local build = plugin.build
      vim.api.nvim_create_autocmd('PackChanged', {
        -- pattern gets the path. Which will end with the plugin's name. (maybe with a / at the end? IDK but probably not?)
        pattern = "*/" .. plugin.name, -- I think this is how to match for that, but it is at least close.
        group = augroup, -- <-- lets us remove all of them if we deregister this handler (you probably won't)
        -- once = true, -- <-- if you want it to only trigger once (you probably dont?)
        callback = function(ev)
          local kind = ev.data.kind
          if (kind == 'install' or kind == 'update') then
            build(ev)
          end
        end,
      })
    end
  end,
}
require('lze').register_handlers(build_handler)

-- and now you can use `build = function`

require('lze').load {
  'nvim-treesitter',
  build = function(ev)
    vim.notify("nvim-treesitter updated/installed; running `:TSUpdate`", vim.log.levels.INFO)
    vim.cmd('TSUpdate')
  end,
}

[BirdeeHub]

What might be interesting actually....

If someone wanted to make some sort of add-on plugin for this kinda like I have with lzextras but focused on adding integrations with the built in plugin manager...

Is you could actually make a handler which triggers the SPEC on this PackChanged thing? Rather than just a hook? That is, after all, how the other handlers work.

Im not sure the best way to optimally handle that, but it could allow for some nice automatic interaction between startup plugins and the built in plugin manager maybe?

IDK. Could be cool, not really sure what form it should take and I use nix for this stuff anyway so I am not really the one to handle that, I'm just going to keep ensuring what I have already here in the lze plugin works so that it can be a solid base for people to use for whatever purpose they wish.

But that would also definitely be out of the scope of your question. So, food for thought I guess.

[BirdeeHub]

urls? This should work? IDK?

I think you might have to register it after the build one though, if that is the case, put the vim.pack.add call into a function instead and return it, it will be called later.

Maybe I add some kind of ability to specify dependent ordering for the handlers? like, after = { "some", "field", "names" } and before or whatever? They already accept a spec form with enabled and handler, that could probably be added with minimal impact. But we can work around it here regardless.

require('lze').register_handlers {
  {
    -- for nix-wrapper-modules#neovim users who only want this when not on nix
    -- enabled = vim.g.nix_info_plugin_name == nil,
    handler = {
      spec_field = "url",
      set_lazy = false,
      add = function(plugin)
        if plugin.url then -- or you could check if not nix here too but then it still runs the function
          vim.pack.add({ { src = plugin.url, name = plugin.name } }, { load = function() end, confirm = false, })
        end
      end,
    }
  }
}

or

require('lze').register_handlers {
  {
    -- for nix-wrapper-modules#neovim users who only want this when not on nix
    -- enabled = vim.g.nix_info_plugin_name == nil,
    handler = {
      spec_field = "url",
      set_lazy = false,
      add = function(plugin)
        if plugin.url then
          return function() -- you might need to do this to delay it
            -- if it turns out it needs to be registered after the build handler.
            -- or vim.schedule would work too probably but this we know for sure when it is called.
            vim.pack.add({ { src = plugin.url, name = plugin.name } }, { load = function() end, confirm = false, })
          end
        end
      end,
    }
  }
}

[n-prat]

Interesting.

Can't really test b/c I have "unlazyfi-ed" my config are am now using pure vim.pack.

But I guess your initial will not be adding a built-in handler for this was the right angle: this is not really lze responsibility.

That being said, I would still advise putting a new entry for build = as a lazy.nvim equivalent in the README to help steer newcomers toward PackChanged [and/or another option cf above if you prefer].

[BirdeeHub]

Yeah I am not entirely sure what to do with these.

I would need to test them out first, but maybe one day I throw them in lzextras. Im not super sure.

a build field doesn't make sense in the main lze repo, due to it intentionally being agnostic to choice of downloader/builder.

But in the lzextras repo, if you don't use something, it never gets required at all? It is kinda just a random bag of functions that help with various lze things.

A build handler might make more sense added there as opposed to here, and people could register it if they wanted it.

I added the url handler above to this conversation because someone asked a relevant question, I linked them here, and realized I had nothing for urls here

I have a lot of stuff to do for my nix-wrapper-modules repo, so this build and url handler things are somewhat low on my priority list at the moment, I personally use nix for all that stuff, but these are definitely on my "eventually" to do list, and if I were to add them, they would be in lzextras and not this repo.

But, regardless, as far as the question is concerned, something like the above 2 handlers would work for those things XD