Nice in-word incremental history word searcher

Nice in-word incremental history word searcher

[Sebastian Gniazdowski]

Hello,
files `zew-process-buffer' and `zew-history-complete-word' here (or
use the whole project):

https://github.com/psprint/zsh-editing-workbench

Incrementally completes any word from history. Can do in-word search
when invoked with cursor in middle of word, or, after starting, if
user positions cursor in a middle of a word and does space - backspace
(to point the tool to that location in word):

https://asciinema.org/a/3qp58ufve1d64jgiu18vv0c4u

Best regards,
Sebastian Gniazdowski

Re: Nice in-word incremental history word searcher

[Bart Schaefer]

On Jan 20,  9:14pm, Sebastian Gniazdowski wrote:
} Subject: Nice in-word incremental history word searcher
}
} files `zew-process-buffer' and `zew-history-complete-word' here (or
} use the whole project):

So I glanced through zew-process-buffer and have a few questions/remarks.

    --- 8< --- snip --- 8< ---
19  local buf="$1"
20  local cursor="$CURSOR"
21  [ -n "$2" ] && cursor="$2"
22
23  ZEW_PB_WORDS=( "${(Z+n+)BUFFER}" )
    --- 8< --- snip --- 8< ---

You could replace lines 20 and 21 with

    local cursor="${2:-$CURSOR}"

Shouldn't line 23 say

    ZEW_PB_WORDS=( "${(Z+n+)buf}" )

??  And therefore why is line 19 not

    local buf="${1:-$BUFFER}"

??  Do you really intend to take words from the ZLE buffer and then use
them to analyze the string passed as "$1"?

This on line 72:

  [[ "$ZEW_PB_SELECTED_WORD" -eq "-1" && "$char_count" -gt "$cursor" ]]

Could be this:

  (( ZEW_PB_SELECTED_WORD == -1 && char_count > cursor ))

Similarly on line 77.

On line 81, this:

    char_count=char_count+"$#buf"

depends on the zsh semantics of assignment to an declared integer.  It
might be better to explicitly use math context:

    (( char_count = char_count + $#buf ))

That's it for process-buffer.  I also took a more superficial look at
zew-history-complete-word; two things to note, one minor, one more
important.

First, you used the old [ ... ] test everywhere instead of [[ ... ]].
Any particular reason?

Second, I think you've partly missed the point of custom keymaps.  I
imagine you copied the caps-lock example from the recursive-edit doc,
but there's actually a better way now (that example could be redone):

Instead of overriding self-insert et al. in the main keymap and then
restoring them, you can do the same thing as with the zhcw keymap:
Create (once) a copy of the main keymap, install your new bindings
for self-insert etc., in that copy, and then when you want to use the
new keymap, switch to it with "zle -K".

If you prefer the way you've done it, at least consider wrapping it
all in an "always" construct so you can't accidentally abort out of
it without restoring the main keymap.

Re: Nice in-word incremental history word searcher

[Bart Schaefer]

On Jan 20,  9:32pm, I wrote:
}
} Instead of overriding self-insert et al. in the main keymap and then
} restoring them, you can do the same thing as with the zhcw keymap:
} Create (once) a copy of the main keymap, install your new bindings
} for self-insert etc., in that copy, and then when you want to use the
} new keymap, switch to it with "zle -K".

Upon thinking about this a bit more ... this may be a better approach
but it's not necessarily an easier approach.  To do it this way you
have to find and rebind every keystroke that is linked to the widget
you intend to replace, rather than just aliasing the widget name.

That's not terribly difficult in Sebastian's function but it could
be ugly if there are a lot of such bindings to fiddle with.

Re: Nice in-word incremental history word searcher

[Sebastian Gniazdowski]

On 21 January 2016 at 06:32, Bart Schaefer <schaefer@brasslantern.com> wrote:
>     --- 8< --- snip --- 8< ---
> 19  local buf="$1"
> 20  local cursor="$CURSOR"
> 21  [ -n "$2" ] && cursor="$2"
> 22
> 23  ZEW_PB_WORDS=( "${(Z+n+)BUFFER}" )
>     --- 8< --- snip --- 8< ---
>
> You could replace lines 20 and 21 with
>
>     local cursor="${2:-$CURSOR}"

Thanks, done that

> Shouldn't line 23 say
>
>     ZEW_PB_WORDS=( "${(Z+n+)buf}" )
>
> ??

True, corrected that, thanks

> And therefore why is line 19 not
>
>     local buf="${1:-$BUFFER}"
>
> ??

Nice idea to have $1 and $2 all optional, done that

> This on line 72:
>
>   [[ "$ZEW_PB_SELECTED_WORD" -eq "-1" && "$char_count" -gt "$cursor" ]]
>
> Could be this:
>
>   (( ZEW_PB_SELECTED_WORD == -1 && char_count > cursor ))

Recently I started to introduce (( )) to conditional expressions,
could replace this to, but comments can nicely refer to "-gt", "-ge"
so I'll leave them as they are

> On line 81, this:
>
>     char_count=char_count+"$#buf"
>
> depends on the zsh semantics of assignment to an declared integer.  It
> might be better to explicitly use math context:
>
>     (( char_count = char_count + $#buf ))
>

I like utilizing integer declaration and then the semantics, rarely
use (( )), if I do then mostly as "integer i=$(( ))" when I need to
assign a value computed with use of parenthesis – "integer i=(a-b)*c"
will return error, doing "0+..." trick doesn't help (it helps when not
declaring but using already declared integer), so I do "integer i=$((
(a-b)*c )). Also, like the *SELECTED_WORD variable, I don't declare
globals as integers, so in such case if computation is needed I use ((
)). This makes some distinctions in code, allows to quickly
differentiate between integers and normal variables / globals. It's
not what I truly planned and I still experiment, but it rather works.

> First, you used the old [ ... ] test everywhere instead of [[ ... ]].
> Any particular reason?

Rather not, I just didn't want to depart from sh too much too fast. I
might switch to [[ ]] after year of testing what pitfalls [ ] can have
(and there are rather none), but on other hand, using [[ ]] only when
it's needed helps reading the code, user can expect simplicity in [ ]
and sophistication in [[ ]]. Is there a reason to always use [[ ?

> Second, I think you've partly missed the point of custom keymaps.  I
> imagine you copied the caps-lock example from the recursive-edit doc,
> but there's actually a better way now (that example could be redone):
>
> Instead of overriding self-insert et al. in the main keymap and then
> restoring them, you can do the same thing as with the zhcw keymap:
> Create (once) a copy of the main keymap, install your new bindings
> for self-insert etc., in that copy, and then when you want to use the
> new keymap, switch to it with "zle -K".

Saw your next email, seems that I could bind backspace and delete, and
leave self-insert as it is.

Best regards,
Sebastian Gniazdowski