web-dev-qa-db-fra.com

Comment quittez-vous le mode vimdiff dans vim, en particulier pour Fugitive?

J'utilise vim avec l'extension fugitive . Il a une commande: Gdiff qui vous amène en mode vimdiff, mais quel est le bon moyen/rapide de fermer/quitter le mode vimdiff?

C'est-à-dire que je suis en train d'éditer le fichier FooBar.txt dans le référentiel Git. Je me lance: Gdiff, passe en revue mes modifications dans vimdiff, puis je veux revenir en arrière et continuer à modifier FooBar.txt ou tout autre fichier :)

UPDATE1: Je vais essayer ces combos rapides le jour ouvrable suivant :) 

"vimdiff current vs git head (fugitive extension)
nnoremap <Leader>Gd :Gdiff<cr> 
"switch back to current file and closes fugitive buffer
nnoremap <Leader>Gd :diffoff!<cr><c-w>h:bd<cr>

UPDATE2: Mes mappages actuels (ferme uniquement la fenêtre diff!)

"vimdiff current vs git head (fugitive extension)
nnoremap <Leader>Gd :Gdiff<cr> 
"switch back to current file and closes fugitive buffer
nnoremap <Leader>Gd <c-w>h<c-w>c

Veuillez également m'aider à décider si les éléments suivants doivent être pris en compte: https://stackoverflow.com/a/15975201/275980

vimvimdiffvim-fugitive
54
wik

Vous pouvez exécuter windo set nodiff noscrollbind puis fermer la deuxième fenêtre.

Mise à jour: il existe une commande diffoff. Utilisez windo diffoff, pas ce que j'ai écrit à la ligne précédente.

39
ZyX

Selon: https://github.com/tpope/vim-fugitive/issues/36

Fermez l'autre fenêtre. Le moyen le plus simple de le faire si vous n’avez pas déplacé le focus sur celui-ci est <C-W><C-O>, ce qui signifie "faire de cette fenêtre la fenêtre unique".

35
jtriley

Je n'ai pas eu de chance avec diffoff, mais je viens d'apprendre que :Gedit sans argument vous ramènera à la version du répertoire de travail du fichier, par opposition à une version antérieure que vous examiniez.

Et comme q (pas besoin de :q) ferme la barre latérale diff, vous pouvez faire q suivi de :Gedit pour supprimer la barre latérale, puis revenir à la version actuelle du fichier.

12
Henrik N

Cela fonctionne bien pour moi, combinant certaines des idées existantes ici:

function! MyCloseDiff()
  if (&diff == 0 || getbufvar('#', '&diff') == 0)
        \ && (bufname('%') !~ '^fugitive:' && bufname('#') !~ '^fugitive:')
    echom "Not in diff view."
    return
  endif

  " close current buffer if alternate is not fugitive but current one is
  if bufname('#') !~ '^fugitive:' && bufname('%') =~ '^fugitive:'
    if bufwinnr("#") == -1
      b #
      bd #
    else
      bd
    endif
  else
    bd #
  endif
endfunction
nnoremap <Leader>Gd :call MyCloseDiff()<cr>
4
blueyed

J'ai trouvé une solution simple pour cela. Vous pouvez le vérifier ici: https://Gist.github.com/radmen/5048080

" Simple way to turn off Gdiff splitscreen
" works only when diff buffer is focused
if !exists(":Gdiffoff")
  command Gdiffoff diffoff | q | Gedit
endif
4
radmen

Aucune des solutions ci-dessus n'a fonctionné pour moi. A fini par faire ceci à la place:

nnoremap <Leader>D :Gedit<CR><C-w>h :q<CR><C-w>k

3
Jens Norrgrann

Une alternative à <C-W><C-O>, si vous avez plusieurs fenêtres, serait de passer à l’autre fenêtre diff et de faire <C-W>c, qui ne ferme qu’une fenêtre.

Si vous fermez la mauvaise fenêtre de diff, faites un :Gedit

Soyez prudent et ne confondez pas <C-W>c avec <C-W><C-C>

2
José Luis

c’est ce que je dois quitter les fenêtres vimdiff après avoir utilisé: Gdiff

nnoremap Gd :q!<CR> :Gedit!<CR>
1
Adolfo Abegg

Exécuter :Gwrite après avoir fusionné à votre satisfaction fermera les deux autres volets en plus de mettre à jour le cache git pour marquer le fichier comme étant fusionné.

0
Caleb

Encore une autre façon. Ce que j'ai dans fugitive.vim - Commencez par enregistrer quelques informations (s: gitbufname) lorsque diff démarre:

function! s:Diff(vert,...) abort
  call sy#toggle()
  let s:startcol = winwidth(0)
  let &columns=(winwidth(0) * 2 - 20)
...
    if getwinvar('#', '&diff')
      let s:gitbufname = bufname("%")
      wincmd p
      call feedkeys(winnr."\<C-W>w", 'n')
    endif
...
endfunction

et plus tard, lorsque vous quittez la fenêtre du commutateur de tampon vers le tampon sauvegardé et restaurez:

augroup fugitive_diff
autocmd!
autocmd BufWinLeave *
  \ if s:can_diffoff(+expand('<abuf>')) && s:diff_window_count() == 2 |
  \   if exists('s:gitbufname') && winnr() != bufwinnr(s:gitbufname) |
  \     let nr = bufnr("%") | exe bufwinnr(s:gitbufname).'wincmd w' | exe 'buf'.nr |
  \   endif |
  \   call s:diffoff_all(getbufvar(+expand('<abuf>'), 'git_dir')) |
  \   call sy#toggle() |
  \   call airline#load_theme() | call airline#update_statusline() |
  \   let &columns=s:startcol |
  \ endif
...
0
cc9cii

Utilisait le code ci-dessous basé sur https://stackoverflow.com/a/15113951/10999673 :

    if !exists(":Gdiffoff")
        command Gdiffoff bw! fugitive://*
    endif

mais cela m’a donné l’erreur "E93: plus d’une correspondance pour ..." dans un diff à 3 voies, j’ai donc utilisé la réponse de https://stackoverflow.com/a/4867969/10999673 et enfin avoir ceci:

function! GetBufferList()
    return filter(range(1,bufnr('$')), 'buflisted(v:val)')
endfunction

function! GetMatchingBuffers(pattern)
    return filter(GetBufferList(), 'bufname(v:val) =~ a:pattern')
endfunction

function! WipeMatchingBuffers(pattern)
    let l:matchList = GetMatchingBuffers(a:pattern)

    let l:count = len(l:matchList)
    if l:count < 1
        echo 'No buffers found matching pattern ' . a:pattern
        return
    endif

    if l:count == 1
        let l:suffix = ''
    else
        let l:suffix = 's'
    endif

    exec 'bw ' . join(l:matchList, ' ')

    echo 'Wiped ' . l:count . ' buffer' . l:suffix . '.'
endfunction

command! -nargs=1 Gdiffoff call WipeMatchingBuffers('fugitive://')

Je viens de peaufiner, copier et coller le code dans mon .vimrc

0
wisefool

Ma fonction fonctionnera à la fois depuis la fenêtre diff et la fenêtre fichier. Mais ne sera probablement pas gérer avec plusieurs diffs ouverts. Pour cela, vous devez utiliser fugitive#buffer(n).path() pour numériser et faire correspondre.

command! Gdiffoff call Gdiffoff()
function! Gdiffoff()
    let diffbufnr = bufnr('^fugitive:')
    if diffbufnr > -1 && &diff
        diffoff | q
        if bufnr('%') == diffbufnr | Gedit | endif
        setlocal nocursorbind
    else
        echo 'Error: Not in diff or file'
    endif
endfunction

Ajouter une liaison de clé:

nnoremap <silent> <leader>Gd :Gdiffoff<CR>
0
Rafi B.

Cochez la case vimdiff entre diffthis et diffoff ici sur cette page .

Le code:

nnoremap <silent> <Leader>df :call DiffToggle()<CR>

function! DiffToggle()
    if &diff
        diffoff
    else
        diffthis
    endif
:endfunction
0
aemonge

noremap <leader>do :diffoff \| windo if &diff \| hide \| endif<cr>

Mode Diff assez et ferme les autres fenêtres de diff. (Remarque: le fugitif supprimera automatiquement ses tampons cachés.)

0
Bohr

Méthode 1:

  • ouvrir une comparaison par:

:windo diffthis

  • fermez le par:

:windo diffoff

Méthode 2:

Je recommande simplement d'utiliser la commande la plus simple: :q<CR>

lorsque vous voulez le faire rapidement, ajoutez le mappage:

" Set mapleader
let mapleader = ","
let g:mapleader = ","

et

" Quickly close the current window
nnoremap <leader>q :q<CR>

Cela fonctionne bien pour moi. Quittez vimdiff simplement par ,q, car normalement votre curseur est dans l'ancien fichier.

0
jack guan