Rientro del codice con rientro errato

Mi piace la funzionalità di rientro intelligente di Vim, mi consente di creare blocchi di codice ben rientrati.

Copio / incollo regolarmente il codice nei buffer, ma quel codice è spesso mal formattato.

Quello che sarebbe l'ideale è "rielaborare" il codice attraverso il sistema di rientro intelligente.

E 'possibile una cosa del genere?

Ad esempio, come 'aggiusteresti' il seguente codice (un estratto da un blocco più grande - Non voglio riparare manualmente ogni riga ...):

    else 
                {
                        m[c] = 5;
                Finished = true;
std::cout<<"(ID,R,E)"<<"-->"<<"("<<g[c]<<","<<r[c]<<","<<E1 <<")"<< std::endl;
std::cout << "\n"<<"finish-->" << r[c] << "\t" <<"E1-->"<< E1 <<"\n" ;
                }
        }

Lo faccio in due modi.

Incolla rettificata

Innanzitutto, se il codice nel buffer è formattato, ma a un diverso livello di rientro, io uso ]pinvece di p, che incolla il codice così com'è, ma con il rientro spostato in modo tale che la prima riga incollata abbia la stessa profondità della riga I sono acceso

Origine EG copiata nel buffer

while (1) {
    dostuff();
}

Ad esempio, il risultato di incollarlo con ]p

int myfunc() {
    int i = 5; /* Cursor on this line before paste */
    while (1) {
        dostuff();
    }
 }

vim pone il tempo allo stesso livello di rientro di int i. Questo è veloce, ma funziona solo se il codice copiato è correttamente rientrato in se stesso.

Riformatta dopo incolla

L' =operatore in vim riformatta il codice in base alle regole di formattazione configurate. Per brevi frammenti di incolla, vado in modalità visiva con v, seleziono le linee che ho appena incollato e quindi premo =per riformattarle.

Per le paste più grandi, approfitto del fatto che il cursore si sposta sulla prima riga incollata e che vim dice qualcosa come "84 più righe". Posso quindi inserire 84==per ridisporre quelle 84 righe (ovviamente, sostituire 84 con il numero di righe effettivamente incollate).

Riferimenti

:help ]p per pasta di rientro corretta

:help =coperture ={motion}, [count]==e {Visual}=per filtrare attraverso personalizzato o incorporato regole rientro

Il =comando può essere usato per rientrare.

Come la maggior parte dei normali comandi in modalità, può essere applicato a un movimento, in modo da poter reinserire il codice appena incollato =']. Ciò si reindirizza dalla posizione corrente del cursore al ']segno, che è l'ultima riga dell'incolla.

= può essere utilizzato anche dalla modalità visiva.

Un altro comando utile è ]p, che incolla allo stesso livello di rientro della riga corrente. Questo può aiutare a incollare il testo correttamente rientrato, sebbene a una profondità di rientro diversa, in conformità con il testo circostante.

L'uso di =ap (mnemonic è 'formattare un paragrafo') avrà un tentativo vim di formattare automaticamente il paragrafo corrente.

Se si desidera prestare particolare attenzione a ciò che si sta potenzialmente riformattando, è possibile trovare più sicuro e rapido utilizzare vapper selezionare visivamente il paragrafo corrente (fornendo un'indicazione visiva di ciò che viene riformattato), seguito da =. Lo trovo utile nei file in cui so che vim si riformatterà in modo errato e non voglio formattare erroneamente altre righe.

Per rientrare in un file già presente nel buffer, utilizzare gg=G: Vedere Correzione del rientro

Per rientrare in una parte di un file, è possibile applicare vari limiti al =filtro (ad esempio, ==corregge solo la riga corrente).

Per mantenere invariato il rientro quando si incolla il testo :set pasteprima di incollarlo nel buffer, ciò impedirà a vim di rientrare automaticamente nel testo appena incollato. Dopo aver incollato le cose, puoi tornare indietro usando set :nopastequando hai finito. Vedi vimdoc qui .

Se ti ritrovi a incollare roba frequentemente, sarebbe una buona idea usare questo suggerimento su VimWiki e impostare un tasto per attivare / disattivare la modalità "incolla" aggiungendo queste righe al tuo .vimrc:

nnoremap <F2> :set invpaste paste?<CR>
set pastetoggle=<F2>
set showmode

Puoi quindi <F2>premere per attivare / disattivare la modalità incolla. vim mostrerà le parole "PASTE" nella riga di stato quando la modalità incolla è attiva.

Per rientrare di nuovo automaticamente l'intero blocco di un blocco tra parentesi graffe o tra parentesi, posizionare il cursore sulla stessa riga in cui è presente una parentesi e provare =%. Per modificare la larghezza del turno, utilizzare ad es :set sw=2.

Se questo non funziona come previsto, per ridurre il rientro manualmente ( obsoleto ), provare <%e ripetere con .(se necessario). Utilizzare >%per l'opposto.

Così:

else
       {
         // some code
       }

diventa:

else
{
  // some code
}

Per un codice specifico, per rientrare automaticamente in rientro una o più righe, prova:

• == per rientrare nella riga corrente
• 5== per rientrare di nuovo 5 righe

Per aumentare / ridurre il rientro manualmente per una o più righe, provare:

• << per rientrare nella riga corrente di spazi di shiftwidth
• 5<< per indentare 5 linee di spazi di larghezza di spostamento
• >> per rientrare nella riga corrente di spazi di shiftwidth
• 5>> per indentare 5 righe per spazi di shiftwidth
• . ripetere se necessario

È inoltre possibile eseguire il rientro in modalità visiva ( v) selezionando il testo e premendo =(rientro automatico), <(rientro) o >(rientro).

Un altro trucco è quello di corretta indentazione di tutto il file: gg=G.

Se hai schede invece di spazi, usa: :retabche sostituirà tutte le schede con spazi (Vedi: Come sostituire le schede con spazi? ).

Per metodi esterni, puoi provare:

• pythonTidy per riformattare il codice Python, ad esempio:

  :%!pythonTidy
  

Relazionato:

• Rientra rapidamente più righe in vi su stackoverflow SE
• Come riformattare un file sorgente per passare da 2 rientri di spazio a 3? su stackoverflow
• Rientro e allineamento di Vim: combinazione di spazi e tab su stackoverflow

Di recente ho installato vim-pasta ( https://github.com/sickill/vim-pasta ) e questo sembra migliorare il rientro del codice quando incollo. Il README ha anche alcune buone discussioni sulle varie strategie di incollaggio del codice.

Ci sono già molte cose coperte nelle risposte esistenti. Mi piace solo aggiungere una mappatura che uso molto spesso per il rientro.

nnoremap <Leader>i  mzgg=G`z

Ho visto un po 'di vimrc con questo mappato su ===.

Ad ogni modo, questa è un'ottima mappatura da avere e la uso quasi sempre, specialmente quando incollo il codice copiato da qualche altra parte.

O meglio, inseriscilo in autocmdmodo che Vim lo indentasse appena prima di scrivere le modifiche sul disco.