Jump to previous/next matching indentation point?

[superDuperCyberTechno]

It's fairly often that I need to refer to the current scope of my work. This could easily be traversed if Helix had a way to jump to where the current indentation is started/ended. Any further movement from this start/end-point would jump the cursor to the next indentation point.

Example:

1. Jumping to the previous matching indent point from logic4 will place the cursor at the starting character of indent2.
2. Repeating the last movement would place the cursor at the starting character of indent1.
3. Jumping to the next matching indent point from indent1 would jump the cursor to the starting character of outdent1.

indent1
    logic1
    logic2
    indent2
        logic3
        logic4
    outdent2
outdent1

[7ombie]

I was surprised that No. 3 wasn't supported already. Being able to jump from any of the first four characters of indent1 to the corresponding cell in outdent1 (and vice versa) would be especially useful.

Maybe we're seeing this working a little differently, but it seems like it would naturally work 'in four directions':

• <prefix> <up>: Jump to the first visible cell above.
• <prefix> <down>: Jump to the first visible cell below.
• <prefix> <left/out>: Jump to the start of the leading line above.
• <prefix> <right/in>: Jump to the start of the first child line below.

The first visible cell would be the first cell in the same column as the cursor that occurs after any indentation and before the end of the visible line. I'm not sure how to define the end though. Maybe the newline should be included, and possibly trailing whitespace??

The leading line would be the nearest line above that is indented less than the current line.

The first child line would be the first line beneath that is indented more than the current line (which may be the child of the current line or a lower sibling).

There's a case for only supporting a subset of the four I listed, either the first two, or the first three, just to keep things simple.

I don't like the nomenclature I've used here, but do think something like this would be very useful.

[kirawi]

This seems like a duplicate of #1810. Depending on the language, you could use the pre-existing textobjects or A-o to go up the tree-sitter AST.

[7ombie]

Hey, @kirawi. Hope you're well.

As I understand #1810, it only permits selecting blocks of equally indented lines. This issue is about moving (jumping) to another line, based on its relationship to the current line.

For the sake of simplicity and generality, the behavior is inferred from the indentation, but in practice (at a higher level), it allows you to do things like jump to the line that leads the current block (typically an if, while, for, class keyword or whatever). It also permits jumping up and down (staying in the same column), while ignoring lines that only contain leading whitespace (similar to the way new cursors skip over deadspace to the next proper line).

At a high level, it does a couple of different things, but it functions in terms of indentation, and at that level, makes sense as a single feature/proposal.

[7ombie]

Take this example code (only the indentation is important):

for n in numbers
    x = n * 2
    put x
put numbers

If your cursor is on Line 2 or Line 3 somewhere, then #1810 allows you to select Line 2 and Line 3 (because they're at the same level of indentation). This proposal allows you to jump to the start of Line 1 (because it's the leading line of the block that Line 2 and Line 3 belong to), and supports something like the opposite (jumping from Line 1 to the start of its first child (Line 2)). This proposal also allows you to jump from any of the first four columns on Line 1 to the corresponding column on Line 4 (because there's only leading-whitespace in-between), and the exact opposite.

It's like code as bullet-points.

[kirawi]

You can flip the head of the cursor and deselect to achieve that as well. The PR #1810 is resolved by also allows you to select the outer indentation. Or you could combine selecting the inner indentation with a single A-o if you really want to focus on only that block and not everything in the outer indentation. This could be further improved by adding more textobjects (e.g. control flow) and implementing "select textobjects" and "next/prev textobject" (there's a tracking issue for this). To jump to the outer column, you can use smart-tab if you're in insert mode to jump out of the scope as well.

Your additional suggestions are different from the premise of this issue.

No idea if this is fully making sense to you since I'm writing this while very tired.

[pascalkuthe]

Yeah I don't think indentstion based movement is useful compared to tree sitter (especiallyin language which are jot python where indentation is not semantically meaningful). Tree sitter also allows you to select the parent node which can already do want you want (especially if you flip the selection). You can also select the next/previous sibling

[superDuperCyberTechno]

1. How would I move the cursor to the first character in the parent indentation?
2. How would I move the cursor to the first character in the next sibling indentation?

[7ombie]

I think @kirawi accused me of adding stuff that wasn't part of the original proposal, which is probably true. I never meant to do that, and am sorry if that's made this issue more confusing. As I mentioned already, I was surprised that Helix lacked the ability to jump up and down like I described, and assumed (if so) someone would have opened an issue proposing it by now. I came to see, found this issue, which seemed close enough, so I added my two pennies. Sorry for the noise.

If we can implement stuff like this ourselves (in config.toml or with the scripting API, in the foreseeable), there's a lot less to be gained from supporting it directly. Still, the operations this proposal describes still seem useful (and unique).

[kirawi]

Don't worry, I wasn't accusing you of anything :P

I was trying to say that your suggestions could be contributed to the other issue instead, since I was focusing on the original focus of the issue being a duplicate.

[7ombie]

No worries. I understand. All the best, mate.

[7ombie]

No idea if this is fully making sense to you since I'm writing this while very tired.

You're all good. I appreciate your feedback.

[superDuperCyberTechno]

Alright, so I've been fiddling with it. Here's to macros that pretty much does what I intended here (working in 23.10):

[keys.normal]
"backspace" = ["move_line_up", "goto_line_end", "move_char_right", "expand_selection", "flip_selections", "goto_first_nonwhitespace"]
"ret" = ["move_line_down", "goto_line_end", "move_char_right", "expand_selection",  "goto_first_nonwhitespace"]

In normal mode, enter goes to next indentation, backspace goes to previous indentation.

I only tested this with PHP so far, so it might be borked for other languages...

[7ombie]

Nice! If we can implement the feature(s) in our configs (or using the scripting API in the future), there's no need for Helix to implement it directly.