Make indent guides indicate changing indentation earlier

[dmnd]

The current indent-guides lazily indicate when the indentation level changes. By "lazy", I mean that the indentation guides keep showing up until a line appears with different content. Example of lazy indentation guides:

Contrast this to eager indentation guides, which disappear as soon as they can:

Lazy indentation guides work well in curly-brace languages because there is content on the line to indicate when a block finishes. However, in CoffeeScript and Python, they don't work well because there is no closing brace, and we end up with confusing guides that don't seem to match up with blocks.

This issue is asking that Atom indentation guides are changed from lazy to eager. Another way of describing it is to change the indentation guides so that they end where the closing brace would be in a curly-brace language.

[izuzak]

we end up with confusing guides that don't seem to match up with blocks.

@dmnd While I see the difference between the two, I'm not sure I understand what exactly is confusing. Could you provide a smaller example and point out the confusing part (is there anything inconsistent in the current way indent guides are used)? Could also you provide a screenshot which shows how the situation is less confusing for a different language? That might be helpful in understanding the problem. Thanks!

[dmnd]

@izuzak sorry for the confusion and thanks for bearing with me as I attempt to explain this 😄

First consider Ruby

1. Indent guides only appear to the immediately left of every line in the block. E.g. for Foo there are guides on lines 2-8 because those are lines that are inside the class.
2. There's no "linkage" between the 2 classes, or between the methods in each class. Each indented block is visually distinguishable and separable. E.g. line 5 is blank and visually separates foo1 from foo2.

Now consider how the equivalent code looks in Python:

1. Indent lines continue beyond the end of a block. Foo now has guides not only from 2-6 (the body of the class), but also on lines 7-8 (which are not "part of" the class). If I moved the declaration of Bar down a few lines, there would be even more extraneous guides.
2. Guides connect methods to methods and classes to classes. This makes them more difficult to visually separate. To my eye, the connected indent guides almost give the appearance that foo2 is inside of foo1.

Why is this inconsistent? If Python had an end keyword, it would appear on line 7. Then there would be no indent guides on lines 7 and 8. In my opinion the indent guides should behave as if there were an invisible end keyword at the end of every block, just as in Ruby or curly-brace languages.

[Bengt]

IMHO there should not even be an indent guide at line 7 where the imaginary end would be. Since the empty lines between methods are convention, but not syntax, they can be removed and the code is still valid Python:

Here line 6 is part of class Bar and not of class Foo. Analogously, the empty last line 11 is part of nothing, not of class Bar, as an imaginary end of it would suggest and especially not of method bar2 as atom currently indicates.

[dmnd]

Agreed @Bengt.

(FWIW that was what I intended to communicate)

[izuzak]

@dmnd @Bengt Thanks for explaining, that's helpful. 👍

Also, I think that this would have been easier to explain if the screenshots were made with invisibles turned on. If I understand correctly, in the Python screenshot -- lines 7, 8, 15 and 16 don't have any whitespace in them, correct? However, it's possible to get the same indent guides by placing some whitespace characters on those lines. In that case, I think the indent guides should indeed be shown since the guides should be used to indicate indentation not language syntax. Does that sound right?

[dmnd]

@izuzak I created those screenshots by adding whitespace to control whether the guides show up or not, but that was just an easy way to do it. Thanks for bearing with me in the explanation 😄

As of now, this is how things behave:

• If lines 7 and 8 have whitespace, guides don't appear.
• If lines 7 and 8 have no whitespace, guides appear.

Are you proposing that those cases should be flipped? This seems consistent with indicating indentation:

• If lines 7 and 8 have whitespace, guides should appear.
• If lines 7 and 8 have no whitespace, guides should not appear.

As opposed to indicating language syntax:

• If lines 7 and 8 have whitespace, guides should not appear.
• If lines 7 and 8 have no whitespace, guides should not appear.

Personally I think indicating language syntax seems like it could be the ideal thing to do, but I don't know if that would scale to other languages, make things look strange when editing, or have other broad implications or complications.

Simply indicating indentation correctly is unquestionably an improvement on the current implementation, though.

[izuzak]

As of now, this is how things behave:

• If lines 7 and 8 have whitespace, guides don't appear.
• If lines 7 and 8 have no whitespace, guides appear.
  Are you proposing that those cases should be flipped?

I guess I was just noticing that the screenshot was ambiguous (as far as I can tell). For example, the screenshots below have identical guides, but notice that the invisible characters show that in one case there is indentation on lines 3 and 4, while in the other case those lines are empty.

With indentation:

Without indentation:

So, guides are currently not an exact indicator of indentation on empty lines. In other words, I'm a bit confused as well and I do think there are things to be improved here (e.g. line 11 in @Bengt's screenshot at least). 😄 I think these cases are valuable feedback for whoever decides to tackle this. Thanks for raising these questions. 👍

[warpkanal]

+1 for eager indent guides