add support for continuous hard wrap

[vlmutolo]

Continuous hard wrap

#2128 deals with hard-wrapping selected text, but ideally we'd have a way to hard-wrap as the user types. This makes for a much better experience when editing files with comments, hard-wrapped plaintext documentation, etc. All the same use cases we listed for the reflow command.

In terms of implementation, I think we could actually just basically do "reflow" on every key press (while in input mode with this feature enabled). It probably shouldn't be exactly the same, since the reflow command optimizes the paragraph globally to produce consistent line lengths close to the maximum, and it would be kind of a weird experience to have the lines reflow back and forth while you're typing. So we'd want to use the "greedy" mode from textwrap for the wrapping instead of their "optimal" mode.

In terms of performance, we'd only be reflowing one paragraph at a time, and that really shouldn't be too expensive. I'd propose as a first cut doing reflow (almost) exactly as we do it now, but on every key press. Then, as I mentioned in a comment on 136, if we wanted more performance we could try to send a patch upstream to the textwrap crate for an "incremental" wrap command that would work off of a delta and produce maybe an iterator of Cow<str> and regions that were changed.

[David-Else]

I have never used an editor with hard wrap as you type, I would have thought it would be the job of the editor to soft wrap as you type and hard wrap on save (if wanted). The hard wrapping should be handled by the LSP formatter as it would be different for every language?

[the-mikedavis]

There's the textwidth configuration from vim that does similar: https://vim.fandom.com/wiki/Automatic_word_wrapping

Automatically breaking a line (by putting the word that exceeds the line width on a new line) is the most minimal and straightforward approach to this IMO. Rebalancing lines seems treacherous: it may not be easy to tell what can or can't be broken. For paragraphs it's straightforward but not for programming languages in general. Plus it's easy to go select the last paragraph [p and reflow it :reflow if you want to have it be perfectly balanced.

I tend to agree with @David-Else that hard wrapping should be something you explicitly ask the editor to do for you (via a command or by saving). (Although I suppose if you found a way to robustly reflow all the time, that would be quite impressive and I might be convinced to change my mind.)

[vlmutolo]

@David-Else

The hard wrapping should be handled by the LSP formatter as it would be different for every language?

I was mostly thinking about prose, such as Markdown or git commit messages. I wouldn't want this applied to code. And it would definitely have to be enabled by the user.

@the-mikedavis

(Although I suppose if you found a way to robustly reflow all the time, that would be quite impressive and I might be convinced to change my mind.)

There are vim plugins that do this. I believe the one I'm thinking of is vim-pencil. The behavior was a little quirky, but I bet with the help of a robust library like textwrap we could do better.

vim-pencil handles the explicit opt-in auto-wrapping with something like :hardwrap 80 or :hardwrap toggle. It's just a mode that you can turn on or off.

[the-mikedavis]

Ah interesting, vim-pencil looks quite cool! I suppose it makes me wonder where it falls between plugin and core. On the one hand it seems pretty handy, on the other, it's a bit fancy/nuanced and I could see it being its own project. What do others think?

[sudormrfbin]

Hard-wrap as you type is wonderful for commit messages and markdown and general prose as @vlmutolo mentioned, and i think it won't be too hard to implement -- on every space character check the length of the line and if it's greater than the configured hard-wrap length, insert a newline.

[vlmutolo]

on every space character check the length of the line and if it's greater than the configured hard-wrap length, insert a newline.

I think this is also what @the-mikedavis suggested, and it's at the very least a good first-cut approach. We'd basically get to the level of what vanilla Vim does with git commit messages.

But the vim-pencil plugin takes it a step further and allows you to actually delete text and have the text after your delete reflow to fit the line. It does this just like a WYSIWYG editor would, and it's a significantly better experience, especially if you're writing a lot of prose.

Most people are probably more interested in use cases for programming, but it would be awesome if Helix also had these sorts of first-class features for regular plaintext prose. Dynamic soft and hard wrap are probably the two biggest missing pieces at the moment.

[mgeisler]

It probably shouldn't be exactly the same, since the reflow command optimizes the paragraph globally to produce consistent line lengths close to the maximum, and it would be kind of a weird experience to have the lines reflow back and forth while you're typing. So we'd want to use the "greedy" mode from textwrap for the wrapping instead of their "optimal" mode.

Yes, on-the-fly wrapping where old wrapping decisions are affected by new text is indeed a strange experience! 😄

In terms of performance, we'd only be reflowing one paragraph at a time, and that really shouldn't be too expensive.

If you haven't already seen it, you can clone https://github.com/mgeisler/textwrap/ and do

% cargo run --example interactive --release

to start a primitive interactive demo editor. It will show the time needed for every redraw and it re-wraps everything on every keystroke.

This will let you try out the weirdness of the optimal-fit wrapping mode. It looks like this in action:

[adsick]

I agree with @vlmutolo

Most people are probably more interested in use cases for programming, but it would be awesome if Helix also had these sorts of first-class features for regular plaintext prose. Dynamic soft and hard wrap are probably the two biggest missing pieces at the moment.

[pascalkuthe]

Once #5420 lands the softwrap logic there can be reused in apply_impl to hardwrap text instead of softwrap it

[filipdutescu]

I really miss this when writing commits, would be great to have it done, after @pascalkuthe's PR lands

[gamma-delta]

Hello, how is this going?

[pedrolucasp]

Gentle ping on this one.