Interested in forward-seeking and n/l indent textobjects (mini.indentscope)

[tuurep]

They may be pretty ambiguous/opinionated to define for the indent textobject, but what I would find extremely useful would be:

forward-seeking:

• if cursor is on an unindented part of the buffer, vii would jump to the next indented block
  • otherwise (cursor line is indented) work as usual

n/l:

• I think most useful would be to jump to the next block with the same indentation level with e.g. vini
• another option: go the next block that's indented further, which may be more intuitive and consistent

Illustration forward-seeking vii:

Questions:

Is it possible to implement a custom indent-textobject in the mini.ai module instead of the mini.indentscope module, or would it be better to either fork and start hacking on mini.indentscope or try to implement it all from the ground up?

[echasnovski]

Yes, implementing custom textobject for 'mini.ai' is pretty reasonable.

For the "next"/"last" case you describe I'd suggest going the route of textobject function that returns array of regions (similar to this example) where each region is a valid indent scope that is (in theory) allowed to be selected. The 'mini.ai' will then take care of the rest ([count], search direction, etc.).

For a more complicated behavior textobject function can return a single region which will be used/selected. This puts more burden on the implementation, but in return is more flexible.

You can also take a look at how LazyVim used to do something similar (prior to its move to 'snacks.scope', of course).

---

All in all, I don't think it will be added in 'mini.nvim' (either 'mini.ai' or 'mini.extra'). Not the last reason for this is that there are many different approaches this new textobject may take (including once described here) without obviously better one.

That said, if you do come up with something, please share your solution here. It might be a good candidate to be added later in the wiki.

[tuurep]

Thanks! I'll look at it as soon as I can

Doing it with mini.ai would also especially work for me because from the mini.indentscope module I only want the textobject (and maybe motion), but not the visualization part.

I'll update later.

[echasnovski]

because from the mini.indentscope module I only want the textobject (and maybe motion), but not the visualization part.

Just FYI, you can disable visualization either by setting a very large config.draw.delay (like 10000000) or config.draw.predicate = function() return false end.

[tuurep]

I was unsure how it should be done, my solution so far had been:

require("mini.indentscope").setup({
    options = { indent_at_cursor = false }
})
vim.g.miniindentscope_disable = true

until I had a thought: "hmm, why could this not forward-seek?" :)

Do you think the g:...disable way is a bad way to achieve it? I feel like I just randomly tried it, and since it worked, stuck with it.

[echasnovski]

It is indeed documented as disabling only the auto-draw part so not that bad. Just wasn't really intended for this to be set permanently.

[tuurep]

Oh, that's right. Thanks

[tuurep]

@echasnovski

Here's my initial attempt that works as if mini.indentscope was configured with:

• border = 'both'
• indent_at_cursor = false
• try_as_border = false

With n/l behavior:

I think most useful would be to jump to the next block with the same indentation level

Ended up quite dirty due to all the edge cases 😄 And probably what I'm doing here is rewriting a certain part of mini.indentscope.

local function get_line_indent(line)
    local prev_nonblank = vim.fn.prevnonblank(line)
    local res = vim.fn.indent(prev_nonblank)

    -- Compute indent of blank line
    if line ~= prev_nonblank then
        local next_indent = vim.fn.indent(vim.fn.nextnonblank(line))
        res = math.max(res, next_indent)
    end

    return res
end

local function ai_indent(ai_type)
    local res = {}

    local target_indent = math.max(
        get_line_indent(vim.fn.line(".")),
        1 -- If cursor is at an unindented part, target all top-level indents
    )

    local from_line, to_line
    local scoping = false
    local eob = vim.fn.line("$")

    for i = 1, eob, 1 do

        -- Find region end
        if scoping then
            local line = vim.fn.getline(i)

            if not line:match("^%s*$") and vim.fn.indent(i) < target_indent then

                to_line = i

                if ai_type == "a" then
                    from_line = math.max(from_line - 1, 1)
                else
                    to_line = to_line - 1
                end

                local region = {
                    from = { line = from_line, col = 1 },
                    to = { line = to_line, col = vim.fn.col({ to_line, "$" }) },
                    vis_mode = "V"
                }
                table.insert(res, region)
                scoping = false
            end

        -- Find region start
        else
            if get_line_indent(i) >= target_indent then
                from_line = i 
                scoping = true
            end
        end

        -- Last buffer line edge case
        if i == eob and scoping then
            if ai_type == "a" then
                from_line = math.max(from_line - 1, 1)
            end
            local region = {
                from = { line = from_line, col = 1 },
                to = { line = eob, col = vim.fn.col({ eob, "$" }) },
                vis_mode = "V"
            }
            table.insert(res, region)
        end

    end

    return res
end

-- To use:
require("mini.ai").setup({
    custom_textobjects = {
        ["i"] = ai_indent
    }
})

However, functionality feels quite complete, which is good!

Feedback welcome, I'd like to iterate on this.

[tuurep]

Wiki entry would be cool, probably needs some parameterization to achieve different combinations of mini.indentscope settings.

Also pls fix:

:)

[echasnovski]

A more curated wiki is more or less a distant goal. Right now I am adding labels to issues/discussions that are worth adding there.

[tuurep]

Should be noted: mini.extra has an indent textobject for ai that basically follows what I meant by:

n/l:
...

• another option: go the next block that's indented further

.. at least with normal mode operators

I find it hard to understand how exactly it's defined even with the docs, but mostly in the case where the cursor is on the leading blank part of an inner indent, where it targets an indent like this:

versus these:

So I was initially confused whether it should be a indent_at_cursor = false or indent_at_cursor = true -type indent (in mini.indentscope terms)

@echasnovski does it have a bug where the indents should extend the from_col to the first column, or is it indeed preferred to be that way? 😄

[echasnovski]

@echasnovski does it have a bug where the indents should extend the from_col to the first column, or is it indeed preferred to be that way? 😄

If it is for i textobject, then it selects scope charwise which doesn't include whitespace from either side of the region: indent from left and (at least) new-line from right. This is mostly to be able to cii and start typing right away at the first line's indent.

[tuurep]

Oh right, I noticed that it leaves the leading whitespace on the line, but didn't connect the dots that this also means that the 'left edge' is at that position.

Also nice for doing a grr on the indented blank line (although griI in the first place is better)

Another factor that confused me: the nvim defaults of autoindent and indentexpr already make cii behave really nice in regards to beginning to type on the right indent even if the whitespace would be stripped.