mini.ai: use different search_method for treesitter textobjects?

[Bvngee]

I apologize if this question has already been answered or explained elsewhere that I could not find.

In most cases, I think search_method = 'cover_or_next' is the best. However, when working with ai.gen_spec.treesitter() textobjects, I find that the "or_next" part gets annoying; that is, I want these specific textobjects to only match when my cursor is within their bounds (which I believe search_method = 'cover' does), for example to prevent jumping 30 line down when I do a cif. Is there a way of specifying search_method for different textobjects? (I don't see anything obvious here...)

PS. I absolutely love what you're doing with mini.nvim, thanks for the awesome work <3

[echasnovski]

I don't think this was answered before, so no need to apologize :)

Although not straightforward, there is a way to do this. The gen_spec.treesitter() function returns a callable (i.e. function) specification. This returned function has the same signature as find_textobject(), which in turn can be configured to use specific search method via opts.search_method.

So the solution here would be to wrap the output of gen_spec.treesitter() in own function which forces specific search method. Here is an example for "function definition" textobject:

local ai = require('mini.ai')
local spec_ts = ai.gen_spec.treesitter({ a = '@function.outer', i = '@function.inner' })
local spec_ts_cover = function(ai_type, id, opts)
  opts.search_method = 'cover'
  return spec_ts(ai_type, id, opts)
end
ai.setup({
  custom_textobjects = {
    F = spec_ts_cover,
  },
})

---

That said, my recommendation would be to use 'cover' method as the main one and explicitly use an / al / in / il variants if you want next/previous textobject.

[Bvngee]

I kinda thought it would be something like that :) thanks so much!

[Goose97]

Sorry for resurrect this thread. I want to achieve the same thing but for brackets ((, [, {). I want the bracket to always use the cover strategy. I tried to mimic your solution but it seems like the gen_spec.pair doesn't support that

      local spec_pair = require("mini.ai").gen_spec.pair
      local opts = {
        custom_textobjects = {
          [")"] = spec_pair("(", ")", { type = "balanced", search_method = "cover" }),
          ["("] = spec_pair("(", ")", { type = "balanced", search_method = "cover" })
        },
      }

      require("mini.ai").setup(opts)

One solution I can think of is to increase the size of n_lines to a sufficiently large number, like 100. I just want to know if there's any official solution before using it as the last resort.

Thanks for this module. I think the API is well thought-out and the documentation is superb.

[Goose97]

After digging around the source code a bit, I came up with a decent solution. Looks a bit cryptic

local spec_pair = require("mini.ai").gen_spec.pair
local opts = {
    custom_textobjects = {
    ["("] = function(ai_type, _, opts)
    -- Force the search method to always be "cover"
    opts.search_method = "cover"
    -- This will use the pattern supply by "_(" below
    return require("mini.ai").find_textobject(ai_type, "_(", opts)
  end,

  ["_("] = { "%b()", "^.().*().$" }
}

require("mini.ai").setup(opts)

[echasnovski]

Yes, this is one way of doing this.

Another approach is to create custom mappings for a( and i( in Visual and Operator-pending modes. With something like this:

local map_cover_parens = function(mode, ai_type, id)
  local opts = { search_method = 'cover', operator_pending = mode == 'o' }
  local rhs = function()
    opts.n_times = vim.v.count1
    MiniAi.select_textobject(ai_type, id, opts)
  end
  local desc = (ai_type == 'a' and 'Around' or 'Inside') .. ' covering ' .. vim.inspect(id)
  vim.keymap.set(mode, ai_type .. id, rhs, { desc = desc })
end

map_cover_parens('x', 'a', '(')
map_cover_parens('x', 'i', '(')
map_cover_parens('o', 'a', '(')
map_cover_parens('o', 'i', '(')

This is more verbose, but should be less cryptic.

---

Unfortunately, I don't see a better way of doing this. Maybe find_textobject() might be extended to accept specification directly as id argument.

But nevertheless, the main suggestion still stands: use 'cover' method as the main one and explicitly use an / al / in / il variants if you want next/previous textobject.

[Goose97]

Thanks for the response. I will adopt this since this is more align with the public API 👍