Set linewise mode for linewise yanks

[xPMo]

Currently, yanks in zsh do not preserve trailing newlines when sent to vim/nvim. Vim and Nvim will use linewise-puts if the text in the register ends with a newline. Zsh will use linewise-puts if the register contains "a sequence of lines" [sic] according to man zshzle.

[xPMo]

After looking at Zsh's source code, the variable responsible for keeping track of this is vilinerange, and it is not exposed to ZLE widgets. This may be impossible unless the Zsh devs choose to make that available.

[xPMo]

We may be able to partially track this ourselves by wrapping the visual-line-mode and vi-yank-whole-line widgets. Tracking this for vi-yank (yy) will be tricker.

[drowning-cat]

Like this?

evil-registers.zsh

LAST_VISUAL_MODE="char-wise"
LAST_VISUAL_MODE="line-wise"
LAST_VISUAL_MODE=

custom-visual-line-mode() {
  LAST_VISUAL_MODE="line-wise"
  zle .visual-line-mode
}
custom-visual-mode() {
  LAST_VISUAL_MODE="char-wise"
  zle .visual-mode
}
# !!! Does not cover the case when a line is selected and then y/c/d is pressed
custom-deactivate-region() {
  LAST_VISUAL_MODE=
  zle .deactivate-region
}

zle -N visual-line-mode custom-visual-line-mode
zle -N visual-mode custom-visual-mode
zle -N deactivate-region custom-deactivate-region

yank_add_newline() { # false [1], true[0]
  if [[ "$WIDGET" != "vi-yank" ]]; then
    return 1
  fi
  if [[ "$LAST_VISUAL_MODE" == "char-wise" ]]; then     # {visual}y
    return 1
  fi
  if [[ "$LAST_VISUAL_MODE" == "line-wise" ]]; then     # {Visual}y
    return 0
  fi
  # Should be called after →evil-registers::yank: zle .$WIDGET
  if [[ "$KEYS" == "j" ]] || [[ "$KEYS" == "k" ]]; then # y{motion}
    return 0
  fi
  if [[ "$KEYS" == "y" ]]; then	                        # yy
    return 0
  fi
  return 1                                              # other
}

functions/→evil-registers::yank

# How does handler take input?
case ${handler[1]:l} in
  -v) # $handler is a parameter name
    typeset -g $handler[2]=$CUTBUFFER
    ;;
  -*p*) # positional parameter
    (${handler:1} $CUTBUFFER &)
    ;;
  -*)  # stdin
    if yank_add_newline; then
      (${handler:1} <<< $CUTBUFFER &)
    else
      (print -rn $CUTBUFFER | ${handler:1} &)
    fi
    ;;
  '') # no handler
    ;;
  *)  # no flags, assume stdin with whole $handler
    if yank_add_newline; then
      ($handler <<< $CUTBUFFER &)
    else
      (print -rn $CUTBUFFER | $handler &)
    fi
    ;;
esac

[drowning-cat]

# A few more widgets
yank_add_newline() {
  [[ "$WIDGET" != "vi-yank" && "$WIDGET" != "vi-change" && "$WIDGET" != "vi-delete" ]] && return 1

  [[ "$LAST_VISUAL_MODE" == "char-wise" ]] && return 1
  [[ "$LAST_VISUAL_MODE" == "line-wise" ]] && return 0
  [[ "$KEYS" == "j" ]] || [[ "$KEYS" == "k" ]] && return 0
  [[ "$WIDGET" == "vi-yank"   ]] && [[ "$KEYS" == "y" ]] && return 0
  [[ "$WIDGET" == "vi-change" ]] && [[ "$KEYS" == "c" ]] && return 0
  [[ "$WIDGET" == "vi-delete" ]] && [[ "$KEYS" == "d" ]] && return 0
  return 1
}

[xPMo]

custom-visual-line-mode() {
  LAST_VISUAL_MODE="line-wise"
  zle .visual-line-mode
}
...
[[ "$LAST_VISUAL_MODE" == "char-wise" ]] && return 1
...

Yeah, pretty much what I was thinking. I'll write it as a single function which is bound to both widgets.

As for checking $KEYS, I don't believe this implementation works, since it exposes the keys that ::yank was invoked with, not the motion itself. I've had to work around some limitations wrt wrapping y/c/d using zle -U before, and it's definitely weird.

Also, if we're just checking keys, we're making assumptions on the user's keymap. Probably some safe assumptions, but assumptions nonetheless.

There's no parameter which works like ${widget_vicmd[y]}, instead all we can do is capture the output of bindkey -M vicmd to figure out what widgets the user has bound.

[drowning-cat]

1. Up and down motions can be tracked with:

VERTICAL_MOTION="down"
VERTICAL_MOTION="up"
VERTICAL_MOTION=

down-line() {
  VERTICAL_MOTION="down"
  zle .down-line
}

up-line() {
  VERTICAL_MOTION="up"
  zle .up-line
}

zle -N down-line
zle -N up-line

2. How to determine yy, cc, and dd?

vi-yank (unbound) (y) (unbound)

Read a movement command from the keyboard, and copy the region from the cursor position to the endpoint of the movement into the kill buffer. If the command is vi-yank, copy the current line.

I interpret this to mean that if the keys before and after the widget are the same, it will copy the string.

yank_add_newline() {
  local keys_before="$1"
  local keys="$2"

  [[ "$WIDGET" != "vi-yank" && "$WIDGET" != "vi-change" && "$WIDGET" != "vi-delete" ]] && return 1

  [[ "$LAST_VISUAL_MODE" == "char-wise" ]] && return 1
  [[ "$LAST_VISUAL_MODE" == "line-wise" ]] && return 0
  [[ -n "$VERTICAL_MOTION" ]] && return 0
  [[ "$keys_before" == "$keys" ]]  && return 0
  return 1
}

Note

A few variables should be cleared after widgets like vi-yank, vi-change, and vi-delete are called:

• VERTICAL_MOTION
• LAST_VISUAL_MODE

Warning

Will not work in case of double binding:

bindkey -M vicmd y vi-yank
bindkey -M vicmd n vi-yank

• yy
• nn
• yn

This can also be fixed by tracking the last yank widget.

P.S. The solution is far from ideal. I just shared my thoughts from the sidelines

P.P.S. I apologize if I am unable to help 😞