Como re-recuar o código mal recuado

Eu gosto do recurso de recuo inteligente do Vim, ele permite criar blocos de código bem recuados.

Eu copio / colo regularmente o código nos buffers, mas esse código geralmente está mal formatado.

O que seria ideal é "reprocessar" o código através do sistema de indentação inteligente.

É possível uma coisa dessas?

Por exemplo, como você 'consertaria' o código a seguir (uma extração de um bloco maior - não quero consertar cada linha manualmente ...):

    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" ;
                }
        }

Eu faço isso de duas maneiras.

Colar ajustado recuo

Primeiro, se o código no buffer estiver formatado, mas em um nível diferente de recuo, eu uso em ]pvez de p, que cola o código como está, mas com o recuo alterado de modo que a primeira linha colada tenha a mesma profundidade que a linha I 'seg.

Origem do EG copiada para o buffer

while (1) {
    dostuff();
}

EG resultado de colá-lo com ]p

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

O vim coloca o tempo no mesmo nível de indentação que int i. Isso é rápido, mas só funciona se o código copiado estiver corretamente recuado dentro de si.

Reformatar após colar

O =operador no vim reformata o código com base nas regras de formatação configuradas. Para pequenos trechos de colagem, entrarei no modo visual v, selecione as linhas que acabei de colar e pressione =para reformatá-las.

Para pastas maiores, aproveito o fato de o cursor ir para a primeira linha colada e o vim dizer algo como "84 linhas a mais". Posso entrar 84==para refazer essas 84 linhas (é claro, substitua 84 pelo número de linhas que você realmente cola).

Referências

:help ]p para colar recuo ajustado

:help =tampas ={motion}, [count]==e {Visual}=para filtrar através personalizado ou builtin regras travessão

O =comando pode ser usado para reinserir.

Como a maioria dos comandos no modo normal, ele pode ser aplicado a um movimento, para que você possa reinserir o código colado com =']. Isso volta da posição atual do cursor para a ']marca, que é a última linha da pasta.

= também pode ser usado no modo visual.

Outro comando útil é o ]pque cola no mesmo nível de recuo da linha atual. Isso pode ajudar a colar o texto recuado corretamente, embora com uma profundidade de recuo diferente, de acordo com o texto ao redor.

O uso =ap (mnemônico é 'formatar um parágrafo') terá uma tentativa do vim de formatar automaticamente o parágrafo atual.

Se você deseja prestar muita atenção ao que está reformatando, talvez seja mais fácil e rápido usá-lo vappara selecionar visualmente o parágrafo atual (fornecendo uma indicação visual do que está sendo reformatado), seguido por =. Acho isso útil em arquivos nos quais sei que o vim será reformatado incorretamente e não quero formatar incorretamente outras linhas por engano.

Para reinserir um arquivo já no buffer, use gg=G: Consulte Corrigir recuo

Para reinserir uma parte de um arquivo, vários limites podem ser aplicados ao =filtro (por exemplo, ==corrige apenas a linha atual).

Para manter o recuo inalterado ao colar o texto :set pasteantes de colar o texto no buffer, isso impedirá o vim de recuar automaticamente o texto que você acabou de colar. Depois de colar as coisas, você pode voltar a usar set :nopastequando terminar. Veja o vimdoc aqui .

Se você estiver colando coisas com frequência, seria uma boa ideia usar esta dica no VimWiki e configurar uma chave para alternar no modo "colar" adicionando estas linhas ao seu .vimrc:

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

Você pode pressionar <F2>para alternar para o modo de colar. O vim mostrará as palavras "COLAR" na linha de status quando o modo colar estiver ativo.

Para re-recuar todo o bloco de um bloco entre colchetes ou colchetes automaticamente, coloque o cursor na mesma linha em que está um colchete e tente =%. Para alterar a largura do turno, use, por exemplo :set sw=2.

Se isso não funcionar como esperado, para diminuir o recuo manualmente ( ultrapassado ), tente <%e repita com .(se necessário). Use >%para o oposto.

Tão:

else
       {
         // some code
       }

torna-se:

else
{
  // some code
}

Para código específico, para re-recuar uma linha ou poucas linhas automaticamente, tente:

• == recuar a linha atual
• 5== re-recuar 5 linhas

Para aumentar / diminuir o avanço manualmente para uma linha ou poucas linhas, tente:

• << recuar a linha atual por espaços de largura de turno
• 5<< recuar 5 linhas por espaços de largura de turno
• >> recuar a linha atual por espaços de largura de turno
• 5>> recuar 5 linhas por espaços de deslocamento
• . repetir se necessário

Você também pode fazer o recuo no modo visual ( v) selecionando texto e pressionando =(recuo automático), <(recuo) ou >(recuo).

Outro truque é recuo correto de todo o arquivo por: gg=G.

Se você tiver guias em vez de espaços, use: o :retabque substituirá todas as guias por espaços (consulte: Como substituir guias por espaços? ).

Para métodos externos, você pode tentar:

• pythonTidy para reformatar o código Python, por exemplo:

  :%!pythonTidy
  

Palavras-chave:

• Recue várias linhas rapidamente no vi no stackoverflow SE
• Como reformatar um arquivo de origem para passar de 2 recuos de espaço para 3? no stackoverflow
• Recuo e alinhamento do vim: combinando espaços e tabulações no stackoverflow

Eu instalei recentemente o vim-pasta ( https://github.com/sickill/vim-pasta ), e isso parece melhorar a indentação do código ao colar. O README também tem uma boa discussão sobre várias estratégias de colagem de código.

Já existem muitas coisas abordadas nas respostas existentes. Eu apenas gosto de adicionar um mapeamento que eu uso com frequência para indentação.

nnoremap <Leader>i  mzgg=G`z

Eu vi alguns vimrc com isso mapeado para ===.

De qualquer forma, esse é um ótimo mapeamento e eu o uso quase sempre, principalmente quando colar o código copiado de outro lugar.

Ou, melhor ainda, coloque isso de autocmdforma que o Vim o indente antes de gravar as alterações no disco.