Re: Nice in-word incremental history word searcher

[Bart Schaefer <schaefer@xxxxxxxxxxxxxxxx>]

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.