Cycle words powered by mini.ai

[drowning-cat]

Description

Simple word cycling similar to dial.nvim#constants.

|In programming, **true** and **false** ...

In programming, **|false** and **false** ...
                  ^ After `<Leader>c`

Configuration example:

vim.g.cycle_config = {
  { words = { "true", "false" } },
  { words = { "True", "False" }, pat = "%f[%u]()%f[%W]" },
  { words = { "left", "right" } },
  { words = { "and", "or" } },
  { words = { "get", "set" } },
  { words = { "&&", "||" }, pat = "" },
  { words = { "yes", "no", "maybe" } },
  { words = { "on", "off" } },
  { words = { "stylua: ignore start", "stylua: ignore end", "stylua: ignore" }, pat = "" },
  { words = { "start", "end" } },
}

Use v:count to jump

In programming, **true** and **|true** ...
                               ^ After `2<Leader>c`

Code (version 1)

I search a single pattern built from all words in vim.g.cycle_config using search_method="cover_or_next". If a match is found, I then find the corresponding cover pattern using search_method="cover". I need this second search because mini.ai always picks the shortest match when cover patterns overlap.

vim.g.cycle_config = {
  { words = { "true", "false" } },
  { words = { "True", "False" }, pat = "%f[%u]()%f[%W]" },
  { words = { "left", "right" } },
  { words = { "and", "or" } },
  { words = { "get", "set" } },
  { words = { "&&", "||" }, pat = "" },
  { words = { "yes", "no", "maybe" } },
  { words = { "on", "off" } },
  { words = { "stylua: ignore start", "stylua: ignore end", "stylua: ignore" }, pat = "" },
  { words = { "start", "end" } },
}

local call_with_config = function(fun, conf)
  local snap_conf = vim.deepcopy(MiniAi.config)
  MiniAi.config = conf
  local res = { fun() }
  MiniAi.config = snap_conf
  return unpack(res)
end

local find_textobject = function(ai_type, spec, opts)
  opts = vim.tbl_extend("keep", opts or {}, { silent = true })
  local tmp_id = "_"
  return call_with_config(function()
    return MiniAi.find_textobject(ai_type, tmp_id, opts)
  end, { silent = opts.silent, custom_textobjects = { [tmp_id] = spec } })
end

local get_pattern = function(pat_templ, word)
  pat_templ = pat_templ or "%f[%w]()%f[%W]"
  local pat, gc = string.gsub(pat_templ, "%(%)", word)
  return gc == 1 and pat or word
end

local cycle_word = function()
  local config = {}
  vim.list_extend(config, vim.b.cycle_config or {})
  vim.list_extend(config, vim.g.cycle_config or {})
  local jump_pattern = {}
  for _, conf in ipairs(config) do
    local word_list = conf.words
    for _, word in ipairs(word_list) do
      if word ~= "" then
        table.insert(jump_pattern, get_pattern(conf.pat, word))
      end
    end
  end
  local jump_reg = find_textobject("a", { jump_pattern }, {
    search_method = "cover_or_next",
    n_lines = 0,
    n_times = vim.v.count1,
  })
  if not jump_reg then
    vim.notify("[mini.cycle] No matches found in the current line", vim.log.levels.WARN)
    return
  end
  local jf, jt = jump_reg.from, jump_reg.to
  local reg_text = vim.api.nvim_buf_get_text(0, jf.line - 1, jf.col - 1, jt.line - 1, jt.col, {})[1]
  for _, conf in ipairs(config) do
    local word_list = conf.words
    if vim.list_contains(word_list, reg_text) then
      for i, word in ipairs(word_list) do
        local cover_reg = find_textobject("a", { get_pattern(conf.pat, word) }, {
          search_method = "cover",
          n_lines = 0,
          n_times = 1,
          reference_region = { from = jf },
        })
        if cover_reg then
          local next_word = word_list[i % #word_list + 1]
          local cf, ct = cover_reg.from, cover_reg.to
          vim.api.nvim_buf_set_text(0, cf.line - 1, cf.col - 1, ct.line - 1, ct.col, { next_word })
          vim.api.nvim_win_set_cursor(0, { cf.line, cf.col - 1 })
          return
        end
      end
    end
  end
  vim.notify(("[mini.cycle] No cycle word matches `%s`"):format(reg_text), vim.log.levels.ERROR)
end

vim.keymap.set("n", "<Leader>c", cycle_word, { desc = "Cycle" })

Use v:count to cycle

vim.g.cycle_config = {
  { words = { "yes", "no", "maybe" } },
}

|In programming, **yes**, **no**, **maybe** ...

In programming, **|maybe**, **no**, **maybe** ...
                  ^ After `2<Leader>c`

Code (version 2)

vim.g.cycle_config = {
  { words = { "true", "false" } },
  { words = { "True", "False" }, pat = "%f[%u]()%f[%W]" },
  { words = { "left", "right" } },
  { words = { "and", "or" } },
  { words = { "get", "set" } },
  { words = { "&&", "||" }, pat = "" },
  { words = { "yes", "no", "maybe" } },
  { words = { "on", "off" } },
  { words = { "stylua: ignore start", "stylua: ignore end", "stylua: ignore" }, pat = "" },
  { words = { "start", "end" } },
}

local call_with_config = function(fun, conf)
  local snap_conf = vim.deepcopy(MiniAi.config)
  MiniAi.config = conf
  local res = { fun() }
  MiniAi.config = snap_conf
  return unpack(res)
end

local find_textobject = function(ai_type, spec, opts)
  opts = vim.tbl_extend("keep", opts or {}, { silent = true })
  local tmp_id = "_"
  return call_with_config(function()
    return MiniAi.find_textobject(ai_type, tmp_id, opts)
  end, { silent = opts.silent, custom_textobjects = { [tmp_id] = spec } })
end

local cycle_word = function()
  local config = {}
  vim.list_extend(config, vim.b.cycle_config or {})
  vim.list_extend(config, vim.g.cycle_config or {})
  local matches = {}
  local col = vim.api.nvim_win_get_cursor(0)[2] + 1
  for _, conf in ipairs(config) do
    conf = vim.tbl_extend("keep", conf, {
      words = {},
      pat = "%f[%w]()%f[%W]",
      cycle = true,
    })
    local word_list, pat_templ, cycle = conf.words, conf.pat, conf.cycle
    for i, word in ipairs(word_list) do
      if word ~= "" then
        local pat, gc = pat_templ:gsub("%(%)", word)
        pat = gc == 1 and pat or word
        local reg = find_textobject("a", { pat }, {
          search_method = "cover_or_next",
          n_lines = 0,
          n_times = 1,
        })
        if reg and (cycle or word ~= word_list[#word_list]) then
          table.insert(matches, { conf = conf, i = i, reg = reg })
        end
      end
    end
  end
  table.sort(matches, function(a, b)
    -- NOTE: Proximity to cursor
    return math.abs(a.reg.from.col - col) < math.abs(b.reg.from.col - col)
  end)
  local match = matches[1]
  if not match then
    vim.notify("[mini.cycle] No matches found in the current line", vim.log.levels.WARN)
    return
  end
  local conf, i, from, to = match.conf, match.i, match.reg.from, match.reg.to
  local word_list, cycle = conf.words, conf.cycle
  local next_word
  if cycle then
    next_word = word_list[(i + vim.v.count1 - 1) % #word_list + 1]
  else
    next_word = word_list[math.min(i + vim.v.count1, #word_list)]
  end
  vim.api.nvim_buf_set_text(0, from.line - 1, from.col - 1, to.line - 1, to.col, { next_word })
  vim.api.nvim_win_set_cursor(0, { from.line, from.col - 1 })
end

vim.keymap.set("n", "<Leader>c", cycle_word, { desc = "Cycle" })

[echasnovski]

Thanks for sharing!

Judging by the used name, you know that this functionality is already planned for 'mini.nvim'. I have a general idea of the design in mind, but need to finish more "pressing" modules first. Probably will be named 'mini.switch', though.

As per the code. I didn't study it closely, but one thing caught my eye: I would suggest to not use multi-character string as textobject id in custom_textobjects. Those are meant and documented as a single character. If it works now - good, but there is no guarantee it will continue work.

[drowning-cat]

Yep, it's just a really cheap alternative while waiting for the real module. I changed tmp_id to _, and since the config will be restored later, so it's not a big deal if it overrides something.

One mini spoiler question: will the new module support treesitter in some way, or will it be pattern-only?

[echasnovski]

One small spoiler question: will the new module support treesitter in some way, or will it be pattern-only?

The current aspiration is for it to be at least flexible enough to handle tree-sitter regions. The main problem with it is that it would probably require custom queries, which is not great.

My long time reference for that module is "I want to be able to invert the if statement, however complex". Like if a and b and (c or d) then not just into if not (a and b and (c or d)) then (but even that is not bad), but into if (not a) or (not b) or (not c and not d) then. This might be too complex, though.