vimdiff: ¿Saltar a la siguiente diferencia dentro de la línea?

vimdiffEs muy útil para comparar archivos. Sin embargo, a menudo lo uso en archivos con líneas largas y relativamente pocas diferencias dentro de las líneas.

vimdiff resaltará correctamente las diferencias dentro de una línea (línea completa rosa, caracteres diferentes rojos). En estos casos, sería bueno poder saltar a la siguiente diferencia dentro de la línea .

Puede saltar a la "siguiente diferencia" ( ]c), pero esto saltará a la siguiente línea con una diferencia.

¿Hay alguna manera de pasar al siguiente carácter diferente dentro de la línea actual?

Veo dos soluciones:

1. tendría que probar el resaltado de sintaxis actual para saltar a la parte roja de la línea.
2. tendría que extraer la línea actual en ambos búferes y encontrar el primer carácter que difiere para colocar correctamente el cursor

Ambas soluciones deben ejecutarse después de] c, y requieren secuencias de comandos vim.

EDITAR: Aquí hay un primer borrador que parece funcionar:

nnoremap <expr> <silent> <F3>   (&diff ? "]c:call \<sid>NextDiff()\<cr>" : ":cn\<cr>")

function! s:GotoWinline(w_l)
  normal! H
  while winline() < a:w_l
    normal! j
  endwhile
  " todo: beware of cases where the window is too little
endfunction

" Better ]c, [c jump
function! s:NextDiff()
  if ! &diffopt =~ 'filler' | return | endif

  let ignore_blanks = &diffopt =~ 'iwhite'

  " Assert: called just after a ]c or a [c
  " Forces the cursos to be synchronized in all synced windows
  " let diff_l = line()
  try 
    let foldenable = &foldenable
    set nofoldenable

    let w_l = winline() " problematic with enabled lines (from diff...)
    " echomsg w_l.'|'.line('.').'|'.getline('.')

    let lines = {}
    windo if &diff | call <sid>GotoWinline(w_l) | let lines[winnr()]={'text':getline('.'), 'number':line('.')} | endif
  finally
    let &foldenable = foldenable
  endtry

  " echomsg string(lines)
  if len(lines) < 2 | return | endif

  let indices = repeat([0], len(lines))
  let tLines = values(lines)
  let found = 0
  " infinite loop on two empty texts...
  while ! found
    let c = ''
    let next_idx = []
    let i = 0
    while i != len(indices)
      let crt_line = tLines[i].text
      let n = indices[i]
      if len(crt_line) == n
    let found = 1
    break
      endif

      let c2 = (len(crt_line) == n) ? 'EOL' : crt_line[n]
      if empty(c) 
    let c = c2
      endif

      " checks match
      let n += 1
      if c =~ '\s'
    if (c2 != c) && (ignore_blanks && c2 !~ '\s')
      let found = 1
      break
    else " advance
      while ignore_blanks && (n == len(crt_line) || crt_line[n] =~ '\s')
        let n += 1
      endwhile
    endif
      else
    if c2 != c
      let found = 1
      break
    endif
      endif
      let next_idx += [n]

      let i += 1
    endwhile
    if found | break | endif

    let indices = next_idx
  endwhile

  " now goto the right column
  let windows = keys(lines)
  " Assert len(windows) == len(indices)
  let w = 0
  while w != len(windows)
    " echomsg 'W#'.windows[w].' -> :'(tLines[w].number).'normal! '.(indices[w]+1).'|'
    exe windows[w].'wincmd w'
    silent! exe (tLines[w].number).'normal! 0'.(indices[w]).'l'
    let w += 1
  endwhile
  " echomsg string(indices)
endfunction

Esta es una solución fácil:

Puedes usar set wrap.

Esto creará problemas si la diferencia hace que el texto se ajuste en un número desigual de líneas.

No puedo entender cómo hacer esto vimdifftampoco, pero puedes echarle un vistazo en su wdifflugar. Muestra las diferencias entre dos archivos, una palabra a la vez.

Tuve que compilarlo desde la fuente:

curl http://ftp.gnu.org/gnu/wdiff/wdiff-1.2.1.tar.gz > wdiff-1.2.1.tar.gz
tar -xzvf wdiff-1.2.1.tar.gz
cd wdiff-1.2.1
./configure
make
make install

A juzgar por la documentación, no se puede hacer.