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" } },
}

Advanced: v:count jump

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

A pattern built from all words in vim.g.cycle_config is searched using search_method="cover_or_next". If a match is found, the corresponding cover pattern is searched using search_method="cover". This second search is needed because mini.ai selects the shortest cover match.

Code (version 1)

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 find_textobject = function(ai_type, spec, opts)
  opts = vim.tbl_extend("keep", opts or {}, { silent = true })
  local snap_config = vim.deepcopy(MiniAi.config)
  local tmp_id = "_"
  MiniAi.config = { custom_textobjects = { [tmp_id] = spec }, silent = opts.silent }
  local reg = MiniAi.find_textobject(ai_type, tmp_id, opts)
  MiniAi.config = snap_config
  return reg
end

local buf_get_text = function(reg)
  local from, to = reg.from, reg.to
  return vim.api.nvim_buf_get_text(0, from.line - 1, from.col - 1, to.line - 1, to.col, {})
end

local buf_set_text = function(reg, buf_text, follow)
  local from, to = reg.from, reg.to
  vim.api.nvim_buf_set_text(0, from.line - 1, from.col - 1, to.line - 1, to.col, buf_text)
  if follow then
    vim.api.nvim_win_set_cursor(0, { from.line, from.col - 1 })
  end
end

local function get_config()
  local config = {}
  vim.list_extend(config, vim.b.cycle_config or {})
  vim.list_extend(config, vim.g.cycle_config or {})
  for i, conf in ipairs(config) do
    conf = vim.tbl_extend("keep", conf, { words = {}, cycle = true, pat = "%f[%w]()%f[%W]" })
    conf._patterns = vim.tbl_map(function(word)
      local pat = conf.pat
      local word_pat, gc = pat:gsub("%(%)", word)
      return gc == 1 and word_pat or error(("[mini.cycle] Unable to substitute pattern: %s"):format(pat))
    end, conf.words)
    config[i] = conf
  end
  return config
end

local cycle_word = function()
  local config = get_config()
  local match_pattern = {}
  for _, conf in ipairs(config) do
    for i, word in ipairs(conf.words) do
      if word ~= "" then
        table.insert(match_pattern, conf._patterns[i])
      end
    end
  end
  local match_reg = find_textobject("a", { match_pattern }, {
    search_method = "cover_or_next",
    n_lines = 0,
    n_times = vim.v.count1,
  })
  if not match_reg then
    vim.notify("[mini.cycle] No matches found in the current line", vim.log.levels.WARN)
    return
  end
  local find_longest_cover = function(conf, ref_reg)
    local item_list = {}
    for i, word in ipairs(conf.words) do
      if word ~= "" then
        table.insert(item_list, { i = i, word = word, pat = conf._patterns[i] })
      end
    end
    table.sort(item_list, function(a, b)
      return #a.word >= #b.word
    end)
    for _, item in ipairs(item_list) do
      local cover_reg = find_textobject("a", { item.pat }, {
        search_method = "cover",
        n_lines = 0,
        n_times = 1,
        reference_region = { from = ref_reg },
      })
      if cover_reg then
        return cover_reg, item.i
      end
    end
  end
  local match_text = buf_get_text(match_reg)[1]
  for _, conf in ipairs(config) do
    if vim.list_contains(conf.words, match_text) then
      local cover_reg, i = find_longest_cover(conf, match_reg.from)
      if cover_reg then
        local next_index = conf.cycle and (i % #conf.words + 1) or math.min(i + 1, #conf.words)
        local next_word = conf.words[next_index]
        local cover_text = buf_get_text(cover_reg)[1]
        if next_word ~= cover_text then
          buf_set_text(cover_reg, { next_word }, true)
        end
        return
      end
    end
  end
end

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

Simple: v:count cycle

vim.g.cycle_config = {
  { words = { "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 find_textobject = function(ai_type, spec, opts)
  opts = vim.tbl_extend("keep", opts or {}, { silent = true })
  local snap_config = vim.deepcopy(MiniAi.config)
  local tmp_id = "_"
  MiniAi.config = { custom_textobjects = { [tmp_id] = spec }, silent = opts.silent }
  local reg = MiniAi.find_textobject(ai_type, tmp_id, opts)
  MiniAi.config = snap_config
  return reg
end

local get_pattern = function(word, pat)
  local word_pat, gc = pat:gsub("%(%)", word)
  return gc == 1 and word_pat or error(("[mini.cycle] Unable to substitute pattern: %s"):format(pat))
end

local set_text = function(reg, buf_text)
  local from, to = reg.from, reg.to
  local reg_text = vim.api.nvim_buf_get_text(0, from.line - 1, from.col - 1, to.line - 1, to.col, {})
  if not vim.deep_equal(buf_text, reg_text) then
    vim.api.nvim_buf_set_text(0, from.line - 1, from.col - 1, to.line - 1, to.col, buf_text)
  end
  vim.api.nvim_win_set_cursor(0, { from.line, from.col - 1 })
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 col = vim.api.nvim_win_get_cursor(0)[2] + 1
  local matches = {}
  for _, conf in ipairs(config) do
    conf = vim.tbl_extend("keep", conf, {
      words = {},
      cycle = true,
      pat = "%f[%w]()%f[%W]",
    })
    for i, word in ipairs(conf.words) do
      if word ~= "" then
        local reg = find_textobject("a", { get_pattern(word, conf.pat) }, {
          search_method = "cover_or_next",
          n_lines = 0,
          n_times = 1,
        })
        if reg and (conf.cycle or word ~= conf.words[#conf.words]) then
          table.insert(matches, { conf = conf, i = i, reg = reg })
        end
      end
    end
  end
  -- NOTE: Closest to the cursor
  table.sort(matches, function(a, b)
    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 = match.conf, match.i
  local next_index
  if vim.v.count ~= 0 then
    -- NOTE: No cycling, fixed value
    next_index = math.min(vim.v.count1, #conf.words)
  else
    next_index = conf.cycle and (i % #conf.words + 1) or math.min(i + 1, #conf.words)
  end
  local next_word = conf.words[next_index]
  set_text(match.reg, { next_word })
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.