Come si fa a uscire vimdiff modalità di vim, in particolare, per il Fuggitivo?

Sto usando vim con il latitante estensione. Ha un :Gdiff comando che ti porta in vimdiff modalità, ma che cosa è il diritto/per chiudere rapidamente/quit vimdiff modalità?

I. e., diciamo che sto editando il file FooBar.txt sotto il repository Git. Accendo :Gdiff, rivedere le mie modifiche in vimdiff, e poi voglio tornare indietro e continuare a modificare FooBar.txt o qualsiasi altro tipo di file 🙂

AGGIORNARE 1: ho intenzione di dare a questi quick combo una prova la prossima giornata di lavoro 🙂

"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: il Mio attuale mapping (chiude diff finestra solo!!!)

"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

Inoltre, si prega di aiutarmi a decidere se le seguenti dovrebbe essere una risposta: https://stackoverflow.com/a/15975201/275980

  • gDPer me funziona senza :diffoff!<cr>.
  • Concentrandosi solo sulla diff finestra e :q chiusura sembra fare il trucco. Sarebbe bello se ci fosse un modo semplice per farlo da una finestra, però.
  • Sembra che la maggior parte se non tutte le risposte sono Latitante-plugin-specifici, e funzionano solo parzialmente con una più semplice configurazione di Vim.
InformationsquelleAutor wik | 2010-04-24

 

15 Replies
  1. 46

    È possibile eseguire windo set nodiff noscrollbind e quindi chiudere la seconda finestra.

    Aggiornamento: c’è un diffoff comando. Utilizzare windo diffoff, non quello che ho scritto nella riga precedente.

    • anche :diffoff! fare lo stesso, giusto? Ero puntato a questo comando da Tony M. da vim_use gruppo.
    • Non chiudere la finestra che è stata aperta da :Gdiff, non è vero?
    • Sì, non. Io non uso il fuggitivo, ma la modalità diff creato con VCSVimDiff (VCSCommand plugin) è sostituita con una non-modalità diff (che era attiva prima VCSVimDiff was run) if you run :bw` il secondo tampone. È molto comodo, ma è VCSCommand plugin propria caratteristica, non qualcosa che vim fornisce out of the box. È possibile creare un autocommand con funzionalità simili nel tuo vimrc, se si desidera.
    • Che cosa non funziona? diffoff disabilita vimdiff modalità non importa il plug-in che l’ha lanciato.
    • Non chiudere le finestre e di ottenere il l’utente di nuovo a dove erano prima di digitare Gdiff, @jtriley la risposta che fa. Questo è ciò che la domanda originale voleva: “e poi voglio tornare indietro e continuare a modificare FooBar.txt”
    • quello che personalmente mi piace di meno di <C-W><C-O> è che chiude tutte le finestre, tra cui git status finestra, che è utile quando si fa qualche indagine più profonda, cioè c’è <S-D> mappa in git finestra di stato che, aprendo la modalità diff sul file evidenziato

  2. 38

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

    Chiudere la finestra. Il modo più semplice per fare questo, se non l’hai spostato il focus è <C-W><C-O>, che significa “rendere questa Finestra e la finestra.”

    • IMHO questa dovrebbe essere la Risposta scelta
    • Questo potrebbe causare problemi se si aveva più finestre aperte prima di entrare Gdiff, anche se-Gdiff solo aggiunge un buffer successivo a quello originale, senza chiudere tutti gli altri. Devi riaprire tutto il resto si stava lavorando.
    • il che non è utile quando si fa differenze dalla git finestra di stato, dal momento che la chiusura di tutte le finestre…
    • Gdiff apre un altro buffer (scheda) con una frazione di windows. Quindi, questo non funzionerà.
  3. 13

    Ho avuto fortuna con la diffoff, ma ho appena appreso che :Gedit con nessun argomento si tornerà al lavoro-directory versione del file, rispetto a qualche versione precedente si erano revisione.

    E come q (non c’è bisogno per :q) chiuderà la diff laterale, si può fare q seguita da :Gedit per sbarazzarsi della barra laterale e poi tornare indietro alla versione corrente del file.

    • q avvierà la registrazione. Quindi non sono sicuro di che tipo di ‘q’ che si sta utilizzando. Magari è una gui vim cosa o qualcosa del genere.
    • Alcuni plugin rimappare q, in un dato buffer (map <buffer> q ZZ o qualsiasi altra cosa), per chiudere buffer. Per me, che accade in il Fuggitivo git colpa “sidebar”. Non ricordo più se è anche utilizzato in qualsiasi diff vista.
    • Il comportamento di default di :Gedit può essere cambiato. Ora si provvederà a modificare il corespoding file di indice, invece dell’albero di lavoro file.
    • Questa risposta si propone innanzitutto di fare :q (o solo q) per chiudere la diff laterale.
  4. 4

    Questo funziona bene per me, che unisce alcune delle idee qui:

    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>
    
  5. 4

    Ho trovato una soluzione semplice per questo. Puoi controllare qui: 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
    
    • Sto piacimento questo. Ex comandi FTW di nuovo. Penso che la userò questo
  6. 3

    Nessuna di queste soluzioni ha funzionato per me. Finito di fare questo, invece:

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

    • Appena capito questo: nnoremap g<C-q> ZZ:Gedit<CR> (vedi la mia domanda di oggi). Penso che sia un po ‘ meglio in quanto si evita di muoversi tra le finestre.
  7. 2

    Un’alternativa a <C-W><C-O>, se si dispone di più di windows, sarebbe spostare l’altro diff finestra e fare <C-W>c, che chiude con una sola finestra.

    Se si chiude il male diff finestra fare un :Gedit

    Fare attenzione a non confondere <C-W>c con <C-W><C-C>

    • Che è simile a quello che ho fatto io nel mio gD mapping: nnoremap <Leader>gD <c-w>h:bd<cr>
  8. 1

    questo è ciò che devo lasciare il vimdiff di windows dopo l’uso :Gdiff

    nnoremap gD :q!<CR> :Gedit!<CR>
    
    • Credo che questo si chiude il file vero e proprio e si finisce la modifica temporanea file diff, dove si finirà per perdere tutte le modifiche. Che se non si è mai spostato il cursore sopra a diff.
  9. 0

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

    Abbastanza diff modalità e chiudere gli altri diff windows. (Nota: latitante si auto elimina nascosto del buffer.)

  10. 0

    La mia funzione sia da diff finestra e la finestra del file. Ma probabilmente non gestire se stesso con più diff aperto. Per questo è necessario utilizzare fugitive#buffer(n).path() per la scansione e la partita.

    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
    

    Aggiungere un’associazione di tasti:

    nnoremap <silent> <leader>gD :Gdiffoff<CR>
    
  11. 0

    Un altro modo ancora. Quello che ho in fuggitivo.vim – prima di salvare qualche info (s:gitbufname) quando diff inizia:

    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
    

    e più tardi, quando lasciando il buffer interruttore finestra salvato buffer e ripristino:

    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
    ...
    
  12. 0

    Controllare il vimdiff commutazione tra diffthis e diffoff qui
    in questa pagina.

    Codice:

    nnoremap <silent> <Leader>df :call DiffToggle()<CR>
    
    function! DiffToggle()
        if &diff
            diffoff
        else
            diffthis
        endif
    :endfunction
    
  13. 0

    Metodo 1:

    • aprire un confronto da:

    :windo diffthis

    • chiudere:

    :windo diffoff

    Metodo 2:

    Vi consiglio di usare il comando più semplice: :q<CR>

    quando si vuole fare in fretta, aggiungere il mapping:

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

    e

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

    Funziona bene per me. Uscita vimdiff solo da ,q, perché, di norma, il cursore nel vecchio file.

  14. 0

    Era di utilizzare il codice riportato di seguito in base https://stackoverflow.com/a/15113951/10999673 :

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

    ma mi dava un errore “E93: più di una partita per …” in un modo 3 diff, così ho invece usato la risposta da https://stackoverflow.com/a/4867969/10999673 e, infine, di avere questo:

    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://')
    
    

    Ho appena modificato, copiato e incollato il codice nel mio .vimrc

  15. 0

    Esecuzione :Gwrite dopo la fusione, per la soddisfazione di chiudere gli altri due diff riquadri, oltre ad aggiornare la tabella cache per contrassegnare il file come fuse.

Lascia un commento