@ -0,0 +1,8 @@ |
|||||||
|
+++ |
||||||
|
title = "My Books" |
||||||
|
template = "section-contentless.html" |
||||||
|
+++ |
||||||
|
|
||||||
|
## Portuguese/Português |
||||||
|
|
||||||
|
* [Uma Lição de Vim](uma-licao-de-vim) |
@ -0,0 +1,36 @@ |
|||||||
|
+++ |
||||||
|
title = "Introdução" |
||||||
|
|
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Esta é a parte em que eu explico porque eu escrevi tudo isso e cujo conteúdo |
||||||
|
não vai afetar em nada seu conhecimento de VIM ou a sua vida. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Em 2000 tive meu primeiro contato com programação em Linux e, como era de se |
||||||
|
esperar, o primeiro editor sugerido foi o "VIM". |
||||||
|
|
||||||
|
Foi WTF à primeira vista (e o clássico "Como é que eu fecho isso?"). |
||||||
|
|
||||||
|
![Ok, não é a mesma versão que eu usei a 8 anos atrás, mas a sensação é a mesma.](vim-zero.png) |
||||||
|
|
||||||
|
Depois de usar outros editores por algum tempo (*cough* FTE *cough*), finalmente |
||||||
|
decidi dar o braço a torcer e passei a usar VIM, continuo usando até hoje. Não |
||||||
|
que eu tenha usado somente VIM desde então, utilizei outros editores (TextMate, |
||||||
|
Sublime Text 2, Gedit) mas eu sempre sinto falta de alguma coisa nos outros |
||||||
|
editores que acabei de acostumando no VIM. E, ainda, VIM ainda é o editor que |
||||||
|
eu mais ouço "Cara, como é que tu fez isso?". |
||||||
|
|
||||||
|
Não que VIM seja um editor completo e perfeito. Existem coisas novas surgindo a |
||||||
|
todo momento que ninguém sequer imaginava quando VIM foi criado; existem coisas |
||||||
|
que pelas próprias limitações do editor, o VIM não faz. Para algumas dessas, |
||||||
|
existem plugins -- e eu vou falar de alguns interessantes mais pra frente -- e, |
||||||
|
infelizmente, para outras, não há nada que possa ser feito, a não ser saber que |
||||||
|
estas "faltas" existem e estar preparados para elas. |
||||||
|
|
||||||
|
E vejamos quantos "Cara, como é que tu fez isso?" vão aparecer até o final |
||||||
|
deste livro. |
||||||
|
|
||||||
|
{{ chapters(next_chapter_link="./01-modos", next_chapter_title="Modos") }} |
After Width: | Height: | Size: 29 KiB |
@ -0,0 +1,69 @@ |
|||||||
|
+++ |
||||||
|
title = "Modos" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Esta é a parte onde eu explico porque você não conseguia sair do VIM na |
||||||
|
primeira vez que tentou usá-lo. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Uma das primeiras coisas que é preciso entender sobre VIM é que ele é um editor |
||||||
|
modal. Enquanto outros editores abrem os arquivos diretamente em "modo de |
||||||
|
edição" (para começar a usar a nomenclatura que o VIM adota) -- permitindo que |
||||||
|
você possa, imediatamente, editar o texto --, o VIM entra em "modo normal" (que |
||||||
|
não é o modo "normal" dos outros editores). |
||||||
|
|
||||||
|
![Mas o que isso quer dizer?](whatdoesitmean1.jpg) |
||||||
|
|
||||||
|
O VIM tem 5 modos: |
||||||
|
|
||||||
|
## Modo Normal |
||||||
|
|
||||||
|
O modo Normal é o modo que o VIM entra normalmente. Neste modo, as teclas são |
||||||
|
traduzidas para comandos de alteração do texto. Na configuração padrão, os |
||||||
|
comandos sequer são apresentados. |
||||||
|
|
||||||
|
## Modo de Inserção |
||||||
|
|
||||||
|
O modo de Inserção é o modo que a maior parte dos outros editores funciona. |
||||||
|
Qualquer coisa editada irá aparecer/alterar o texto atual. |
||||||
|
|
||||||
|
## Modo Visual |
||||||
|
|
||||||
|
O modo Visual é semelhante ao selecionar texto com "shift" em outros |
||||||
|
editores[^1]. |
||||||
|
|
||||||
|
## Modo de Comando |
||||||
|
|
||||||
|
O modo de comando serve para ações que começam com ":" (comandos Ex), "/" e "?" |
||||||
|
(procura) e "|" (filtro). |
||||||
|
|
||||||
|
## Modo Ex |
||||||
|
|
||||||
|
Semelhante ao modo de comando depois de usar ":", mas permanece no modo Ex. |
||||||
|
|
||||||
|
Praticamente todos os modos são utilizados, de alguma forma ou de outra, com |
||||||
|
exceção do modo Ex. |
||||||
|
|
||||||
|
A pergunta que você deve estar se fazendo agora é: E daí? |
||||||
|
|
||||||
|
![Você, agora.](so-what.jpg) |
||||||
|
|
||||||
|
Existem algumas coisas interessantes que podem ser feitas com VIM que não podem |
||||||
|
ser facilmente replicadas em outros editores justamente pela existência destes |
||||||
|
modos de operação. Sim, inicialmente, o fato de não poder entrar no editor e |
||||||
|
sair adicionando código pode parecer frustante, mas a medida que você for |
||||||
|
aprendendo como utilizar cada modo, você verá que eles fazem sentido e que não |
||||||
|
é nenhum mistério ficar pulando de modo para modo. |
||||||
|
|
||||||
|
A verdadeira lição começa agora. |
||||||
|
|
||||||
|
{% note () %} |
||||||
|
Todas as imagens são copyright (C) seus respectivos donos. |
||||||
|
{% end %} |
||||||
|
|
||||||
|
[^1] Apenas a título de informação, praticamente tudo que pode ser feito em |
||||||
|
modo visual pode ser feito em modo normal. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./00-intro", prev_chapter_title="Introdução", next_chapter_link="./01-01-modo-normal", next_chapter_title="Modo Normal") }} |
After Width: | Height: | Size: 66 KiB |
After Width: | Height: | Size: 101 KiB |
After Width: | Height: | Size: 41 KiB |
@ -0,0 +1,85 @@ |
|||||||
|
+++ |
||||||
|
title = "Modo Normal" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Esta é a parte em que você ainda vai precisar de um arquivo pronto para ver |
||||||
|
as coisas funcionando. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
A apresentação mais clássica do modo normal são todas as demais explicações que |
||||||
|
você vai achar por aí que dizem que é preciso usar `h`, `j`, `k` e `l` para |
||||||
|
mover o cursor na tela. Tirando o fato que isso é uma balela sem tamanho e que |
||||||
|
o VIM suporta movimentação com as teclas direcionais e que você não precisa |
||||||
|
ficar pensando em mnemônicos como "j tem uma perna pra baixo, k tem uma perna |
||||||
|
pra cima" e outras absurdices, estes são comandos normais válidos: ao |
||||||
|
pressionar `k`, o cursor irá mover para a linha de cima, `j` moverá o cursor |
||||||
|
para a linha de baixo e assim por diante. |
||||||
|
|
||||||
|
Nem todos os comandos são acionados com apenas uma tecla. Alguns iniciam um |
||||||
|
comando, mas ficam esperando mais informações para saber o que fazer ou onde |
||||||
|
fazer. Assim, temos comandos que são de movimentação e outros de ação. |
||||||
|
|
||||||
|
## Comandos de Movimentação |
||||||
|
|
||||||
|
Comandos de movimentação são comandos que movem o cursor no texto. Como já |
||||||
|
vimos, `h`, `j`, `k` e `l` são comandos de movimentação. Além destes temos[^1]: |
||||||
|
|
||||||
|
### f[letra] |
||||||
|
|
||||||
|
Posiciona o cursor na próxima `[letra]` na linha. Se `[letra]` não existir, não |
||||||
|
move o cursor. Por exemplo, `fa` irá mover o cursor para o próximo "a" na |
||||||
|
linha. |
||||||
|
|
||||||
|
### F[letra] |
||||||
|
|
||||||
|
O mesmo que `f[letra]`, mas voltando na linha ao invés de ir pra frente. |
||||||
|
|
||||||
|
### t[letra] |
||||||
|
|
||||||
|
Posiciona o cursor uma posição antes de `[letra]` na linha. Praticamente o mesmo |
||||||
|
que `f[letra]`, mas uma posição antes. |
||||||
|
|
||||||
|
### T[letra] |
||||||
|
|
||||||
|
Assim como "F" faz o mesmo que "t", mas voltando na linha. |
||||||
|
|
||||||
|
### 0 |
||||||
|
|
||||||
|
Move o cursor para a coluna 0. |
||||||
|
|
||||||
|
### _ |
||||||
|
|
||||||
|
Move o cursor para a primeira letra que não seja espaço ou tabulação na linha. |
||||||
|
|
||||||
|
### $ |
||||||
|
|
||||||
|
Move o cursor para o final da linha. |
||||||
|
|
||||||
|
### % |
||||||
|
|
||||||
|
Move o cursor para o outro elemento do par (por exemplo, % quando cursor |
||||||
|
estiver sobre um "(" irá mover o cursor para o ")" correspondente). |
||||||
|
|
||||||
|
Até aqui eu acredito que você esteja pensando "nada que mude minha vida". Bom, |
||||||
|
então aqui vem a primeira grande dica: |
||||||
|
|
||||||
|
> Se você digitar um número antes de fazer um comando, VIM irá repetir o |
||||||
|
> comando quantas vezes o número indicar. |
||||||
|
|
||||||
|
![](Mind-Blown.jpg) |
||||||
|
|
||||||
|
Ok, talvez não tenha sido a revelação do século, mas isso quer dizer que se |
||||||
|
você digitar `3f.`, VIM irá mover o cursor para o terceiro ponto na linha atual. |
||||||
|
E isso também pode não parecer importante, mas daqui pra frente isso vai fazer |
||||||
|
sentido. |
||||||
|
|
||||||
|
{% note() %} |
||||||
|
Todas as imagens são copyright (C) seus respectivos donos. |
||||||
|
{% end %} |
||||||
|
|
||||||
|
[^1] De forma alguma, esta é uma lista completa de todos os comandos de |
||||||
|
movimentação existentes, apenas os mais interessantes. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./01-modos", prev_chapter_title="Modos", next_chapter_link="./01-02-entendendo-o-cursor", next_chapter_title="Entendendo o Cursor") }} |
After Width: | Height: | Size: 7.1 KiB |
@ -0,0 +1,39 @@ |
|||||||
|
+++ |
||||||
|
title = "Entendendo o Cursor" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Esta é a parte em que você vai lembrar quando o texto não parar exatamente |
||||||
|
onde você pensava que ele iria parar. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Antes de passar para comandos do modo normal que realmente alteram o texto, é |
||||||
|
preciso entender como o VIM entende o cursor, porque o funcionamento pode |
||||||
|
parecer um pouco diferente dos demais editores. |
||||||
|
|
||||||
|
Para todos os efeitos, considere que o cursor está sempre na parte inferior |
||||||
|
esquerda do bloco do cursor. |
||||||
|
|
||||||
|
![](vim-cursor.png) |
||||||
|
|
||||||
|
![Mais uma foto de você, nesse exato momento.](areyoufuckingkiddingme.jpg) |
||||||
|
|
||||||
|
Porque é importante ter isso em mente? |
||||||
|
|
||||||
|
Porque a maior parte dos editores trata as coisas um pouco diferentes: Por |
||||||
|
exemplo, se houver uma linha inteira no clipboard, o VIM irá inserir (com o |
||||||
|
comando padrão de colar, que vamos ver mais adiante) a nova linha abaixo na |
||||||
|
linha atual -- a maior parte dos outros editores cola a nova linha no lugar da |
||||||
|
linha atual e move a antiga linha uma posição abaixo. |
||||||
|
|
||||||
|
Apenas tenha isso em mente agora que vamos começar a mudar de modo e alguns |
||||||
|
comandos consideram a posição do cursor desta forma e tem uma "contraparte" |
||||||
|
para ações antes do cursor -- e por isso o próximo capítulo parece ter comandos |
||||||
|
repetidos. |
||||||
|
|
||||||
|
{% note() %} |
||||||
|
Todas as imagens são copyright (C) seus respectivos donos. |
||||||
|
{% end %} |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./01-01-modo-normal", prev_chapter_title="Modo Normal", next_chapter_link="./01-03-modo-de-insercao", next_chapter_title="Modo de Inserção") }} |
After Width: | Height: | Size: 12 KiB |
After Width: | Height: | Size: 145 KiB |
After Width: | Height: | Size: 305 KiB |
@ -0,0 +1,123 @@ |
|||||||
|
+++ |
||||||
|
title = "Mudando de Modos – Modo de Inserção" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Esta é a parte em que você vai finalmente começar a editar o texto. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Agora que você sabe que existe mais de um modo de edição e como o cursor |
||||||
|
funciona, podemos finalmente começar a ver como se passa de um modo para o |
||||||
|
outro -- e, no processo, entender como editar um texto no VIM. |
||||||
|
|
||||||
|
Primeiro, é preciso saber que o Modo Normal é o ponto central para todos os |
||||||
|
outros modos -- o jeito mais fácil de passar de um modo para o outro é através |
||||||
|
do Modo Normal. E, de qualquer modo[^1], para ir para o modo normal basta |
||||||
|
pressionar `Esc`. |
||||||
|
|
||||||
|
Lembre-se: `Esc` irá sempre voltar para o modo normal para que você possa passar |
||||||
|
para os demais modos. `Esc` em modo normal irá continuar em modo normal[^2]. |
||||||
|
|
||||||
|
Para passar do modo normal para o modo de inserção, você deve usar o seguinte: |
||||||
|
|
||||||
|
## i |
||||||
|
|
||||||
|
Vai para o modo de inserção na posição do cursor (lembre-se do capítulo |
||||||
|
anterior: o cursor está no canto inferior esquerdo do cursor, logo qualquer |
||||||
|
coisa que você digitar vai aparecer antes da letra onde o cursor se encontrava |
||||||
|
antes de pressionar `i`). |
||||||
|
|
||||||
|
## I |
||||||
|
|
||||||
|
Move o cursor para o primeiro caracter que não seja espaço ou tabulação na |
||||||
|
linha e entra em modo de inserção (semelhante à `_i`). |
||||||
|
|
||||||
|
## a |
||||||
|
|
||||||
|
Move o cursor uma posição pra frente e entra em modo de inserção (ou o mesmo |
||||||
|
que `li`). |
||||||
|
|
||||||
|
## A |
||||||
|
|
||||||
|
Move o cursor para o fim da linha e entra em modo de inserção (Seria quase um |
||||||
|
`$i`, só que `$` pára no último não branco da linha -- se considerarmos o caracter |
||||||
|
de quebra de linha um caracter "branco" -- e `i` ficará antes desse não-branco). |
||||||
|
|
||||||
|
## o |
||||||
|
|
||||||
|
Insere uma linha em branco depois do cursor e entra em modo de inserção. |
||||||
|
|
||||||
|
## O |
||||||
|
|
||||||
|
Insere uma linha em branco acima do cursor e entra em modo de inserção. |
||||||
|
|
||||||
|
## R |
||||||
|
|
||||||
|
Entra em modo de inserção, mas substitui as letras atuais ao invés de adicionar |
||||||
|
mais. Sim, é um modo de substituição ("replace"), mas ainda é considerado um |
||||||
|
modo de inserção. |
||||||
|
|
||||||
|
Ok, pequena pausa para acertar os ponteiros agora: Uma coisa que eu comentei |
||||||
|
anteriormente foi que, no modo normal é possível definir o número de vezes que |
||||||
|
um comando será repetido. Por mais estranho que isso possa parecer, todos os |
||||||
|
comandos acima também aceitam um número de repetições. Por exemplo, `20A-[Esc]` |
||||||
|
irá repetir o comando `A-` 20 vezes, efetivamente colocando 20 "-" na linha |
||||||
|
atual; `20Oolá[Esc]` irá adicionar 20 linhas de `olá` no seu texto, a partir da |
||||||
|
posição do cursor. |
||||||
|
|
||||||
|
![Sua vida acabou de mudar.](iStock_000014784346Small.jpg) |
||||||
|
|
||||||
|
Quem estava prestando atenção deve ter notado que eu pulei `r` como opção de |
||||||
|
modo de inserção e todos os demais comandos tem uma versão em minúsculas e |
||||||
|
maiúsculas. O motivo é que `r` tem um funcionamento, digamos, peculiar. |
||||||
|
|
||||||
|
`r`, por si só, espera por uma tecla para substituir o caracter sob o cursor. |
||||||
|
Seria o equivalente a fazer `R`, pressionar uma tecla e, na sequência, |
||||||
|
pressionar `[Esc]` para sair do modo de inserção. O estranho, no entando, é |
||||||
|
quando é definido um número de vezes que `r` deve ser executado: Neste caso, o |
||||||
|
caracter sob o cursor é alterado para o caracter indicado, o cursor é movido |
||||||
|
para o próximo caracter e o processo se repete até o número de vezes indicado |
||||||
|
(ou seja alcançado o final da linha). `20r-[Esc]` irá, efetivametne, substituir |
||||||
|
os 20 próximos caracteres por "-" -- que não seria o mesmo que digitar, |
||||||
|
manualmente, `r-` 20 vezes. |
||||||
|
|
||||||
|
Existem ainda outros dois comandos para entrar em modo de inserção: `c` e `s`. |
||||||
|
Existem algumas diferenças configuráveis entre ambos, mas o funcionamento é o |
||||||
|
mesmo: Removem os caracteres indicados pela movimentação e passam para o modo |
||||||
|
de inserção. |
||||||
|
|
||||||
|
![Como assim "movimentação"?!?](enhanced-buzz-5697-1327086181-19.jpg) |
||||||
|
|
||||||
|
De novo, pausa para acertar os ponteiros: no capítulo #2.2, eu falei sobre |
||||||
|
comandos do modo normal que movimentam o cursor. Aqui, `c` e `s` não vão entrar em |
||||||
|
modo de inserção até que você adicione uma sequência de movimentação. Assim: `s$` |
||||||
|
irá remover tudo da posição de cursor até o final da linha e entrará em modo de |
||||||
|
inserção, `s%` irá remover tudo da posição do cursor até o próximo elemento que |
||||||
|
"fecha" o elemento atual (aspas, parênteses, colchetes, etc) e entrará em modo |
||||||
|
de inserção, `c2f.` irá remover tudo da posição do cursor até o segundo ponto na |
||||||
|
linha e entrará em modo de inserção e assim por diante. |
||||||
|
|
||||||
|
![A ficha finalmetne caiu](jaw-drop.jpg) |
||||||
|
|
||||||
|
Embora `c` e `s` funcionem de forma semelhante, `C` e `S` não: `C` irá apagar |
||||||
|
tudo da posição do cursor até o final da linha enquanto que `S` irá remover |
||||||
|
todo o conteúdo da linha, não importando a posição do cursor. Logicamente, |
||||||
|
depois de fazerem isso, ambos entram em modo de inserção. Com um número de |
||||||
|
repetições, no entanto, ambos funcionam da mesma forma -- tanto `20S` quanto |
||||||
|
`20C` irão remover a linha atual e mais 19 e entrar em modo de edição. |
||||||
|
|
||||||
|
E, só pra lembrar: Pressionar `[Esc]` irá voltar para o modo normal. |
||||||
|
|
||||||
|
{% note() %} |
||||||
|
Todas as imagens são copyright (C) seus respectivos donos. |
||||||
|
{% end %} |
||||||
|
|
||||||
|
[^1] ... exceto o modo Ex, mas como eu falei antes, não é um modo muito útil |
||||||
|
hoje em dia e, portanto, eu estou ignorando ele daqui pra frente. |
||||||
|
|
||||||
|
[^2] ... O que explica porque vários programadores experientes em VIM tem a |
||||||
|
mania de, algumas vezes, ficar pressionando `[Esc]` rapidamente quando |
||||||
|
algo sai errado. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./01-02-entendendo-o-cursor", prev_chapter_title="Entendendo o Cursor", next_chapter_link="./01-04-modo-visual", next_chapter_title="Modo Visual") }} |
After Width: | Height: | Size: 8.7 KiB |
@ -0,0 +1,57 @@ |
|||||||
|
+++ |
||||||
|
title = "Mudando de Modos – Modo Visual" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Esta é a parte em que VIM deixa de ser um editor tão alienígena. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Na nota de rodapé do primeiro capítulo eu comentei que a maior parte dos |
||||||
|
comandos do modo visual podem ser feitos no modo de comando. Como já vimos o |
||||||
|
modo de comando, fica mais fácil entender o modo visual. |
||||||
|
|
||||||
|
Em suma, o modo visual é a versão do VIM para o "Shift+Direcionais" dos demais |
||||||
|
editores: Vai selecionando texto, deixando visível o que está sendo |
||||||
|
selecionado. A diferença é que não é preciso ficar segurando o Shift o tempo |
||||||
|
todo. E todos os demais comandos de movimentação ainda são válidos. |
||||||
|
|
||||||
|
Para entrar no modo visual, você usa, em modo normal, `v` -- e, de novo, você não |
||||||
|
precisa pressionar ou ficar segurando nenhuma tecla: o modo ficará ativo até |
||||||
|
que você cancele o modo visual (voltando para o modo normal com `[Esc]`) ou seja |
||||||
|
utilizado algum comando de alteração de texto (como `s`). |
||||||
|
|
||||||
|
Uma vez que a região fique selecionada, você pode usar qualquer comando de |
||||||
|
alteração de textos para executar somente naquela região. Assim, ao invés de |
||||||
|
ficar contando quantos pontos a linha tem para chegar no número certo de saltos |
||||||
|
para o commando `f`, você pode facilmente ativar o modo visual, navegar a bel |
||||||
|
prazer, usado qualquer combinação de comandos de movimentação (incluindo |
||||||
|
repetir `f` a vontade) até chegar no ponto que quiser e executar o comando |
||||||
|
somente naquela região. |
||||||
|
|
||||||
|
Além de `v`, existem outros dois outros comandos para entrar em modo visual: |
||||||
|
`[Shift]+v` e `[Ctrl]+v`. |
||||||
|
|
||||||
|
`[Shift]+v` é chamado de "modo visual de linha" porque, bem, são selecionadas |
||||||
|
linhas inteiras neste modo, incluíndo o caracter de nova linha de cada uma das |
||||||
|
linhas selecionadas. Neste modo, não é possível selecionar apenas parte de uma |
||||||
|
linha, somente linhas inteiras -- que é útil quando se quer remover aquela |
||||||
|
função inteira[^1]. |
||||||
|
|
||||||
|
`[Ctrl]+v` é chamado de "modo visual de bloco" e faz algo que poucos outros |
||||||
|
editores conseguem: seleção de regiões retangulares. A pergunta que você deve |
||||||
|
estar se fazendo agora é: e como é que o VIM junta as linhas se eu apagar um |
||||||
|
bloco inteiro? Resposta indireta: O modo visual de bloco funciona como se |
||||||
|
várias seleções fossem feitas ao mesmo tempo, o que significa que cada linha é |
||||||
|
uma seleção diferente e que cada comando de alteração de texto é executado |
||||||
|
individualmente em cada linha. Assim, se você iniciar o modo visual de bloco, |
||||||
|
selecionar várias linhas mas apenas uma coluna, e executar o comando `c,[Esc]`, o |
||||||
|
que vai acontecer é que o VIM irá substituir o caracter na coluna indicada por |
||||||
|
vírgula em cada uma das linhas. Ou seja, respondendo a pergunta feita logo no |
||||||
|
começo deste parágrafo: o VIM irá juntar as linhas como se você tivesse ido na |
||||||
|
primeira linha, executado o comando, retornado a coluna inicial, ido para a |
||||||
|
linha seguinte, repetido o comando e passado para a próxima linha. |
||||||
|
|
||||||
|
[^1] Ou copiar para outro arquivo, que nós vamos ver mais pra frente. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./01-03-modo-de-insercao", prev_chapter_title="Modo de Inserção", next_chapter_link="./02-outros-comandos", next_chapter_title="Outros Comandos") }} |
@ -0,0 +1,146 @@ |
|||||||
|
+++ |
||||||
|
title = "Mudando de Modos – Modo de Comando" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte onde você vai aprender a fazer as coisas que precisavam de um |
||||||
|
menu para serem feitas. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Existem três "iniciadores" de comandos no modo de... erm... comando: |
||||||
|
|
||||||
|
* `:`: Inicia um comando de edição. |
||||||
|
* `/`: Comando de pesquisa. |
||||||
|
* `!`: Comando de filtro externo. |
||||||
|
|
||||||
|
## Comandos de Edição |
||||||
|
|
||||||
|
Assim como os comandos do modo normal, a quantidade de comandos de edição é |
||||||
|
grande demais para cobrir de uma vez só. Então vamos dar uma olhada nos mais |
||||||
|
utilizados: |
||||||
|
|
||||||
|
## :q |
||||||
|
|
||||||
|
Sai do VIM. Esse deve ser o comando mais infame da história do editor -- pelo |
||||||
|
menos, para os não iniciados. E ele ainda aparece na tela inicial do VIM, se |
||||||
|
você prestar atenção. |
||||||
|
|
||||||
|
## :w |
||||||
|
|
||||||
|
Salva o arquivo atual em disco. Você pode passar o nome do arquivo a ser salvo |
||||||
|
neste ponto. `:w`, por exemplo, irá salvar o conteúdo com o nome atual; `:w |
||||||
|
outro-nome` irá salvar o conteúdo no arquivo "outro-nome". |
||||||
|
|
||||||
|
## :wall |
||||||
|
|
||||||
|
Salva todos os arquivos arquivos. Mais adiante veremos como ter vários arquivos |
||||||
|
abertos ao mesmo tempo. |
||||||
|
|
||||||
|
## :wq |
||||||
|
|
||||||
|
Salva o arquivo atual e o fecha. |
||||||
|
|
||||||
|
## :help |
||||||
|
|
||||||
|
Abre o help do VIM no tópico indicado. Por exemplo, `:help :w` irá apresentar as |
||||||
|
opções existentes para o comando `:w`; `:help c` irá mostrar as opções do comando `c` |
||||||
|
do modo normal e assim por diante. |
||||||
|
|
||||||
|
## :set |
||||||
|
|
||||||
|
Configura (ou apresenta) alguma configuração do VIM. Mais a frente veremos como |
||||||
|
configurar o VIM e veremos as opções este comando. |
||||||
|
|
||||||
|
## :r |
||||||
|
|
||||||
|
(Ou :read) Não é muito comum, mas permite carregar o conteúdo de outro arquivo |
||||||
|
para dentro do arquivo atual. sem precisar fazer todo o processo de |
||||||
|
copiar-e-colar (que veremos mais adiante). Um fato interessante de `:r` é que se |
||||||
|
o nome do arquivo a ser carregado começar com "!", o VIM irá tentar executar o |
||||||
|
comando ao invés de carregar o conteúdo. Por exemplo, `:r date` irá carregar o |
||||||
|
conteúdo do arquivo `date` para dentro do arquivo atual enquanto que `:r !date` irá |
||||||
|
executar o comando `date` e "colar" o resultado para dentro do arquivo atual. |
||||||
|
|
||||||
|
## :noh |
||||||
|
|
||||||
|
(Ou :nohighlight) Desliga a marcação sobre elementos de pesquisa. A seguir nós |
||||||
|
vamos ver sobre o comando de pesquisa; ao fazer uma, o VIM irá colocar um |
||||||
|
"realce" (ou "highlight") sobre as palavras encontradas. Para desligar esses |
||||||
|
realces no texto, você pode usar `:noh`. |
||||||
|
|
||||||
|
Aqui eu preciso abrir três parenteses: |
||||||
|
|
||||||
|
* Quando o vim se recusar a executar um comando, você pode forçá-lo a executar |
||||||
|
o mesmo de qualquer forma adicionando uma exclamação `!` no final do comando. |
||||||
|
Por exemplo, se o VIM se recusar a sair porque você tem alterações em um |
||||||
|
arquivo não salvo, `:q!` irá forçar o editor fechar, perdendo as alterações |
||||||
|
feitas; se o arquivo não tiver permissão de escrita, `:w!` irá fazer com que o |
||||||
|
VIM altere as permissão do arquivo para poder escrever (e, no final, esta |
||||||
|
alteração das permissões é revertida)[^1]. |
||||||
|
|
||||||
|
* Uma coisa que você vai encontrar frequentemente são referências a "buffer" e |
||||||
|
"arquivo". Entenda assim: buffer é a representação do arquivo na memória |
||||||
|
enquanto que o arquivo é a representação do conteúdo no disco. Ao abrir um |
||||||
|
arquivo, o VIM cria um buffer com o conteúdo do arquivo e o mantém em |
||||||
|
memória; se o arquivo sumir, o buffer ainda existirá e poderá ser salvo |
||||||
|
ainda; vários comandos internos do VIM -- se você se aventurar a escrever um |
||||||
|
plugin, por exemplo -- fazem referência ao buffer e não ao arquivo, mas |
||||||
|
existem funções que retornam o buffer de um arquivo com o nome indicado. Em |
||||||
|
todo esse tempo usando VIM, a distinção entre ambos nunca me pareceu |
||||||
|
importante e considerar, simplesmente, que "buffer" é o arquivo em memória é |
||||||
|
o suficiente. |
||||||
|
|
||||||
|
* Todos os comandos internos do VIM iniciam com uma letra minuscula e plugins, |
||||||
|
quando adicionam comandos a mais, adicionam com letras maiúsculas[^2]. Ainda, |
||||||
|
boa parte dos comandos não precisa ser digitada completa; quando não há mais |
||||||
|
redundâncias, o comando é aceito. Por exemplo, se houverem os comandos |
||||||
|
":Gblame" e ":Gbork", ":Gb" não será aceito, mas ":Gba” será porque não há |
||||||
|
mais nenhum outro comando que comece com ":Gba" (por isso que ":noh" funciona |
||||||
|
como atalho para ":nohighlight": porque não há nenhum outro comando que |
||||||
|
inicie com "noh"). |
||||||
|
|
||||||
|
## Comando de Pesquisa |
||||||
|
|
||||||
|
O comando de pesquisa é, simplesmente, `/`. Uma vez pressionado, você verá o |
||||||
|
cursor indo para a última linha da tela esperando a pesquisa. Uma coisa a ter |
||||||
|
em mente é que o VIM utiliza expressões regulares -- então algumas coisas que |
||||||
|
você procurar não irão funcionar exatamente como você está esperando. ".", por |
||||||
|
exemplo. Eu não vou entrar em detalhes sobre expressões regulares porque há |
||||||
|
pilhas de informações sobre elas na internet -- e há praticamente mais sobre |
||||||
|
elas do que essa série tem (e terá) sobre VIM. |
||||||
|
|
||||||
|
Dois comandos do modo normal que eu não mencionei antes por estarem ligados ao |
||||||
|
comando de pesquisa são `n` e `N`. `n` irá mover o cursor para a próxima |
||||||
|
ocorrência da pesquisa, enquanto que `N` move o cursor para a anterior. Note |
||||||
|
que eu falei "move o cursor"; isso quer dizer que `n` e `N` são comandos de |
||||||
|
movimentação e, portanto, podem ser usados com outros comandos do modo normal |
||||||
|
que utilizam movimentação. Por exemplo, procurar por "olá" e, em modo normal, |
||||||
|
executar `cn` irá remover tudo da posição do cursor até a próxima ocorrência de |
||||||
|
"olá" (e entrará em modo de edição). |
||||||
|
|
||||||
|
## Comando de Filtro |
||||||
|
|
||||||
|
O comando de filtro pega o conteúdo no editor e passa para outro programa. Por |
||||||
|
exemplo, se você tiver o aplicativo "rot13", ao executar `!rot13`, todo o |
||||||
|
conteúdo do arquivo será convertido para ROT13. Se você digitar `!!rot13`, no |
||||||
|
entanto, o conteúdo ainda será passado para o filtro e o resultado irá |
||||||
|
substituir o conteúdo do buffer atual. |
||||||
|
|
||||||
|
Não parece ser interessante, mas um dos aplicativos que normalmente vem com o |
||||||
|
VIM é "xxd", que converte o conteúdo para sua representação hexadecimal. Ao |
||||||
|
executar "!xxd", você verá todo o conteúdo do seu arquivo com os valores |
||||||
|
hexadecimais de cada caracter. |
||||||
|
|
||||||
|
[^1] Não confunda "Não ter permissão de escrita" com "O arquivo pertence ao |
||||||
|
root". No primeiro caso, o usuário tem permissão de ler o arquivo e trocar |
||||||
|
as permissões enquanto que no segundo o editor teria que ter permissões |
||||||
|
especiais de execução para poder trocar as permissões. O VIM só consegue |
||||||
|
responder ao `:w!` se ele próprio -- e, no caso, o próprio usuário -- tiver |
||||||
|
permissões suficientes sem requisitar outro aplicativo. |
||||||
|
|
||||||
|
[^2] Na verdade, o VIM vem sim com comandos que inicial com letra maíuscula: São |
||||||
|
os comandos de exploração de diretório `:Explore`, `:Rexplore`, `:Vexplore` e o |
||||||
|
famigerado `:Sexplore`, que o pessoal costuma encurtar para `:Sex`. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./01-04-modo-visual", prev_chapter_title="Modo Visual", next_chapter_link="./01-05-modo-de-comando", next_chapter_title="Modo de Comando") }} |
@ -0,0 +1,152 @@ |
|||||||
|
+++ |
||||||
|
title = "Outros Comandos" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Esta é a parte em que eu comento alguns comandos que você vai usar |
||||||
|
esporadicamente. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Neste ponto você deve estar entendendo como os modos do VIM funcionam, para que |
||||||
|
cada um funciona e tento uma idéia básica de como editar arquivos. Como eu |
||||||
|
falei já duas vezes, a quantidade de comandos disponíveis é gigantesca, então |
||||||
|
vamos aproveitar esse pequeno momento em que as coisas começam a fazer sentido |
||||||
|
para ver mais alguns comandos. |
||||||
|
|
||||||
|
## [Shift]+j (Modo normal) |
||||||
|
|
||||||
|
"Junta" a linha abaixo do cursor com a atual. Pode não parecer muito, mas o VIM |
||||||
|
irá colocar um espaço no final da linha atual[^1] antes de juntar com a linha |
||||||
|
abaixo e removerá todo caractere branco da linha de baixo antes de juntar as |
||||||
|
duas linhas. |
||||||
|
|
||||||
|
## x (Modo normal) |
||||||
|
|
||||||
|
Apaga o caractere sob o cursor. O mesmo que `[Del]`. |
||||||
|
|
||||||
|
## gq (Modo normal) |
||||||
|
|
||||||
|
Reformata o parágrafo. Não faz muito sentido para código (com algumas |
||||||
|
exceções), mas se você tiver configurado a coluna máxima (vou explicar como |
||||||
|
fazer isso na parte de configuração do VIM), você pode selecionar um comentário |
||||||
|
em modo visual e usar gq para que o VIM alinhe o comentário no espaço definido. |
||||||
|
Também serve para quando você estiver editando arquivos de markup (MarkDown, |
||||||
|
reSTRUCTURED text, HTML, etc). |
||||||
|
|
||||||
|
## gg e G (Modo normal) |
||||||
|
|
||||||
|
`gg` move o cursor para o início do arquivo e `G` move o cursor para o fim do |
||||||
|
arquivo. Efetivamente, fazer `ggdG` (mover o cursor para o início do arquivo, |
||||||
|
remover tudo até o final do arquivo) irá remover todo o conteúdo do arquivo. |
||||||
|
|
||||||
|
## = (Modo normal) |
||||||
|
|
||||||
|
Reidenta o código usando a sintaxe atual. |
||||||
|
|
||||||
|
## u e [Ctrl]+r (Modo normal) |
||||||
|
|
||||||
|
Undo e redo, respectivamente. |
||||||
|
|
||||||
|
## [Ctrl]+y e [Ctrl]+e (Modo normal e Modo de inserção) |
||||||
|
|
||||||
|
Dois comandos que funcionam de forma diferente se executados em modo normal ou |
||||||
|
modo de inserção. |
||||||
|
|
||||||
|
No modo normal, `[Ctrl]+y` irá rolar o conteúdo do texto para baixo, mantendo o |
||||||
|
cursor na mesma posição enquanto que `[Ctrl]+e` irá rolar o conteúdo para cima, |
||||||
|
ainda mantendo o cursor na mesma posição. Se você abusar destes comandos, |
||||||
|
movendo a linha onde o cursor se encontra para fora da área visível, o cursor |
||||||
|
irá se mover. |
||||||
|
|
||||||
|
No modo de inserção, no entanto, `[Ctrl]+y` irá copiar o caractere da linha de |
||||||
|
cima na mesma coluna na posição atual; `[Ctrl]+e` faz o mesmo, mas com a linha de |
||||||
|
baixo. |
||||||
|
|
||||||
|
## . (Modo normal) |
||||||
|
|
||||||
|
Repete o último comando. Note que `.` irá repetir o último comando completo. Por |
||||||
|
exemplo, quando eu falei sobre `ggdG`, estamos falando, na verdade, de dois |
||||||
|
comandos completos: `gg` e `d{movimentação}`. `.`, neste caso, irá repetir o comando |
||||||
|
`dG`. Mais adiante veremos como criar "macros de teclado" e efetivamente permitir |
||||||
|
a execução de coleções de comandos. |
||||||
|
|
||||||
|
## :e e :files (Modo de comando) |
||||||
|
|
||||||
|
Edita um arquivo. Se não for passado o nome do arquivo depois do comando, o |
||||||
|
mesmo arquivo é recarregado do disco (em outras palavras, o buffer é atualizado |
||||||
|
com o conteúdo do arquivo). `:e#` recarrega o último arquivo aberto (por exemplo, |
||||||
|
se você estiver com o arquivo "arquivo" aberto e fizer `:e arquivo2`, usar `:e#` |
||||||
|
irá recarregar "arquivo" para o editor; usando `:e#` de novo, "arquivo2" será |
||||||
|
apresentado). |
||||||
|
|
||||||
|
Você pode ver os últimos arquivos abertos na sessão atual do VIM com `:files`. Se |
||||||
|
quiser recarregar algum destes arquivos de novo, basta usar `:e#{número}`, onde |
||||||
|
{número} é o número do arquivo na lista. |
||||||
|
|
||||||
|
## :sh (Modo de comando) |
||||||
|
|
||||||
|
Abre um shell dentro do VIM. Para retornar ao VIM, basta encerrar o shell. |
||||||
|
|
||||||
|
## :{número} (Modo de comando) |
||||||
|
|
||||||
|
Pula para a linha indicada. Por exemplo, `:100` irá para a centésima linha do |
||||||
|
arquivo. |
||||||
|
|
||||||
|
## [Ctrl]+] e [Ctrl]+t (Modo normal) |
||||||
|
|
||||||
|
`[Ctrl]+]` pula para a tag sob o cursor e `[Ctrl]+t` retorna. Mais adiante veremos |
||||||
|
como criar um arquivo de tags para que o VIM consiga navegar pelo código. A |
||||||
|
mesma idéia é usada no help do VIM: se você digitar `:help` irá ver a primeira |
||||||
|
página de ajuda do editor; para navegar entre os tópicos apresentados (marcados |
||||||
|
de forma diferente, dependendo do esquema de cor utilizado), é utilizado |
||||||
|
`[Ctrl]+]` para avançar e `[Ctrl]+t` para retornar para a página anterior. |
||||||
|
|
||||||
|
## ~ (Modo normal) |
||||||
|
|
||||||
|
Altera o caractere sob o cursor para maiúscula se for minúscula e vice-versa e |
||||||
|
move o cursor uma posição pra frente. |
||||||
|
|
||||||
|
## gu{movimentação}, gU{movimentação} e g~{movimentação} (Modo normal) |
||||||
|
|
||||||
|
`gu{movimentação}` altera todos os caracteres em {movimentação} para minúsculas. |
||||||
|
|
||||||
|
`gU{movimentação}` altera todos os caracteres em {movimentação} mara maiúsculas. |
||||||
|
|
||||||
|
`g~{movimentação}` faz `~` nos caracteres em {movimentação} (ou seja, os caracteres |
||||||
|
da posição do cursor até movimentação ficarão em maiúsculas se estiverem em |
||||||
|
minúsculas e vice-versa). |
||||||
|
|
||||||
|
## [Ctrl]+p e [Ctrl]+n (Modo de inserção) |
||||||
|
|
||||||
|
Auto-complete. `[Ctrl]+p` tenta completar a palavra antes do cursor voltando no |
||||||
|
texto enquanto que `[Ctrl]+n` tenta completar com palavras mais a frente no |
||||||
|
texto. |
||||||
|
|
||||||
|
## [Ctrl]+a e [Ctrl]+x (Modo normal) |
||||||
|
|
||||||
|
Incrementa (`[Ctrl]+a`) ou decrementa (`[Ctrl]+x`) o número sob o cursor. O VIM |
||||||
|
automaticamente detecta se o número está em decimal, octal ou hexa. |
||||||
|
|
||||||
|
E MAIS! |
||||||
|
|
||||||
|
## w (Modo normal) |
||||||
|
|
||||||
|
Move o cursor para o começo da próxima palavra. |
||||||
|
|
||||||
|
## e (Modo normal) |
||||||
|
|
||||||
|
Move o cursor para o fim da próxima palavra. |
||||||
|
|
||||||
|
## b (Modo normal) |
||||||
|
|
||||||
|
Move o cursor para o começo da palavra anterior. |
||||||
|
|
||||||
|
## ge (Modo normal) |
||||||
|
|
||||||
|
Move o cursor para o fim da palavra anterior. |
||||||
|
|
||||||
|
[^1] ... a não ser que o primeiro caractere (não branco) da linha de baixo seja |
||||||
|
um ")"; neste caso, o VIM não adiciona o espaço. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./01-05-modo-de-comando", prev_chapter_title="Modo de Comando", next_chapter_link="./03-recortar-copiar-colar", next_chapter_title="Recordar, Copiar e Colar") }} |
@ -0,0 +1,71 @@ |
|||||||
|
+++ |
||||||
|
title = "Recortar, Copiar e Colar" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte que você não deve fazer muitas vezes quando estiver |
||||||
|
programando. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Assim como outros editores, o VIM tem um sistema de copiar e colar. E, como |
||||||
|
vimos vendo desde o começo, o VIM tem seu modo peculiar de lidar com isso. |
||||||
|
|
||||||
|
Toda a parte de copiar-e-colar do VIM é feita em modo normal. E sem que você |
||||||
|
soubesse, você já stava vendo a parte de recordar textos desde a parte de |
||||||
|
comandos do modo normal: Qualquer comando que exclua texto imediatamente |
||||||
|
transfere a parte excluído para a área de transferência do VIM. A única parte |
||||||
|
que ficou faltando foi como você “cola” estes textos de volta. |
||||||
|
|
||||||
|
E, para colar, você usa `p` (de "paste", veja só!). |
||||||
|
|
||||||
|
E, obviamente, existe o `[Shift]+p` também. E a diferença é facilmente explicada |
||||||
|
se voltarmos para o capítulo #2.2. |
||||||
|
|
||||||
|
Quando falamos do cursor, eu disse que o cursor encontra-se na parte inferior |
||||||
|
esquerda do bloco do cursor. O colar do VIM é feito depois do cursor. Assim, ao |
||||||
|
pressionar `p`, o texto irá aparecer depois do caractere sob o cursor; se for |
||||||
|
pressionado `[Shift]+p`, o texto será colado antes do caractere atual, empurrando |
||||||
|
o mesmo pra frente. |
||||||
|
|
||||||
|
O funcionamento muda um pouco se você recortar o texto usando o modo visual de |
||||||
|
linha (ou recortar usando algum movimento que desconsidere a coluna atual). |
||||||
|
Nestes casos, o VIM entende que você quer colar uma linha inteira e, ao invés |
||||||
|
de mover o conteúdo da linha atual, o texto é colado abaixo da linha atual, |
||||||
|
desconsiderando a posição do cursor. `[Shift]+p` irá colar o texto antes da linha |
||||||
|
atual. |
||||||
|
|
||||||
|
(Embora pareça complicado, a medida que você for se aclimatando com o |
||||||
|
copiar-e-colar do VIM, você verá que não é tão diferente dos demais editores -- |
||||||
|
com a exceção que os outros editores tentam adivinhar quando você quer fazer |
||||||
|
copia de linhas inteiras ou apenas pedaços, enquanto que o VIM deixa você mesmo |
||||||
|
decidir quando fazer isso.) |
||||||
|
|
||||||
|
A única coisa que ficou faltando agora foi como copiar o texto sem remover o |
||||||
|
mesmo antes -- porque, vamos admitir, recortar e colar de novo seria muita |
||||||
|
burrice. |
||||||
|
|
||||||
|
O comando para copiar é `y{movimentação}`. Normalmente, ele é chamado de "yank" |
||||||
|
(arrancar) e por isso muitos chamam o sistema de "copy'n'paste" do VIM de |
||||||
|
"yank'n'paste". |
||||||
|
|
||||||
|
Para copiar a linha inteira, você pode usar `yy`. Isto copia toda a linha, |
||||||
|
incluindo o marcador de nova linha, e o VIM vai entender que, na hora de colar, |
||||||
|
você quer colar a linha inteira, seguindo as mesmas regras que eu expliquei |
||||||
|
acima sobre o modo visual de linha. |
||||||
|
|
||||||
|
Assim como outros editores, o VIM mantém a área de transferência entre arquivos |
||||||
|
(com isso, você pode abrir um arquivo, copiar um texto, abrir outro arquivo e |
||||||
|
colar a parte selecionada do primeiro) e, normalmente, o VIM ainda consegue |
||||||
|
manter a área de transferência entre execuções. Entretanto, uma coisa que você |
||||||
|
pode não gostar é que a área de transferência pertence e é gerenciada |
||||||
|
exclusivamente pelo VIM -- ou seja, ele não usa a área de transferência do |
||||||
|
sistema operacional[^1]. Assim, você não vai conseguir copiar do VIM e colar no |
||||||
|
seu browser ou vice-versa. |
||||||
|
|
||||||
|
.. a não ser que você use registradores, que nós vamos ver a seguir. |
||||||
|
|
||||||
|
[^1] E não, o "botão do meio dentro do X" não é a mesma coisa a área de |
||||||
|
transferência. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./02-outros-comandos", prev_chapter_title="Outros Comandos", next_chapter_link="./04-registradores", next_chapter_title="Registradores") }} |
@ -0,0 +1,76 @@ |
|||||||
|
+++ |
||||||
|
title = "Registradores" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte que o VIM fica melhor que os outros editores. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
No capítulo anterior eu mencionei que o VIM tem uma área de transferência |
||||||
|
própria e que ela não se comunica diretamente com a área de transferência do |
||||||
|
sistema operacional, apenas através de registradores. |
||||||
|
|
||||||
|
A forma mais simples de pensar em registradores é: são marcadores para áreas de |
||||||
|
transferência com nomes[^1]. |
||||||
|
|
||||||
|
Para acessar os registradores, você deve usar `"{nome do registrador}`, onde |
||||||
|
{nome do registrador} é uma letra apenas. Assim, para copiar texto para um |
||||||
|
registrador, é utilizado `"{registrador}y{movimento}`; para retirar depois este |
||||||
|
texto do registrador, é utilizado `"{registrador}p`. |
||||||
|
|
||||||
|
Enquanto você estava vendo yank'n'paste do VIM, o VIM estava guardando o texto |
||||||
|
numa área de transferência apontanda pelo "registrador sem nome". E eu não |
||||||
|
estou brincando aqui: O próprio help do VIM chama este registrador de |
||||||
|
"registrador sem nome". A letra do registrador sem nome é `"` (ou seja, `""yy` e |
||||||
|
`yy` ambos irão copiar a linha atual para o registrador sem nome). |
||||||
|
|
||||||
|
Números são registradores especiais. 0 contém o último texto copiado para área |
||||||
|
de transferência; de 1 a 9 ficam os textos excluídos, em forma de pilha (o mais |
||||||
|
recente no registrador 1, o anterior a este no 2 e assim por diante; e quando |
||||||
|
mais texto é excluído, o conteúdo vai para o registrador 1, o conteúdo do |
||||||
|
registrador 1 vai para o registrador 2 e assim por diante). |
||||||
|
|
||||||
|
`-` é um registrador que guarda qualquer coisa excluída que for menor que uma |
||||||
|
linha inteira. |
||||||
|
|
||||||
|
Registradores com letras de "a" a "z" funcionam exatamente como esperado: `"ayy` irá |
||||||
|
copiar a linha atual para o registrador "a" enquanto que `"bp` irá colar o conteúdo |
||||||
|
do registrador b. |
||||||
|
|
||||||
|
Note que até agora eu chamei os registradores normais com minúsculas. O motivo |
||||||
|
é que, ao copiar algo para um registrador, o conteúdo anterior é removido, a |
||||||
|
não ser que você passe o nome do registrado em maiúsculas. Neste caso, o |
||||||
|
conteúdo movido para a área de transferência do registrador é adicionado ao |
||||||
|
conteúdo já existente. Assim, você pode copiar linhas não-contíguas usando `"ayy` |
||||||
|
para a primeira linha, `"Ayy` para as demais e depois colar com `"ap` (para o paste |
||||||
|
não há diferença entre maiúsculas e minúsculas). |
||||||
|
|
||||||
|
Outros registradores especiais são: |
||||||
|
|
||||||
|
## = |
||||||
|
|
||||||
|
Registrador de expressões. Você pode entrar fórmulas e depois colar o resultado |
||||||
|
no conteúdo com `p`. Uma coisa a cuidar aqui é que não é possível fazer `"=p`; o |
||||||
|
VIM irá imediatamente abrir espaço para entrar a fórmula ao digitar `"=`; ainda, |
||||||
|
o conteúdo é perdido se depois de digitar a fórmula você utilizar qualquer |
||||||
|
comando que não seja `p` (incluindo os comandos de movimentação). |
||||||
|
|
||||||
|
## _ |
||||||
|
|
||||||
|
Registrador "buraco negro" (de novo, eu não estou brincando, o help do VIM |
||||||
|
chama esse registrador de "buraco negro"). Qualquer coisa enviada para este |
||||||
|
registrador é perdida; paste deste registrador retorna nada. Útil quando você |
||||||
|
quer excluir algum texto sem mexer no registrador sem nome. |
||||||
|
|
||||||
|
## + |
||||||
|
|
||||||
|
Registrador da área de transferência do sistema operacional. Somente disponível |
||||||
|
para aplicações GUI, já que estas tem acesso direto ao sistema (no caso do VIM |
||||||
|
console em Linux, o "sistema operacional" seria o próprio shell, que não tem |
||||||
|
uma área de transferência -- se você pensar nas bibliotecas envolvidas, a coisa |
||||||
|
faz sentido). |
||||||
|
|
||||||
|
[^1] Registradores também são usados para outras coisas, mas veremos isso mais pra frente. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./03-recortar-copiar-colar", prev_chapter_title="Recortar, Copiar e Colar", next_chapter_link="./05-marcadores", next_chapter_title="Marcadores") }} |
@ -0,0 +1,72 @@ |
|||||||
|
+++ |
||||||
|
title = "Marcadores" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que você não vai mais precisar se lembrar da última linha |
||||||
|
que estava editando. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Algumas vezes você precisa ficar pulando entre partes diferentes do seu |
||||||
|
arquivo. Alguns editores oferecem a funcionalidade de "bookmark" para linhas |
||||||
|
específicas e ficam "pulando" entre estes bookmarks. O VIM tem uma |
||||||
|
funcionalidade semelhante, chamada "Marcadores". A diferença é que enquanto os |
||||||
|
demais editores só tem um estado para marcadores (ativo ou não), o VIM permite |
||||||
|
que você tenha até 26 marcadores únicos -- e que podem ser acessados |
||||||
|
diretamente. |
||||||
|
|
||||||
|
Para marcar uma linha, você deve usar `m{nome do marcador}` em modo normal, onde |
||||||
|
`{nome do marcador}` é uma letra de "a" a "z". Para ir diretamente para um |
||||||
|
marcador, é só usar `'{nome do marcador}` para simplesmente mover o cursor para o |
||||||
|
primeiro caractere não branco na linha do marcador ou `\`{nome do marcador}` para |
||||||
|
mover o cursor exatamente para a posição do marcador (ambos também em modo |
||||||
|
normal). |
||||||
|
|
||||||
|
Como tudo no VIM, maiúsculas e minúsculas fazem diferença. |
||||||
|
|
||||||
|
Criar um marcador com um nome em minúsculas signifca que o marcador é valido |
||||||
|
somente dentro do arquivo. O marcador "a" do arquivo "arquivo1" não é o mesmo |
||||||
|
marcador "a" do arquivo "arquivo2". Quando um marcador é criado em maiúsculas, |
||||||
|
ele se torna global: Se você fizer `mA` no arquivo "arquivo1" e abrir o arquivo |
||||||
|
"arquivo2", `\`A` irá voltar para o arquivo "arquivo1" (na posição do marcador, |
||||||
|
obviamente). |
||||||
|
|
||||||
|
E como tudo no VIM, sempre existem os comandos mágicos. |
||||||
|
|
||||||
|
## \`\` ou '' |
||||||
|
|
||||||
|
Retorna para a última posição onde foi feito um "pulo". Por exemplo, se você |
||||||
|
está na linha 100 do arquivo atual, e fizer um pulo para o marcador "a" (com `\`a`, |
||||||
|
por exemplo), ``\`\`` irá retorna para a linha 100. Note que isso não gera um |
||||||
|
marcador per se, já que fazer ``\`\`` de novo irá retornar para a posição do |
||||||
|
marcador "a" (pois foi lá que aconteceu o último pulo). |
||||||
|
|
||||||
|
|
||||||
|
## \`. ou '. |
||||||
|
|
||||||
|
Retorna para a última posição onde houve alteração de texto. O exemplo que eu |
||||||
|
posso pensar neste caso é quando você está digitando um comando e não se lembra |
||||||
|
se fez o #include ou import necessário. Neste caso, você simplesmente termina |
||||||
|
de digitar o comando, usa `gg` para ir para o começo do arquivo para verificar se |
||||||
|
o include/import está lá e, se tiver, usa `\`.` para retornar para a posição |
||||||
|
original. |
||||||
|
|
||||||
|
|
||||||
|
## \`[ ou '[ e \`] ou '] |
||||||
|
|
||||||
|
Retorna para a posição onde o texto foi copiado ("yanked") para a área de |
||||||
|
transferência (qualquer área de transferência). `[` irá mover para o primeiro |
||||||
|
caractere copiado e `]` para o último. |
||||||
|
|
||||||
|
|
||||||
|
## \`" ou '" |
||||||
|
|
||||||
|
Move para a última posição do arquivo quando o arquivo foi fechado. Isto |
||||||
|
normalmente é controlado pelo arquivo de inicialização, que veremos mais a |
||||||
|
frente. |
||||||
|
|
||||||
|
E, para ver onde estão as marcas atuais, você só precisa usar `:marks` no modo de |
||||||
|
comando. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./04-registradores", prev_chapter_title="Registradores", next_chapter_link="./06-macros-de-teclado", next_chapter_title="Macros de Teclado") }} |
@ -0,0 +1,60 @@ |
|||||||
|
+++ |
||||||
|
title = "Macros de Teclado" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que você repete várias coisas sem repetir várias coisas. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
No capítulo #3, eu falei rapidamente do commando `.`, que repete o último comando |
||||||
|
completo. Mas como repetir comandos que são, na verdade, uma composição de |
||||||
|
vários outros comandos? |
||||||
|
|
||||||
|
A resposta são macros de teclado. |
||||||
|
|
||||||
|
Macros de teclado permitem que você grave uma execução qualquer e depois a |
||||||
|
repita quantas vezes quiser. |
||||||
|
|
||||||
|
Para fazer uma macro de teclado, você deve, em modo normal, executar |
||||||
|
`q{registrador}`. Ao fazer isso, a última linha do VIM irá mostrar "recording", |
||||||
|
indicando que o editor está agora gravandos todas as teclas pressionadas no |
||||||
|
registrador. Para encerrar a gravação pressione `q` novamente (desta vez, sem o |
||||||
|
registrador). Para "tocar" a macro, é necessário usar `@{registrador}`. |
||||||
|
|
||||||
|
Quem prestou atenção no capítulo #5, deve ter notado que eu usei a palavra |
||||||
|
"registrador" de novo. E a base da questão é que realmente os dois são a mesma |
||||||
|
coisa: Se você copiar algo para o registrador `a` (`"ayy`, por exemplo) e depois |
||||||
|
gravar a macro "a", o conteúdo copiado para a área de transferência será perdido. |
||||||
|
Em compensação, se você criar a macro no registrador "a", você pode ver |
||||||
|
exatamente a sequência de comandos usados usando `"ap`. Ou ainda, você pode |
||||||
|
colocar a sequência de comandos desejada num arquivo (ou no próprio arquivo), |
||||||
|
copiar para o registrador necessário e depois só "tocar" o registrador. |
||||||
|
|
||||||
|
Como exemplo, imagine que você tem uma lista de constantes que você quer |
||||||
|
transformar em uma lista de strings. No caso, você teria que adicionar uma aspa |
||||||
|
no começo, uma aspa no final, uma vírgula e passar para a próxima linha. Se |
||||||
|
forem apenas 4 constantes, é fácil repetir os comandos em cada linha; mas se |
||||||
|
forem 100, a coisa fica diferente. |
||||||
|
|
||||||
|
Neste caso, você faria o seguinte: Na primeira linha, executaria |
||||||
|
`qaI"[Esc]A",[Esc]jq` -- ou seja, iniciaria a macro "a", entraria em modo de |
||||||
|
inserção no primeiro caractere não branco da linha (`I`), colocaria uma aspa, |
||||||
|
sairia do modo de inserção, entraria novamente no modo de inserção mas desta |
||||||
|
vez movendo o cursor para o último caractere antes (`A`), adicionaria a aspa que |
||||||
|
encerra a string e uma vírgula, moveria para a linha de baixo e encerraria a |
||||||
|
macro de teclado. Até aqui espero que não tenha nada de surpresas. Agora você |
||||||
|
pode repetir `@a` 99 vezes para as próximas linhas ou simplesmente executar `99@a` |
||||||
|
e deixar o VIM repetir a macro 99 vezes. No final, bastaria simplesmente |
||||||
|
remover a última vírgula. |
||||||
|
|
||||||
|
Uma coisa a ter em mente -- além da questão do registrador -- é que o VIM |
||||||
|
encerra tanto a macro quanto o número de repetições se houver qualquer |
||||||
|
problema. Por exemplo, se no meio da sua macro você colocar um `f.` para mover |
||||||
|
o cursor para o próximo ponto, mas no meio da execução não for encontrado |
||||||
|
nenhum ponto, a macro será interrompida e qualquer execução posterior será |
||||||
|
encerrada, não importando se for a 99<sup>a</sup> execução da macro ou a |
||||||
|
1</sup>a</sup>. Se você perceber que a execução não terminou onde deveria, |
||||||
|
basta executar `u` em modo de comando para desfazer a execução da macro. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./05-marcadores", prev_chapter_title="Marcadores", next_chapter_link="./07-procurar-varios-arquivos", next_chapter_title="Procurar em Vários Arquivos") }} |
@ -0,0 +1,70 @@ |
|||||||
|
+++ |
||||||
|
title = "Procurar em Vários Arquivos" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que mais uma vez você vai ter que pesquisar sobre |
||||||
|
expressões regulares. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Já vimos o comando de pesquisa, que tem um modo inteiro só pra si[^1]. |
||||||
|
|
||||||
|
Mas como fazer para encontrar ocorrências de uma palavra em mais de um arquivo? |
||||||
|
Para isto, existe o comando `:grep`. |
||||||
|
|
||||||
|
O grep é uma ferramente comum em Unixes (e Linux) em geral, mas o VIM tem |
||||||
|
scripts que fazem a mesma coisa em outros sistemas operacionais (por exemplo, |
||||||
|
Windows). Assim, o mesmo comando vai funcionar da mesma forma não importando |
||||||
|
qual sistema você esteja utilizando. |
||||||
|
|
||||||
|
Como o `:grep` usa outras funcionalidades existentes no VIM, iremos ver um pouco |
||||||
|
mais do que simplesmente "Procurar", mas isso é necessário. |
||||||
|
|
||||||
|
Como o modo de pesquisa, `:grep` precisa de uma expressão regular. Ao contrário |
||||||
|
do modo de pesquisa, o `:grep` também precisa de uma lista de arquivos a serem |
||||||
|
pesquisados. Por baixo dos panos, o que o VIM faz é chamar o comando "grep" (do |
||||||
|
Unix), verifica o resultado e permite pular facilmente entre os elementos |
||||||
|
encontrados (então todas as opções disponíveis para o grep podem ser passadas |
||||||
|
diretamente de dentro do VIM). |
||||||
|
|
||||||
|
Por exemplo, para pesquisar por arquivos que contém a palavra "void", você só |
||||||
|
precisa executar o comando `:grep void *` (onde `:grep` é o comando, `void` é a |
||||||
|
expressão a ser pesquisada e `*` é a lista de arquivos a serem pesquisados). Como |
||||||
|
o grep (o aplicativo do Unix) somente pesquisa arquivos no diretório |
||||||
|
especificado (no nosso caso anterior, como não foi passado diretório algum, |
||||||
|
será considerado o diretório atual), o `:grep` (o comando do VIM) também não vai |
||||||
|
entrar em nenhum subdiretório (de novo, porque o VIM simplesmente chama o grep |
||||||
|
[aplicativo do Unix] e facilita pular entre os elementos encontrados). Para |
||||||
|
fazer uma procura que encontre a expressão além do diretório atual, basta |
||||||
|
adicionar a opção "-r" para o grep (`:grep void -r *`). |
||||||
|
|
||||||
|
Ok, agora que você sabe usar o `:grep`... Como é que você vê os resultados? |
||||||
|
|
||||||
|
Primeira informação periférica: O VIM tem um tipo de "janela" especial, chamada |
||||||
|
"Quickfix". Essa "janela" é, na verdade, um "split" da tela (e mais a frente |
||||||
|
veremos como trabalhar com "splits" e abas). Para exibir o Quickfix, é usado o |
||||||
|
comando `:copen`; para fechar o Quickfix, basta usar `:copen` de novo. Para |
||||||
|
passar para o próximo elemento existente no Quickfix, use `:cnext` (ou |
||||||
|
simplesmente `:cn`); para passar para o elemento anterior, use `:cprevious` (ou |
||||||
|
simplesmente `:cp`); para mover o cursor para a posição do elemento atual do |
||||||
|
Quickfix, use `:cc` (que é simplesmente `:cc` mesmo). |
||||||
|
|
||||||
|
A segunda informação periférica: Como eu falei, usar `:grep {expressão} *` irá |
||||||
|
procurar "{expressão}" a partir do diretório atual. Para descobrir qual é o |
||||||
|
"diretório atual" para o VIM, use `:pwd` (de "print working directory", que |
||||||
|
também é um comando Unix); para mudar para outro diretório, utilize o comando |
||||||
|
`:cd {diretório}`, como você faria num shell normal. |
||||||
|
|
||||||
|
(E antes que alguém pergunte: Sim, você pode fazer um grep fora do diretório |
||||||
|
atual passando o diretório em questão no próprio comando do grep: `:grep void |
||||||
|
/tmp -r` irá procurar por "void" em todos os arquivos existentes no diretório |
||||||
|
/tmp.) |
||||||
|
|
||||||
|
[^1] Apenas para lembrar, `/` entra no modo de pesquisa, onde só é preciso entrar |
||||||
|
a expressão regular a ser encontrada; para passar para a próxima |
||||||
|
ocorrência, use `n` em modo normal; para passar para a ocorrência anterior, |
||||||
|
use `N` também em modo normal; para remover o realce das palavras |
||||||
|
encontradas, use `:noh` em modo de comando. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./06-macros-de-teclado", prev_chapter_title="Macros de Teclado", next_chapter_link="./08-localizar-substituir", next_chapter_title="Localizar e Substituir") }} |
@ -0,0 +1,87 @@ |
|||||||
|
+++ |
||||||
|
title = "Localizar e Substituir" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que você vai precisar aprender expressões regulares — mais |
||||||
|
uma vez. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Uma coisa relativamente comum quando se está programando é substituir todas as |
||||||
|
ocorrências de uma palavra por outra[^1]. |
||||||
|
|
||||||
|
Para fazer "localizar e substituir" ("search and replace") existe o comando |
||||||
|
`:substitute` em modo de comando (ou simplesmente `:s`). |
||||||
|
|
||||||
|
Até aí sem problemas, mas existe uma pequena pegadinha (na verdade, duas, mas |
||||||
|
uma de cada vez): `:s` é, na verdade, `:{range}s`, onde "{range}" é a parte do |
||||||
|
texto que o comando `:s` deve ser executado -- e sim, eu sei que não falei |
||||||
|
sobre este tipo de comando antes, mas essa era a melhor oportunidade. |
||||||
|
|
||||||
|
Então, {range}. {range} é opcional e, se não for passado, o comando será |
||||||
|
executado da linha atual. Isto, obviamente, não é muito útil. {range} é formado |
||||||
|
por um par[^2], separado por vírgulas, indicando o início e o fim da execução do |
||||||
|
comando. |
||||||
|
|
||||||
|
O uso básico de {range} é "linha inicial,linha final". Por exemplo, `:1,5s` irá |
||||||
|
executar o comando `:s` entre as linhas 1 (a primeira, não existe linha 0 no |
||||||
|
VIM) e 5. |
||||||
|
|
||||||
|
E, mais uma vez, existem indicadores especiais, inclusive para {range}. |
||||||
|
|
||||||
|
Um número indica o número da linha, como já comentei. "$" é a última linha do |
||||||
|
arquivo (assim, `:1,$s` irá executar `:s` em todo o arquivo); "%" é um alias |
||||||
|
para "1,$" (ou seja, todo o arquivo); `'{marcador}` irá, obviamente, utilizar |
||||||
|
os marcadores (ou seja, `:'a,'bs` irá executar `:s` entre o marcador "a" e o |
||||||
|
marcador "b" -- E marcadores entre arquivos [em maiúsculas] não são |
||||||
|
permitidos). |
||||||
|
|
||||||
|
(E existe outros dois marcadores especiais que eu não comentei antes por achar |
||||||
|
que não há uso fora do `:s` que são `'<` e `'>` que indicam, respectivamente, o |
||||||
|
início e o fim da região visual -- mas o VIM vai adicionar estes dois |
||||||
|
marcadores automaticamente se você tiver uma região visual selecionada e |
||||||
|
pressionar `:` e por isso ficaram pra trás. Então não se assuste se o VIM |
||||||
|
começar a colocar coisas na linha de comando sem que você tenha digitado.) |
||||||
|
|
||||||
|
Daqui pra frente, eu vou colocar o comando como `:%s`, já que esta é a execução |
||||||
|
mais comum do comando. Mas lembre-se que `%` = `1,$` = do começo ao fim. |
||||||
|
|
||||||
|
`:%s` funciona, assim como a pesquisa, com expressões regulares, só que ao invés |
||||||
|
de termos uma expressão, teremos duas: a de pesquisa e a de substituição. Em |
||||||
|
casos mais simples, onde você quer substituir "palavra 1" por "palavra 2", o |
||||||
|
comando será `:%s/palavra 1/palavra 2`. Mais uma vez, conhecer expressões |
||||||
|
regulares vai ajudar aqui -- e fica a dica para olhar sobre "grupos". |
||||||
|
|
||||||
|
A segunda pegadinha é que `:%s` executa o comando em cada linha do range e, como |
||||||
|
padrão, somente a primeira ocorrência é substituída. Assim, se "palavra 1" |
||||||
|
existir mais de uma vez em uma linha, somente a primeira será alterada. |
||||||
|
|
||||||
|
Para resolver isso, você deve usar o terceiro parâmetro de `:%s`, {flags}. As |
||||||
|
flags mais comuns são: |
||||||
|
|
||||||
|
<dl> |
||||||
|
<dt>g</dt> |
||||||
|
<dd>Substitui todas as ocorrências da expressão de procura na linha, não apenas |
||||||
|
a primeira.</dd> |
||||||
|
<dt>i</dt> |
||||||
|
<dd>Ignora maiúsculas e minúsculas ("ignore case")</dd> |
||||||
|
<dt>c</dt> |
||||||
|
<dd>Pede confirmação em cada alteração.</dd> |
||||||
|
</dl> |
||||||
|
|
||||||
|
Concluindo: para substituir "void" por "int\*" em todo o arquivo mas apenas no |
||||||
|
começo da linha, ignorando se está em maiúsculas ou minúsculas (porque o |
||||||
|
estagiário pensou que estava digitando uma monografia), mas confirmando cada |
||||||
|
mudança, você faria `:%s/^void/int*/ic` (como é apenas no começo da linha e nós |
||||||
|
forçamos isso na expressão regular -- o `^` ali -- não precisamos usar a flag "g", |
||||||
|
já que não teria efeito nenhum). |
||||||
|
|
||||||
|
[^1] E, mas pra frente, veremos que existem plugins que deixam esta parte mais |
||||||
|
fácil. |
||||||
|
|
||||||
|
[^2] Na verdade, não e um par mas, de novo, fazer substituição em apenas uma |
||||||
|
linha não é muito útil, principalmente considerando os comandos que o VIM |
||||||
|
tem para movimentação do cursor. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./07-procurar-varios-arquivos", prev_chapter_title="Macros de Teclado", next_chapter_link="./09-splits", next_chapter_title="Splits") }} |
After Width: | Height: | Size: 79 KiB |
After Width: | Height: | Size: 41 KiB |
@ -0,0 +1,114 @@ |
|||||||
|
+++ |
||||||
|
title = "Splits" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que você vai passar uma hora dividindo a tela em pedacinhos |
||||||
|
cada vez mais pequenos. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Até agora, enquanto falávamos de editar textos no VIM, vimos apenas como editar |
||||||
|
um arquivo por vez. Existem formas de editar mais de um arquivo (usando `:e` e |
||||||
|
`:e#{número}`) mas estas estão longe de serem fáceis de serem utilizadas. |
||||||
|
|
||||||
|
Existem duas formas de manter dois (ou mais) arquivos abertos ao mesmo tempo. |
||||||
|
Uma delas são "splits". Basicamente, splits permitem que você "reparta" a tela |
||||||
|
em pedaços, podendo mostrar outros arquivos (ou até mesmo outra vez o mesmo |
||||||
|
arquivo). |
||||||
|
|
||||||
|
Para criar splits, existem dois comandos que devem ser usados em modo de |
||||||
|
comando: `:sp` e `:vsp`. Ambos comandos aceitam o nome do arquivo a ser aberto no |
||||||
|
novo split; se não for passado o nome de um arquivo, o arquivo que já está |
||||||
|
aberto será carregado. |
||||||
|
|
||||||
|
A diferença entre eles é que `:sp` irá criar um split horizontal... |
||||||
|
|
||||||
|
![](horizontal-split.png) |
||||||
|
|
||||||
|
... enquanto que `:vsp` irá criar um split vertical. |
||||||
|
|
||||||
|
![](vertical-split.png) |
||||||
|
|
||||||
|
Dentro de cada split, comandos executados irão afetar apenas o buffer atual: `:w` |
||||||
|
irá salvar apenas o arquivo apresentar no split atual, `:e` irá abrir um arquivo |
||||||
|
no split atual e assim por diante. |
||||||
|
|
||||||
|
Note que eu falei "buffer atual". Como falei antes, "buffer" é o nome dado para |
||||||
|
a representação do arquivo em memória e que tanto `:sp` quanto `:vsp` sem |
||||||
|
parâmetros irão abrir um split com o arquivo atual -- que, na verdade, é o |
||||||
|
buffer atual. Se você fizer isso e começar a editar o texto em um dos splits, o |
||||||
|
conteúdo do outro também irá mudar, já que ambos estão apresentando o mesmo |
||||||
|
buffer. |
||||||
|
|
||||||
|
Para fechar um split, basta fechar o arquivo, tanto com `:q` quanto `:wq` ou |
||||||
|
qualquer outro comando que feche um arquivo. O split será removido e o cursor |
||||||
|
irá para o próximo split. Se não houverem mais splits, o VIM irá fechar, como |
||||||
|
já vinhamos vendo desde o começo. |
||||||
|
|
||||||
|
E sim, você pode fazer quantos splits e de formas diversas quantas vezes quiser |
||||||
|
(até que não sobre mais espaço na tela, quer dizer). |
||||||
|
|
||||||
|
![](all.png) |
||||||
|
|
||||||
|
Para "manusear" splits, você irá utilizar comandos que começam com, em modo |
||||||
|
normal, `[Ctrl]w`. `[Ctrl]w`, por si só, não faz nada (a não ser que você |
||||||
|
repita o comando, mas isso é outra coisa) e requer uma ação a ser executada no |
||||||
|
split (assim como alguns comandos requerem uma movimentação). |
||||||
|
|
||||||
|
## [Ctrl]wj ou [Ctrl]w[direcional para baixo] |
||||||
|
|
||||||
|
Move o cursor para o split abaixo do atual. Se não houverem outros splits |
||||||
|
abaixo do atual, permanece no mesmo. Aceita um número de repetiçoes, ou seja, |
||||||
|
`3[Ctrl]wj` irá imediatamente pular para o 3o. split abaixo do atual. |
||||||
|
|
||||||
|
## [Ctrl]wh ou [Ctrl]w[direcional para a esquerda] e [Ctrl]wk ou [Ctrl]w[direcional para cima] e [Ctrl]wl ou [Ctrl]w[direcional para a direita] |
||||||
|
|
||||||
|
O mesmo que [Ctrl]wj, mas indo para o split da esquerda, acima ou direita, |
||||||
|
respectivamente. |
||||||
|
|
||||||
|
## [Ctrl]w+ e [Cltr]w- |
||||||
|
|
||||||
|
Aumenta ou diminui o tamanho do split em uma linha. Se for passado um número |
||||||
|
antes do comando -- por exemplo `3[Ctrl]w+` -- o número de linhas afetas será o |
||||||
|
número indicado. |
||||||
|
|
||||||
|
## [Ctrl]w> e [Ctrl]w< |
||||||
|
|
||||||
|
O mesmo que `[Ctrl]w+` e `[Ctrl]w-`, mas altera o número de colunas ao invés do número de linhas. |
||||||
|
|
||||||
|
## [Ctrl]w\_ e [Ctrl]w| |
||||||
|
|
||||||
|
Deixa o split com o maior altura possível (ou seja, coloca o máximo de linhas |
||||||
|
possíveis para o split) ou com a maior largura possível (ou seja, coloca o |
||||||
|
máximo de colunas possíveis para o split). |
||||||
|
|
||||||
|
## [Ctrl]w= |
||||||
|
|
||||||
|
Altera o tamanho dos splits para que estes fiquem o mais equilibrados |
||||||
|
possíveis. |
||||||
|
|
||||||
|
## [Ctrl]wH, [Ctrl]wJ, [Ctrl]wK,/tt> e [Ctrl]wL |
||||||
|
|
||||||
|
Move o split atual para o canto mais a esquerda, abaixo, acima ou direita, |
||||||
|
respectivamente (note que a letra de movimentação está em maiúsculas). |
||||||
|
|
||||||
|
## [Ctrl]ww |
||||||
|
|
||||||
|
Move o cursor para o split anterior. Se você está em um split qualquer e fizer |
||||||
|
`3[Ctrl]wj` para ir para o 3<sup>o</sup> split abaixo do atual, `[Ctrl]ww` irá |
||||||
|
mover o cursor de volta para o split original (e `[Ctrl]ww` irá mover o cursor |
||||||
|
de volta para o 3<sup>o</sup> split abaixo do atual). |
||||||
|
|
||||||
|
## [Ctrl]wf |
||||||
|
|
||||||
|
Abre o arquivo com o nome sob o cursor em um novo split. |
||||||
|
|
||||||
|
Quando falei do grep, eu comentei que existe o comando `:cope` para abrir a |
||||||
|
janela do Quickfix. Bom, se você quiser ficar pulando entre a janela do |
||||||
|
Quickfix e o texto, os comandos `[Ctrl]w` acima irão ajudar. |
||||||
|
|
||||||
|
Existem ainda alguns outros comandos para splits, mas veremos estes mais a |
||||||
|
frente. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./08-localizar-substituir", prev_chapter_title="Localizar e Substituir", next_chapter_link="./10-abas", next_chapter_title="Abas") }} |
After Width: | Height: | Size: 68 KiB |
@ -0,0 +1,44 @@ |
|||||||
|
+++ |
||||||
|
title = "Abas" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte me que você acha coisas que já fazia antes. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Além dos splits, que vimos no capítulo anterior, VIM também tem suporte à abas. |
||||||
|
O mais interessante é que você pode usar abas tanto no VIM gráfico (também |
||||||
|
chamado de GVim) quanto no console. |
||||||
|
|
||||||
|
Para abrir um arquivo no VIM, sabemos que temos que usar o comando `:e`; para |
||||||
|
abrir o arquivo em uma aba, o comando é `:tabe`. |
||||||
|
|
||||||
|
Ao contrário de splits, criar uma nova aba sem passar um arquivo não cria uma |
||||||
|
nova aba com o buffer atual; `:tabe` sem um nome de arquivo irá criar uma nova |
||||||
|
aba com um buffer em branco. E sim, você pode abrir o mesmo arquivo em mais de |
||||||
|
uma aba e as alterações feitas em uma irão refletir na outra. |
||||||
|
|
||||||
|
Para pular entre abas, você poder usar o comando `gt` em modo normal ou `:tabn` em |
||||||
|
modo de comando. Se você usar um número de repetições (p.ex. `3gt` ou `:tabn 3`) o |
||||||
|
VIM irá pular diretamente para aquela aba (no caso, para a terceira), não |
||||||
|
importando a aba atual. `gT` em modo normal ou `:tabp` move o cursor para a aba |
||||||
|
anterior. |
||||||
|
|
||||||
|
Se quiser mover abas de posição, você deve usar `:tabm`. `:tabm` irá mover a aba |
||||||
|
atual para ficar depois da aba indicada (p.ex., `:tabm 3` irá mover a aba atual |
||||||
|
para depois da terceira aba). `:tabm` também aceita parâmetros considerando a aba |
||||||
|
atual: `:tabm +2` irá mover a aba atual duas abas pra frente (para a direita) e |
||||||
|
`:tabm -2` irá mover a aba duas abas pra trás (para a esquerda). |
||||||
|
|
||||||
|
Atalhos padrão para mover para a próxima aba do sistema operacional também são |
||||||
|
aceitos por padrão. `[Ctrl][PageDn]` e `[Ctrl][PageUp]` no Linux e |
||||||
|
`[Command][Shift]]` e `[Command][Shift][` no OS X, por exemplo. Como não existe |
||||||
|
nenhum padrão para consoles, não há nenhum atalho padrão e devem ser usados os |
||||||
|
comandos de seleção de abas que vimos antes. |
||||||
|
|
||||||
|
Mais pra frente, quando estivermos falando do arquivo de configuração, eu vou |
||||||
|
explicar um "truque" para pular diretamente para a aba desejada, assim como |
||||||
|
funciona no Firefox e no Chrome. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./09-splits", prev_chapter_title="Splits", next_chapter_link="./11-config", next_chapter_title="Arquivos de Configuração") }} |
@ -0,0 +1,162 @@ |
|||||||
|
+++ |
||||||
|
title = "Arquivos de Configuração" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que eu menti. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Lembram que bem no começo, quando estávamos falando dos modos de execução, eu |
||||||
|
comentei que o modo Ex não era usado? |
||||||
|
|
||||||
|
Bom, eu menti. MUAHAHAHAHA! |
||||||
|
|
||||||
|
![](muahaha.jpg) |
||||||
|
|
||||||
|
Na verdade, o Modo Ex não é chamado comumente, mas os arquivos de configuração |
||||||
|
do VIM são um grande amontoado de comandos executando em modo Ex. |
||||||
|
|
||||||
|
E o que é o modo Ex, afinal de contas? O modo Ex nada mais é que o modo de |
||||||
|
comando sem a necessidade de usar `:` na frente de todos os comandos. Como |
||||||
|
ficaria complicado para, por exemplo, entrar no modo Ex, executar e arquivo, |
||||||
|
sair do modo ex e entrar em modo de inserção, até o momento temos usado o modo |
||||||
|
de comando para isso, já que economiza um monte de tecladas. Como não iremos |
||||||
|
ficar indo para o modo de inserção o tempo todo, e não faz sentido fazer um |
||||||
|
arquivo gigantesco com várias linhas começando com `:`, também faz sentido que o |
||||||
|
arquivo de configuração seja executado em modo Ex. |
||||||
|
|
||||||
|
O VIM tem um arquivo de configuração global (conhecido com "vimrc") e um arquivo |
||||||
|
para execução em modo gráfico ("gvimrc")[^1]. Ainda, existem duas versões de cada |
||||||
|
um destes arquivos: uma versão global para todos os usuários e uma versão |
||||||
|
definida para o usuário atual. Daqui pra frente, iremos ver as configurações do |
||||||
|
usuário, já que estas sobrepõem as globais. |
||||||
|
|
||||||
|
"vimrc" e "gvimrc" ficam no diretório dos dados do usuário; em qualquer um dos |
||||||
|
sistemas operacionais hoje, você consegue descobrir o diretório destes arquivos |
||||||
|
com `:echo $HOME` dentro do próprio VIM. Apenas note que embora eu venho chamando |
||||||
|
os arquivos de vimrc e gvimrc, os nomes são, na verdade, ".vimrc" e ".gvimrc" (ou |
||||||
|
"\_vimrc" e "\_gvimrc" no caso do Windows). |
||||||
|
|
||||||
|
Como existem muitas opções, não vou aqui explicar cada uma delas -- mas, no |
||||||
|
próximo capítulo eu vou mostrar o arquivo que eu estou usando para servir de |
||||||
|
guia. |
||||||
|
|
||||||
|
O que você vai ver quando abrir um arquivo de configuração: |
||||||
|
|
||||||
|
## set |
||||||
|
|
||||||
|
`set` é, efetivamente, a forma de "setar" alguma configuração no VIM. |
||||||
|
|
||||||
|
Existem dois tipos de configurações: As com valores e flags. |
||||||
|
|
||||||
|
Flags é mais fácil de ser explicado: você simplesmente seta a configuração. Por |
||||||
|
exemplo, fazer com que o VIM mostre uma coluna com o número de cada linha, |
||||||
|
você pode usar `:set number` (ou simplesmente `set number` dentro do arquivo de |
||||||
|
configuração). Para desligar uma opção deste tipo, você só precisa adicionar |
||||||
|
"no" na frente (para desligar number é usado `:set nonumber`). |
||||||
|
|
||||||
|
"Valores" é exatamente o que significa: Ao invés de ser uma simples flag, a |
||||||
|
opção recebe uma string ou número. Por exemplo, `:set tabstop=4` irá definir que |
||||||
|
o tamanho da tabulação é de 4 espaços. `:set notabstop` não tem efeito aqui, já |
||||||
|
que não é uma flag. |
||||||
|
|
||||||
|
Para fazer com que uma configuração volte ao seu valor/estado original, use |
||||||
|
`:set {opção}&`; para verificar o valor de uma opção, use `:set {opção}?`. |
||||||
|
|
||||||
|
Talvez a coisa não esteja muito clara aqui, mas quando examinarmos um arquivo |
||||||
|
de configuração real, as coisas irão clarear. |
||||||
|
|
||||||
|
## let |
||||||
|
|
||||||
|
`let` é usado para definir o valor de uma variável. Uma variável tem sempre um |
||||||
|
valor -- ou seja, não existem "variáveis flags". Variáveis são normalmente |
||||||
|
utilizadas por plugins ou arquivos de sintaxe e, portanto, as variáveis que |
||||||
|
você terá que usar vão depender do que você está usando. |
||||||
|
|
||||||
|
(Obviamente, se você estiver escrevendo seu próprio plugin — que eu não vou |
||||||
|
abordar aqui — o uso de variáveis vai ser praticamente obrigatório.) |
||||||
|
|
||||||
|
## if |
||||||
|
|
||||||
|
`if`, como em qualquer linguagem de programação, serve para execução |
||||||
|
condicional. Você pode, por exemplo, verificar se alguma feature foi ativada na |
||||||
|
compilação do binário, se alguma opção está ligada, etc. |
||||||
|
|
||||||
|
Por exemplo, para verificar se o suporte à scripts Python foi adicionado, você |
||||||
|
pode fazer: |
||||||
|
|
||||||
|
```viml |
||||||
|
if has('python') |
||||||
|
" configuração em python vai aqui |
||||||
|
end |
||||||
|
``` |
||||||
|
|
||||||
|
Para verificar se alguma opção está ativa: |
||||||
|
|
||||||
|
```viml |
||||||
|
if &compatible |
||||||
|
" configuração em modo de compatibilidade com o VI original |
||||||
|
end |
||||||
|
``` |
||||||
|
|
||||||
|
ou para conferir um valor: |
||||||
|
|
||||||
|
```viml |
||||||
|
if &t_Co > 2 |
||||||
|
" configuração quando há suporte a mais de 2 cores. |
||||||
|
end |
||||||
|
``` |
||||||
|
|
||||||
|
E assim por diante. |
||||||
|
|
||||||
|
## map, imap (e outros) |
||||||
|
|
||||||
|
`map` pode ser usado para mapear teclas para outras funções. Por exemplo `:map Y |
||||||
|
y$` irá mapear "Y" para executar `y$` (copiar da posição atual do cursor até o fim |
||||||
|
da linha). Com excessão de [Shift], qualquer modificador pode ser usado: |
||||||
|
|
||||||
|
* C - para `[Control]` |
||||||
|
* M - para `[Alt]` (que normalmente é chamado de "Meta" em sistemas Unix — e por isso "M") |
||||||
|
* O - para `[Command]` (somente em Macs) |
||||||
|
|
||||||
|
Por exemplo, `:map C-m yy` irá adicionar `[Ctrl]m` para copiar a linha inteira. |
||||||
|
|
||||||
|
Ainda, a diferença entre `map` e `imap` é que `map` é global enquanto que |
||||||
|
`imap` só irá funcionar em modo de inserção (e assim você pode imaginar o que |
||||||
|
`nmap` e `vmap` fazem, certo?) |
||||||
|
|
||||||
|
## au (ou autocmd) |
||||||
|
|
||||||
|
Comandos que são executados em determinadas condições. Condições podem desde |
||||||
|
"FileType" para ações confirme o tipo de arquivo e "BufRead", "BufWrite" e |
||||||
|
relacionados quando um buffer for aberto ou fechado. |
||||||
|
|
||||||
|
O que seriam os "relacionados"? Bom, alem de ser na leitura/escrita do arquivo, |
||||||
|
podem ser adicionados comandos antes da execução ("BufReadPre", "BufWritePre"), |
||||||
|
depois da execução ("BufReadPost", "BufWritePost") e durante ("BufReadCmd", |
||||||
|
"BufWriteCmd"). |
||||||
|
|
||||||
|
(Existem ainda auto-comandos para quando o editor entrar em modo de edição, |
||||||
|
abrir o VIM gráfico, VIM está fechando, e assim por diante. Para ver todos os |
||||||
|
eventos, digite `:help autocmd-events`.) |
||||||
|
|
||||||
|
Por exemplo, `au FileType smarty set ai` para ligar a auto-identação quando VIM |
||||||
|
detectar que você está editando um arquivo Smarty (engine de templates para |
||||||
|
PHP). Ou ainda `au BufRead set nocompatible` irá configurar o editor para entrar |
||||||
|
em modo de não-compatibilidade com VI depois de abrir qualquer arquivo. |
||||||
|
|
||||||
|
Ainda, é possível encadear auto-comandos, por exemplo, `autocmd FileType python |
||||||
|
autocmd BufWritePre :%s/\s\+$//e` irá fazer com que quando o tipo de arquivo for |
||||||
|
"python", seja criado um auto-comando que antes de salvar o arquivo, seja |
||||||
|
executado um comando de substituição no buffer -- que remove espaços em branco |
||||||
|
no final da linha). |
||||||
|
|
||||||
|
(Se você está perdido com o que está vendo aqui, não se preocupe -- a tendência |
||||||
|
é que, ao ver um arquivo de configuração real, você entenda o que está |
||||||
|
acontecendo). |
||||||
|
|
||||||
|
[^1] Existe um terceiro, .exrc, mas honestamente, em todo esse tempo usando o |
||||||
|
VIM, eu nunca tinha ouvido falar que este arquivo sequer existia. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./10-abas", prev_chapter_title="Abas", next_chapter_link="./11-01-vimrc", next_chapter_title="Meu .vimrc") }} |
After Width: | Height: | Size: 55 KiB |
@ -0,0 +1,468 @@ |
|||||||
|
+++ |
||||||
|
title = "Meu .vimrc" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que você vai ver um arquivo de configuração meio |
||||||
|
estranho. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Como falamos sobre arquivo de configuração, eu vou mostrar o que eu tenho hoje |
||||||
|
configurado no meu VIM, explicando o que cada comando faz. Boa parte do que eu |
||||||
|
tenho veio da configuração global do VIM, que eu copiei apenas para garantir |
||||||
|
que não importando onde eu esteja ou qualquer alteração que seja feita neste |
||||||
|
arquivo, as funcionalidades que eu estou acostumado continuarão funcionando |
||||||
|
como esperado. |
||||||
|
|
||||||
|
```viml |
||||||
|
set encoding=utf-8 |
||||||
|
``` |
||||||
|
|
||||||
|
Garante que os arquivos salvos estarão em UTF-8, ao invés de tentar converter |
||||||
|
para o encoding do sistema operacional. |
||||||
|
|
||||||
|
```viml |
||||||
|
set nocompatible |
||||||
|
``` |
||||||
|
|
||||||
|
Desativa o modo de compatilidade com o VI original. Existem algumas diferenças |
||||||
|
entre ambos (por exemplo, depois de um fazer um undo (`u`), no VI original fazer |
||||||
|
undo de novo desfazia o undo anterior (efetivamente, fazendo um "redo") e para |
||||||
|
continuar fazendo undo, o primeiro comando depois de undo deveria ser `.`; no |
||||||
|
VIM, fazer um undo depois de um undo irá continuar desfazendo o que foi entrado |
||||||
|
no texto, até retornar ao estado original) e a não ser que você seja fã do VI |
||||||
|
original, eu não recomendaria usar o modo de compatilibidade. |
||||||
|
|
||||||
|
```viml |
||||||
|
set backspace=indent,eol,start |
||||||
|
``` |
||||||
|
|
||||||
|
Apenas garante que o backspace consiga remover identações, apagar o fim da |
||||||
|
linha e o começo de uma linha (neste último, forçando a linha atual e se juntar |
||||||
|
com a anterior). Esse é o funcionamento normal de qualquer editor. |
||||||
|
|
||||||
|
```viml |
||||||
|
" Don’t use Ex mode, use Q for formatting |
||||||
|
map Q gq |
||||||
|
|
||||||
|
" Map Y to do the same (well, almost) as the D command |
||||||
|
map Y y$ |
||||||
|
``` |
||||||
|
|
||||||
|
Estes dois mapeamentos eu peguei da configuração global, mas nunca efetivamente |
||||||
|
usei. Mas, por via das dúvida... |
||||||
|
|
||||||
|
Ainda, uma coisa que eu não havia comentado: Comentários. Você pode comentar |
||||||
|
qualquer linha começando a mesma com aspas (") sem as aspas finais (senão o VIM |
||||||
|
irá interpretar o conteúdo como string). Então: Uma aspa, comentário; duas |
||||||
|
aspas, string; mais de duas, erro. |
||||||
|
|
||||||
|
```viml |
||||||
|
if &t_Co > 2 ||& |
||||||
|
syntax on |
||||||
|
set hlsearch |
||||||
|
endif |
||||||
|
``` |
||||||
|
|
||||||
|
Ah, nosso primeiro encontro com ifs. Se o terminal tiver mais de duas cores |
||||||
|
(`&t_Co > 2`) ou estivermos rodando em GUI (`has("gui_running")`) então o |
||||||
|
suporte à sintaxes deve ser ligado (`syntax on`) e pesquisas devem marcar todas |
||||||
|
as ocorrências encontradas no último comando de pesquisa(`set hlsearch`)[^1]. |
||||||
|
|
||||||
|
```viml |
||||||
|
" ------------------------ |
||||||
|
" Those are my settings |
||||||
|
" ------------------------ |
||||||
|
|
||||||
|
set tabstop=4 " tabs are displayed as 4 spaces |
||||||
|
set shiftwidth=4 " by default, when auto-identing, add 4 spaces (or 1 tabstop) |
||||||
|
set foldmethod=marker " fold on markers |
||||||
|
set scrolloff=1 " always show one line around the cursor |
||||||
|
set laststatus=2 " always show the status bar (’cause I like to see the line and column, always) |
||||||
|
set showtabline=2 " always show the tabline |
||||||
|
set showmatch " show matching bracket |
||||||
|
set noerrorbells " no error bells |
||||||
|
set autowrite " write the file when switching between files or something |
||||||
|
set nowrap " do not wrap long lines |
||||||
|
set nobackup " do not keep a backup file, use versions instead |
||||||
|
set history=50 " keep 50 lines of command line history |
||||||
|
set ruler " show the cursor position all the time |
||||||
|
set showcmd " display incomplete commands |
||||||
|
set incsearch " do incremental searching |
||||||
|
set formatoptions=tcq " wrap with textwidth, wrap comments, insert commend leader (twice), format comments |
||||||
|
set smartindent " smart identation |
||||||
|
set number " show line numbers |
||||||
|
set wim=longest,list " file auto-completion |
||||||
|
set background=dark " to follow most of the colorschemes I use |
||||||
|
set vb t_vb= " convert bells to visual bells and do nothing as visual bell |
||||||
|
|
||||||
|
set t_Co=256 " 256 color terminals |
||||||
|
|
||||||
|
let mapleader="," " use comma to start user-defined (in plugins) functions |
||||||
|
``` |
||||||
|
|
||||||
|
Um grande bloco de configurações. Vamos ver um por um: |
||||||
|
|
||||||
|
* `set tabstop=4`: Define o tamanho da tabulação. Se estiver usando o caractere |
||||||
|
"tab" ao invés de espaço, estes caracteres serão mostrados como 4 espaços |
||||||
|
(quando o padrão são 8). |
||||||
|
* `set shiftwidth=4`: Quando o VIM for identar um pedaço de texto sozinho[^2]. Se |
||||||
|
"shiftwidth" for igual a "tabstop" e você não tiver configurado para usar |
||||||
|
espaços ao invés de tabulações (calma que eu já explico como se faz isso), o |
||||||
|
VIM irá adicionar uma tabulação inteira; se "shiftwidth" for menor que |
||||||
|
"tabstop", espaços serão usados; se "shiftwidth" for maior que "tabstop", |
||||||
|
será usada uma mistura de tabulações e espaços até que o tamanho especificado |
||||||
|
seja alcançado. |
||||||
|
* `set foldmethod=marker`: "Folding" foi algo que eu não comentei até agora |
||||||
|
porque eu até agora não consegui me aclimatar com folding (até porque eu não |
||||||
|
consegui pensar num mnemônico para lembrar dos comandos). Mas, basicamente, |
||||||
|
"folding" permite que você "oculte" partes do código com alguma condição. |
||||||
|
Alguns arquivos de sintaxe definem início e fim de funções e isso pode ser |
||||||
|
usado para ocultar toda uma função (apenas para exibição, a função continua |
||||||
|
existindo lá). "marker" define que o método de folding são marcadores e os |
||||||
|
marcadores padrão são "\{\{\{" para o início e "\}\}\}" para o fim. |
||||||
|
* `set scrolloff=1`: Número de linhas que devem sempre ficar visíveis ao redor do |
||||||
|
cursor. "1" significa que antes de chegar à primeira ou última linha da tela, |
||||||
|
o VIM irá rolar o texto e apresentar a linha anterior (ou próxima) -- enquanto |
||||||
|
possível. |
||||||
|
* `set laststatus=2`: Quando estávamos vendo splits, você deve ter notado que o |
||||||
|
VIM adicionou uma barrinha indicando a posição do cursor (e talvez mais |
||||||
|
algumas outras informações). Esse é o padrão para "1" (mostrar a barra de |
||||||
|
status quando houver splits); "0" nunca mostra e "2" mostra sempre. |
||||||
|
* `set showtabline=2`: Assim como "laststatus", se você estava vendo abas em modo |
||||||
|
de console, deve ter reparado que a linha com as abas aparecia apenas quando |
||||||
|
haviam duas ou mais abas. "2" define que essa linha de abas deve ser sempre |
||||||
|
mostrada, mesmo quando há apenas uma aba. |
||||||
|
* `set showmatch`: Quando estiver sobre um caractere como parênteses, colechetes |
||||||
|
ou chave, faz o highlight do elemento que abre ou fecha o correspondente. |
||||||
|
* `set noerrorbells`: Se ocorrer um erro, não utilize erros sons para |
||||||
|
notificações[^3]. |
||||||
|
* `set autowrite`: Quando o VIM passar o controle para outro aplicativo ("grep", |
||||||
|
"make" ou mesmo o "shell"), salva o arquivo atual antes de passar a execução. |
||||||
|
* `set nowrap`: Quando uma linha for maior que a tela, desabilita a "quebra" da |
||||||
|
linha e, com isso, é necessário "rolar" o conteúdo horizontalmente para ver o |
||||||
|
resto. Um aviso: se você usar "wrap" (`set wrap`) o VIM vai continuar lidando a |
||||||
|
linha como uma coisa só, desconsiderando como a mesma está sendo apresentada; |
||||||
|
assim, se você estiver na primeira parte de uma linha que foi quebrada por |
||||||
|
wrap, usar qualquer comando que vá para a próxima linha irá ir para a próxima |
||||||
|
linha, não para a parte quebrada. |
||||||
|
* `set nobackup`: Não grava arquivos de backup. Por padrão, antes de salvar um |
||||||
|
arquivo, o VIM guarda uma cópia do original com o mesmo nome seguido de "~". |
||||||
|
* `set history=50`: Quando você usa um comando, o VIM pode guardar esse comando |
||||||
|
para execução futura, como o prompt do shell. Aqui é definido quantos destes |
||||||
|
comandos são guardados. |
||||||
|
* `set ruler`: Sempre que possível, mostre a posição do cursor. Se "laststatus" |
||||||
|
for "0" (ou "1" e não houver nenhum split), a posição é exibida na última |
||||||
|
linha da tela, no canto direito; se "laststatus" for "2" (ou "1" e houver |
||||||
|
pelo menos um split), a posição é exibida dentro da barra de status[^4]. |
||||||
|
* `set showcmd`: Você deve ter notado que comandos que esperam mais informações |
||||||
|
(por exemplo, aqueles que requerem uma movimentação) não são mostrados em |
||||||
|
lugar algum. "showcmd" irá mostrar o comando até que ele seja concluído. |
||||||
|
* `set incsearch`: Enquanto você estiver digitando uma pesquisa, já vai |
||||||
|
posicionando o cursor na primeira ocorrência encontrada. "noincsearch" irá |
||||||
|
manter o cursor na mesma posição até que o mesmo seja concluído. |
||||||
|
* `set formatoptions=tcq`: Opções de formatação de textos. Cara um dos caracteres |
||||||
|
representa algo diferente: "t" indica que se "textwidth" estiver definido, o |
||||||
|
editor deve quebrar as linhas[^5]; "c" significa que se o texto for quebrado |
||||||
|
durante um comentário (definido pela sintaxe atual), um novo caractere de |
||||||
|
comentário deve ser adicionado; "q" indica que comentários podem ser |
||||||
|
quebrados por "textwidth". |
||||||
|
* `set smartindent`: Utiliza identação inteligente, se a sintaxe não definir |
||||||
|
nenhuma. Existem quatro tipos de identação: Nenhuma ("nosmartindent") |
||||||
|
indicando que ao adicionar uma nova linha, nenhuma identação é adicionada; |
||||||
|
"autoindent" para que novas linhas tenham a mesma identação da linha |
||||||
|
anterior; "smartindent", que tenta usar o último caractere da linha para |
||||||
|
identificar se deve ser adicionada uma nova identação ou não (por exemplo, |
||||||
|
parênteses e chaves adicionam identação); e "cindent" que tenta seguir o |
||||||
|
padrão para C. Note que essa configuração só vale para arquivos que não |
||||||
|
definem uma identação no seu arquivo de sintaxe (que são bem poucos). |
||||||
|
* `set number`: Adiciona uma área na esquerda da tela com o número da linha na |
||||||
|
própria linha. |
||||||
|
* `set wim=longest,list`: Duas coisas aqui: 1) comandos de set tem um nome |
||||||
|
longo e um nome curto e "wim" é o nome curto para "wildmode"; 2) "wildmode" |
||||||
|
define como serão completados os nomes dos arquivos quando você usar um |
||||||
|
comando para abrir arquivos e usar [Tab] para tentar completar o nome do |
||||||
|
arquivo automaticamente. "longest,list" emula o padrão de shells como Bash. |
||||||
|
* `set background=dark`: Alguns colorschemes (temas de cor) definem dois |
||||||
|
padrões de cores, um claro e um escuro. "background=dark" define que, na |
||||||
|
existência de dois padrões, o padrão escuro deve ser usado. |
||||||
|
* `set vb t_vb=:` Mais uma coisa nova: Duas configurações em uma linha só. Na |
||||||
|
verdade, todas as configurações apresentadas aqui poderiam ficar em uma linha |
||||||
|
só, mas eu mantive estas duas juntas por um motivo: Como defini |
||||||
|
"noerrorbell", o VIM cai para "visualbell" (nome longo de "vb"), que causa um |
||||||
|
"flash" no conteúdo (as cores do tema rapidamente se invertem e voltam ao |
||||||
|
normal) quando ocorre um erro; no caso, eu defini que sim, eu quero que o |
||||||
|
tipo de erro visual ("`t_vb`") seja... nada. Assim, quando ocorre um erro, o VIM |
||||||
|
não bipa nem faz flash. |
||||||
|
* `set t_Co=256`: Define que o terminal terá, por padrão, 256 cores. Algumas |
||||||
|
vezes o VIM não consegue descobrir se o terminal tem suporte a mais de 16 |
||||||
|
cores ou não e esta configuração reafirma que sim, o terminal é capaz de usar |
||||||
|
256 e, portanto, colorschemes podem ter mais cores. |
||||||
|
* `let mapleader=","`: Define a variável "mapleader". "mapleader" é o caractere |
||||||
|
que o VIM utiliza em alguns plugins[^5], quando estes define comandos em modo |
||||||
|
normal. O padrão é "/", eu mudei para vírgula. |
||||||
|
|
||||||
|
```viml |
||||||
|
if has("autocmd") |
||||||
|
``` |
||||||
|
|
||||||
|
Eu falei sobre auto-commands, mas na verdade é uma feature que deve ser |
||||||
|
adicionada na hora de compilar o VIM. Entretanto, até agora eu não vi um pacote |
||||||
|
disponível que não tenha essa feature. Apenas para garantir, verificamos se a |
||||||
|
funcionalidade foi adicionada mesmo ou não. |
||||||
|
|
||||||
|
Boa parte do que tem daqui pra frente ou eu já falei ou veio do arquivo de |
||||||
|
configuração global. |
||||||
|
|
||||||
|
```viml |
||||||
|
filetype plugin indent on |
||||||
|
``` |
||||||
|
|
||||||
|
Ativa as configurações vindas do arquivo de sintaxe. Quando eu disse que as |
||||||
|
configurações de auto-identação vem do arquivo de sintaxe, é esta linha que |
||||||
|
garante que isso vai acontecer. |
||||||
|
|
||||||
|
```viml |
||||||
|
autocmd FileType text setlocal textwidth=78 |
||||||
|
``` |
||||||
|
|
||||||
|
Quando o tipo de arquivo for texto ("text") define localmente para aquele |
||||||
|
buffer que o tamanho da linha é de 78 colunas. Como "formatoptions" tem um "t", |
||||||
|
o VIM irá automaticamente quebrar a linha (adicionando um [Enter] antes da |
||||||
|
palavra que passa do limite) na coluna 78.[^7] |
||||||
|
|
||||||
|
```viml |
||||||
|
" When editing a file, always jump to the last known cursor position. |
||||||
|
" Don’t do it when the position is invalid or when inside an event handler |
||||||
|
" (happens when dropping a file on gvim). |
||||||
|
autocmd BufReadPost * |
||||||
|
\ if line("’\"") > 0 && line("’\"") <= line("$") | |
||||||
|
\ exe "normal g`\"" | |
||||||
|
\ endif |
||||||
|
``` |
||||||
|
|
||||||
|
Este comando existe no arquivo de configuração global, mas é bem interessante. |
||||||
|
Lendo exatamente o que ele faz: Depois de carregar qualquer arquivo, se a linha |
||||||
|
que o marcador de saída do buffer existir e estiver entre o começo do arquivo e |
||||||
|
antes do fim da linha, executa, em modo normal, `g\"`, que efetivamente "pula" |
||||||
|
para o marcador de saída do buffer. A diferença entre `\`` e `g\``` é que `g`` não mexe |
||||||
|
no jumplist quando pular (logo, ```` não vai funcionar). Como não mexer no |
||||||
|
jumplist é algo que não se faz normalmente, nem comentei antes. |
||||||
|
|
||||||
|
```viml |
||||||
|
autocmd FileType python autocmd BufWritePre <buffer> :%s/\s\+$//e |
||||||
|
``` |
||||||
|
|
||||||
|
Eu falei deste comando antes, mas vamos de novo: Quando o tipo de arquivo for |
||||||
|
"python", adicione um auto-comando que antes de gravar o buffer, execute, no |
||||||
|
buffer, a expressão regular `/\s\+$//e`, que basicamente, serve para remover |
||||||
|
espaços em branco no final das linhas. |
||||||
|
|
||||||
|
```viml |
||||||
|
" omni completion |
||||||
|
au FileType python setlocal ofu=pythoncomplete#Complete |
||||||
|
au FileType javascript setlocal ofu=javascriptcomplete#CompleteJS |
||||||
|
au FileType html setlocal ofu=htmlcomplete#CompleteTags |
||||||
|
au FileType css setlocal ofu=csscomplete#CompleteCSS |
||||||
|
au FileType xml setlocal ofu=xmlcomplete#CompleteTags |
||||||
|
au FileType php setlocal ofu=phpcomplete#CompletePHP |
||||||
|
|
||||||
|
set completeopt-=preview |
||||||
|
``` |
||||||
|
|
||||||
|
Eu não falei do Omni-complete antes porque até o momento o auto-complete |
||||||
|
(`[Ctrl]p` e `[Ctrl]n` em modo de inserção) tem resolvido todos meus problemas. |
||||||
|
Mas, em teoria, o omni-complete consegue detectar quais elementos fazem sentido |
||||||
|
no contexto atual, "encherga" coisas que estão no arquivo de tags e conhece |
||||||
|
toda a sintaxe da linguagem que você está usando. Mas, realmente, o simples |
||||||
|
auto-complete já resolve 99% dos problemas que tenho encontrado. |
||||||
|
|
||||||
|
E desliga a apresentação dos resultados do omni-complete na janela de preview, |
||||||
|
que é semelhante ao quickfix, mas na minha experiência, ela quebra muito o |
||||||
|
fluxo de edição do código. |
||||||
|
|
||||||
|
Se você quiser tentar, para usar o omni complete basta usar `[Ctrl]x` seguido de |
||||||
|
`[Ctrl]o`. |
||||||
|
|
||||||
|
```viml |
||||||
|
" ------------------------ |
||||||
|
" Auto-commands |
||||||
|
" ------------------------ |
||||||
|
|
||||||
|
" default python style |
||||||
|
" (use spaces instead of tabs (expandtab), uses 4 spaces for tabs (tabstop), |
||||||
|
" when auto-indenting, also use 4 spaces (shiftwidth), when deleting text, 4 |
||||||
|
" spaces are a tab (softtabstop) and break the line at column 78 (textwidth)) |
||||||
|
au FileType python setlocal expandtab tabstop=4 shiftwidth=4 softtabstop=4 textwidth=78 |
||||||
|
|
||||||
|
" reStructured files follow python closely, but use 3 tab stops instead of 4 |
||||||
|
au FileType rst setlocal expandtab tabstop=3 sw=3 sts=3 textwidth=78 |
||||||
|
|
||||||
|
" templates (Jinja2 in this case) will use tabs instead (to reduce file size) |
||||||
|
au FileType htmldjango setlocal noet tabstop=4 shiftwidth=4 softtabstop=4 textwidth=0 |
||||||
|
au FileType jinja setlocal noet tabstop=4 shiftwidth=4 softtabstop=4 textwidth=0 |
||||||
|
|
||||||
|
" the smarty filetypes doesn’t have any sort of indentation, so we set it to |
||||||
|
" auto |
||||||
|
au FileType smarty setlocal ai |
||||||
|
|
||||||
|
" PHP break lines at column 79, like Python |
||||||
|
au FileType php setlocal textwidth=79 |
||||||
|
|
||||||
|
" svn (when editing svn commit messages, break lines at |
||||||
|
" column 70) |
||||||
|
au FileType svn setlocal tw=70 |
||||||
|
|
||||||
|
" email (mostly mutt stuff) |
||||||
|
au FileType mail setlocal spell spelllang=en |
||||||
|
|
||||||
|
" JavaScript (who though those were "good" defaults?) |
||||||
|
au FileType javascript setlocal expandtab tabstop=2 sw=2 sts=2 textwidth=0 |
||||||
|
``` |
||||||
|
|
||||||
|
Uma série de auto-comandos baseados no tipo de arquivo. Como eu falei antes |
||||||
|
neste capítulo, você pode botar vários "set" um atrás do outro separados por |
||||||
|
espaço e sets tem versões com nomes longos e nomes curtos ("sts" é um atalho |
||||||
|
para "softtabstop", "sw" para "shiftwidth", "noet" para "noexpandtabs", "ai" |
||||||
|
para "autoindent" e "tw" para "textwidth"). E sim, eu sei que não manti nenhum |
||||||
|
padrão no meio, mas pelo menos agora você alguns nomes curtos para algumas |
||||||
|
opções. |
||||||
|
|
||||||
|
```viml |
||||||
|
else |
||||||
|
set autoindent " always set autoindenting on |
||||||
|
endif " has("autocmd") |
||||||
|
``` |
||||||
|
|
||||||
|
E, se autocmd não estiver disponível, simplesmente seta auto-indent. |
||||||
|
|
||||||
|
```viml |
||||||
|
" ------------------------ |
||||||
|
" mapings |
||||||
|
" ------------------------ |
||||||
|
|
||||||
|
" Easy switching between tabs (just use Alt+<tab number>) |
||||||
|
if has(‘mac’) |
||||||
|
map <D-1> :tabn 1<CR> |
||||||
|
map <D-2> :tabn 2<CR> |
||||||
|
map <D-3> :tabn 3<CR> |
||||||
|
map <D-4> :tabn 4<CR> |
||||||
|
map <D-5> :tabn 5<CR> |
||||||
|
map <D-6> :tabn 6<CR> |
||||||
|
map <D-7> :tabn 7<CR> |
||||||
|
map <D-8> :tabn 8<CR> |
||||||
|
map <D-9> :tabn 9<CR> |
||||||
|
map <D-0> :tabn 10<CR> |
||||||
|
|
||||||
|
imap <D-1> <ESC>:tabn 1<CR>a |
||||||
|
imap <D-2> <ESC>:tabn 2<CR>a |
||||||
|
imap <D-3> <ESC>:tabn 3<CR>a |
||||||
|
imap <D-4> <ESC>:tabn 4<CR>a |
||||||
|
imap <D-5> <ESC>:tabn 5<CR>a |
||||||
|
imap <D-6> <ESC>:tabn 6<CR>a |
||||||
|
imap <D-7> <ESC>:tabn 7<CR>a |
||||||
|
imap <D-8> <ESC>:tabn 8<CR>a |
||||||
|
imap <D-9> <ESC>:tabn 9<CR>a |
||||||
|
imap <D-0> <ESC>:tabn 10<CR>a |
||||||
|
else |
||||||
|
map <M-1> :tabn 1<CR> |
||||||
|
map <M-2> :tabn 2<CR> |
||||||
|
map <M-3> :tabn 3<CR> |
||||||
|
map <M-4> :tabn 4<CR> |
||||||
|
map <M-5> :tabn 5<CR> |
||||||
|
map <M-6> :tabn 6<CR> |
||||||
|
map <M-7> :tabn 7<CR> |
||||||
|
map <M-8> :tabn 8<CR> |
||||||
|
map <M-9> :tabn 9<CR> |
||||||
|
map <M-0> :tabn 10<CR> |
||||||
|
|
||||||
|
imap <M-1> <ESC>:tabn 1<CR>a |
||||||
|
imap <M-2> <ESC>:tabn 2<CR>a |
||||||
|
imap <M-3> <ESC>:tabn 3<CR>a |
||||||
|
imap <M-4> <ESC>:tabn 4<CR>a |
||||||
|
imap <M-5> <ESC>:tabn 5<CR>a |
||||||
|
imap <M-6> <ESC>:tabn 6<CR>a |
||||||
|
imap <M-7> <ESC>:tabn 7<CR>a |
||||||
|
imap <M-8> <ESC>:tabn 8<CR>a |
||||||
|
imap <M-9> <ESC>:tabn 9<CR>a |
||||||
|
imap <M-0> <ESC>:tabn 10<CR>a |
||||||
|
endif |
||||||
|
``` |
||||||
|
|
||||||
|
Ok, este é um mapeamento que eu sempre achei interessante: |
||||||
|
|
||||||
|
1. Existe uma diferença entre OS X e outros sistemas que a tecla "Command" é |
||||||
|
usada para praticamente tudo, inclusive trocar as abas nos browsers; já em |
||||||
|
outros sistemas, a tecla para isto é "Alt". Um VIM compilado para OS X tem, |
||||||
|
estranhamente, uma feature chamada "mac"; checando isso você consegue |
||||||
|
descobrir se está rodando num OS X ou não. |
||||||
|
|
||||||
|
2. Mapeamentos diferentes para modo normal e de inserção: Se estiver no modo |
||||||
|
normal, basta usar `:tabn {número}` para pular diretamente para uma aba (`:tabn |
||||||
|
{número}` é a versão de modo de comando do `{número}gt` do modo normal[^8][^9]); |
||||||
|
quando estiver em modo de inserção, saida do modo de inserção (simulando |
||||||
|
pressionar [Esc] com <ESC>, execute o mesmo comando usado no modo normal |
||||||
|
para pular para uma aba específica e volte para o modo de inserção ("a"). |
||||||
|
|
||||||
|
BOOM! Você acabou de adicionar no VIM uma feature que existe nos browsers. |
||||||
|
|
||||||
|
```viml |
||||||
|
" custom PHP syntax file configuration |
||||||
|
let php_smart_members=1 |
||||||
|
``` |
||||||
|
|
||||||
|
Essa é uma das coisas que eu falei antes: "let" permite definir variáveis, |
||||||
|
incluindo algumas dentro do arquivo de sintaxe. No caso "php_smart_members" |
||||||
|
altera a forma como funções membro de uma classe em PHP seja coloridas de forma |
||||||
|
diferente. |
||||||
|
|
||||||
|
O resto do meu arquivo de configuração é usado para manter plugins, que eu vou |
||||||
|
explicar o que cada um faz mais pra frente. Se você quiser ver o arquivo |
||||||
|
original, ele pode ser encontrado no meu repositório de configurações (que eu |
||||||
|
uso para manter as configurações sincronizadas entre meu computador pessoal e o |
||||||
|
computador do trabalho). |
||||||
|
|
||||||
|
[^1] Apenas para fazer um gancho com o que foi falado anteriormente: No |
||||||
|
capítulo #2.5, quando estava falando de comandos do modo de comando, eu |
||||||
|
comentei sobre `:noh` para desmarcar as ocorrências encontradas no último |
||||||
|
comando de pesquisa. Bom, `hlsearch` faz com que estas ocorrências sejam |
||||||
|
marcadas e se você colocar set `nohlsearch`, nenhuma ocorrência será marcada |
||||||
|
e você nunca irá precisar usar `:noh`. |
||||||
|
|
||||||
|
[^2] ... ou quando você usar `>{movimentação}` ou `<{movimentação}` em modo normal, |
||||||
|
que eu não havia mencionado antes porque estávamos falando de edição de |
||||||
|
qualquer texto e não de código fonte. `>>` irá adicionar um "shiftwidth" |
||||||
|
para a direita e `<<` irá remover um "shiftwidth" na esquerda. |
||||||
|
|
||||||
|
[^3] Aqui acabamos de ver duas configurações de flags: Uma ativando uma |
||||||
|
configuração ("showmatch") e outra desligando ("noerrorbells"). |
||||||
|
|
||||||
|
[^4] Uma pequena nota sobre as posições apresentadas: algumas vezes, você verá |
||||||
|
o VIM apresentar a coluna como "{número}-{número}". Isso acontece |
||||||
|
principalmente quando se está usando tabulações ao invés de espaços e o |
||||||
|
VIM está indicando a contagem de caracteres na esquerda e a coluna de |
||||||
|
exibição na direita (ou seja, o valor da direita é {quantidade de |
||||||
|
caracteres menos tabulações} + ({quantidade de tabulações} * {"tabstop"}). |
||||||
|
|
||||||
|
[^5] E quando digo "quebrar" eu quero dizer "quebrar" mesmo: Enquanto que |
||||||
|
"wrap" irá cuidar apenas da apresentação do texto, "textwidth" com |
||||||
|
"formatoptions=t" irá inserir um caractere de nova linha quando a palavra |
||||||
|
digitada ultrapassar o limite indicado. |
||||||
|
|
||||||
|
[^6] Note que o VIM define uma variável para isso, mas nada garante que o autor |
||||||
|
do plugin utilizou essa tecla. Existe um padrão em usar "mapleader" como início |
||||||
|
de comando normal de um plugin, mas nada obriga o autor do plugin à usar |
||||||
|
esta tecla. |
||||||
|
|
||||||
|
[^7] E, recapitulando, para reformatar o parágrafo caso você altere alguma |
||||||
|
coisa no texto, use gq sobre a região do mesmo. O VIM irá considerar o |
||||||
|
"textwidth" na hora de reformatar. |
||||||
|
|
||||||
|
[^8] E não, não são todos os comandos que tem versões tanto em modo normal |
||||||
|
o quanto em modo de comando. |
||||||
|
|
||||||
|
[^9] E porque eu usei `:tabn {número}` ao invés de `{número}gt`? Porque quando eu |
||||||
|
pesquisei como pular de abas, este foi o primeiro resultado que eu encontrei. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./11-config", prev_chapter_title="Arquivos de Configuração", next_chapter_link="./11-02-gvimrc", next_chapter_title="Meu .gvimrc") }} |
@ -0,0 +1,108 @@ |
|||||||
|
+++ |
||||||
|
title = "Meu .gvimrc" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que veremos mais do mesmo. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Na parte de configurações, eu falei de dois arquivos, "vimrc" e "gvimrc". Vocês já |
||||||
|
viram o que eu fiz com meu vimrc, então acho justo que vejam também o que eu |
||||||
|
fiz com o meu gvimrc. |
||||||
|
|
||||||
|
Para que fique claro, vimrc sempre é lido, não importa qual executável do VIM |
||||||
|
você está usando. gvimrc é lido depois do vimrc somente quando você iniciar um |
||||||
|
VIM gráfico. |
||||||
|
|
||||||
|
Como o arquivo é bem menor (já que o grosso da configuração fica no vimrc), |
||||||
|
este é o arquivo inteiro que eu estou usando: |
||||||
|
|
||||||
|
```viml |
||||||
|
set guioptions=aegit " basically, all options, except the scrollbar, menu and toolbar |
||||||
|
set columns=116 " number of columns (uses most of my screen, in this case) |
||||||
|
set cursorline " highlight the line with the cursor |
||||||
|
set colorcolumn=+2 " put a marker at textwidth + 2 |
||||||
|
set linespace=1 " spread the lines a bit, adding a 1px line above all |
||||||
|
|
||||||
|
if has('mac') |
||||||
|
set gfn=monofur:h15 " My screen size sucks, mkay? |
||||||
|
set lines=63 " number of lines, based on my screen size and font |
||||||
|
else |
||||||
|
set gfn=monofur\ for\ Powerline\ 12 |
||||||
|
set lines=54 |
||||||
|
endif |
||||||
|
``` |
||||||
|
|
||||||
|
E explicando: |
||||||
|
|
||||||
|
* `set guioptions=aegit`: Define a aparência do editor em modo gráfico. Eu |
||||||
|
prefiro um editor limpo, sem menus, toolbars ou (e isso talvez soe estranho |
||||||
|
para alguns), sem barra de rolagem. Em ordem, as opções ativas são: |
||||||
|
|
||||||
|
`a`: Quando estiver fazendo a seleção com o modo visual, já copia o selecionado |
||||||
|
para a área de transferência. No caso de sistemas Unix, isso significa que |
||||||
|
selecionar algo com o modo visual é o mesmo que selecionar com o botão da |
||||||
|
esquerda (e que pode ser colado diretamente usando o botão do meio). |
||||||
|
|
||||||
|
`e`: Mostra abas (se estiver configurado para mostrar abas com “showtabline” -- |
||||||
|
que eu configurei para mostrar sempre no meu vimrc). |
||||||
|
|
||||||
|
`g`: Mostra opções do menu desabilitadas. O normal é que opções desabilitadas |
||||||
|
sequer apareçam. Esta opção só faz sentido se o menu estiver presente (com a |
||||||
|
opção m no "guioptions") que, como você pode perceber, eu não estou usando. |
||||||
|
Em alguns sistemas (por exemplo, OS X) o controle do menu não faz sentido |
||||||
|
porque o sistema operacional sempre tem um menu ativo. Assim, quando não há |
||||||
|
necessidade de menu, esta opção é desnecessária; quando não há escapatória do |
||||||
|
menu, pelo menos todas as opções serão visíveis. |
||||||
|
|
||||||
|
`i`: VIM tem um ícone (sim você pode configurar para o que o VIM não mostre um |
||||||
|
ícone em lugar algum). De novo, dependendo do sistema operacional, esta opção |
||||||
|
não tem efeito algum porque o próprio sistema adiciona o ícone do launcher. |
||||||
|
|
||||||
|
`t`: Menus podem ser arrancados (quando possível). Esta é uma funcionalidade |
||||||
|
que o GTK+ até a versão 2 tinha, que permitia que os menus fosse |
||||||
|
"desconectados" da área de menu, o que facilita bastante na hora de |
||||||
|
selecionar colorschemes (e como você pode adicionar um menu a qualquer hora |
||||||
|
com `:set guioptions+=m`, o que eu normalmente faço -- ou melhor, fazia -- era |
||||||
|
adicionar um grupo de novos colorschemes, ativar o menu, "arrancar" o menu de |
||||||
|
colorschemes e sair selecionando opções até achar um colorscheme |
||||||
|
interessante). |
||||||
|
|
||||||
|
* `set columns=116`: Número de colunas da janela do editor. Se a sua tela não |
||||||
|
tiver como apresentar 116 colunas (pelo tamanho da fonte e da tela, ou por |
||||||
|
alguma restrição do gerenciador de janelas), o VIM irá reduzir a quantidade |
||||||
|
de colunas até que a janela caiba completamente. |
||||||
|
|
||||||
|
* `set cursorline`: A linha onde o cursor se encontra tem highlight. E, caso |
||||||
|
você esteja se perguntando, existe um `set cursorcolumn` que mostra a coluna do |
||||||
|
cursor. Tanto "cursorline" quanto "cursorcolumn" funcionam em console, mas a |
||||||
|
forma como a linha é apresentada no meu colorscheme é... estranha.[^1] |
||||||
|
|
||||||
|
* `set colorcolumn=+2`: Define uma coluna para ser marcada com uma cor |
||||||
|
diferente. Se for usado uma opção relacional (não um valor absoluto, mas algo |
||||||
|
começando com "+" ou "-"), então cursorline vai usar o "textwidth" atual. |
||||||
|
|
||||||
|
* `set linespace=1`: Define um espaçamento entre linhas, em pixeis. No caso, |
||||||
|
"1" significa que as linhas terão a altura requisitada pela fonte mais um |
||||||
|
pixel. |
||||||
|
|
||||||
|
* `set lines=???:` Define a quantidade de linhas do editor. Segue todas as |
||||||
|
considerações feitas em “columns”. Ainda, aqui eu estou usando de novo a |
||||||
|
checagem de funcionalidade (`has()`) para ter configurações diferenciadas no OS |
||||||
|
X e em outros sistemas operacionais. |
||||||
|
|
||||||
|
* `set gfn=???`: Define a fonte a ser usada ("gfn" é a forma curta de "guifont"). |
||||||
|
Note que fontes que tem espaço no meio tem que ter os espaços "escapados" |
||||||
|
(com `\` antes do espaço) ou como strings. Se você quiser selecionar alguma |
||||||
|
fonte mas não faz idéia do nome da fonte, use `:set gfn=*` para que o VIM |
||||||
|
mostre o seletor de fontes do sistema; depois que escolher uma fonte, se |
||||||
|
quiser que o VIM descreva como usar, use `:set gfn` e cole o resultado no seu |
||||||
|
arquivo de configuração. |
||||||
|
|
||||||
|
[^1] E, lembrando mais uma vez: Para desligar opções deste tipo, coloque "no" na |
||||||
|
frente. Para desligar o highlight da linha atual do cursor, use `:set |
||||||
|
nocursorline`; para desligar o highlight da coluna atual do cursor, use |
||||||
|
`:set nocursorcolumn`. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./11-01-vimrc", prev_chapter_title="Meu .vimrc", next_chapter_link="./12-modelines", next_chapter_title="Modelines") }} |
@ -0,0 +1,70 @@ |
|||||||
|
+++ |
||||||
|
title = "Modelines" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que você ignora seus arquivos de configuração. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Bom, agora você sabe como configurar seu VIM, mudar configurações baseadas no |
||||||
|
tipo de arquivo... Mas o que fazer se um arquivo tem uma configuração |
||||||
|
completamente diferente do resto? |
||||||
|
|
||||||
|
A solução são modelines. Modelines são linhas que você pode adicionar no seu |
||||||
|
arquivo e o VIM, quando carregar o arquivo, irá mudar suas configurações |
||||||
|
baseadas nesta linha. |
||||||
|
|
||||||
|
A sintaxe da linha é, simplesmente: `vim: set {configurações}:`. |
||||||
|
|
||||||
|
"Mas é um código fonte e se eu colocar um 'vim' no meio, o compilador vai |
||||||
|
reclamar!", você deve estar pensando agora. Acontece que o VIM procura uma linha |
||||||
|
válida em qualquer lugar, desconsiderando a sintaxe atual. Se você colocar o |
||||||
|
modeline dentro de um comentário, o VIM ainda vai encontrar e ainda vai |
||||||
|
processar o modeline e ainda vai trocar as configurações do editor (apenas para |
||||||
|
aquele arquivo). |
||||||
|
|
||||||
|
Por exemplo, para garantir que meus templates Jinja fiquem com a sintaxe |
||||||
|
correta (usando a sintaxe de templates do Django), eu tenho colocado, como |
||||||
|
última linha do arquivo |
||||||
|
|
||||||
|
```django |
||||||
|
{# vim: set ft=htmldjango: #} |
||||||
|
``` |
||||||
|
|
||||||
|
"ft", no caso, é o nome curto para "filetype", que define o tipo de arquivo que |
||||||
|
está sendo usando e qual sintaxe será utilizada. E o par `{#` e `#}` são |
||||||
|
comentários do template e completamente ignorados no resultado final. |
||||||
|
|
||||||
|
Assim como vimos antes, várias configurações podem ser usadas no mesmo set. |
||||||
|
Usando o exemplo acima, se eu quisesse que meus templates usassem tabulações ao |
||||||
|
invés de espaços para identação mas fossem apenas 2 espaços por tabulação, eu |
||||||
|
poderia colocar, no final do arquivo: |
||||||
|
|
||||||
|
```django |
||||||
|
{# vim: set ft=htmldjango noet ts=2 sts=2 sw=2: #} |
||||||
|
``` |
||||||
|
|
||||||
|
O VIM ainda aceita que as opções sejam separadas em vários comandos, com a |
||||||
|
adição de ":": |
||||||
|
|
||||||
|
```django |
||||||
|
{# vim: set ft=htmldjango:set noet:set ts=2:set sts=2:set sw=2: #} |
||||||
|
``` |
||||||
|
|
||||||
|
Mas realmente não faz sentido, faz? |
||||||
|
|
||||||
|
E apenas um aviso: Algumas distribuções Linux desligam modelines no arquivo |
||||||
|
global (adicionando `set nomodeline` no arquivo global) e, assim, modelines são |
||||||
|
completamente ignorados, sob a desculpa de "segurança". Tentando descobrir o |
||||||
|
porque descobri o seguinte: O único comando que pode ser usado em modelines é |
||||||
|
"set", ou seja, não é possível colocar um modeline que abra outro arquivo, ou |
||||||
|
mude o diretório atual ou qualquer outra coisa; nem todas as configurações pode |
||||||
|
ser alteradas (infelizmente, o help do VIM não lista quais são e quais não são |
||||||
|
permitidas); e, aparentemente, a pior forma de "ataque" seria alguém colocar um |
||||||
|
"textwidth" e seu código ficar torto na primeira edição. Se você achar que |
||||||
|
modelines não estão sendo executados, você pode adicionar no seu vimrc `set |
||||||
|
modelines` para que modelines sejam processados (ou troque por uma distribuição |
||||||
|
que não tenha configurações que não fazem sentido). |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./11-02-gvimrc", prev_chapter_title="Meu .gvimrc", next_chapter_link="./13-tags", next_chapter_title="Tags") }} |
@ -0,0 +1,60 @@ |
|||||||
|
+++ |
||||||
|
title = "Tags" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que você vai entender Unix um pouco. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Eu expliquei antes que haviam dois comandos para utilizar tags, `[Ctrl]]` e |
||||||
|
`[Ctrl]t`. Existem duas coisas que eu não expliquei: O que são tags e de onde |
||||||
|
elas vem. |
||||||
|
|
||||||
|
Primeiro, tags são qualquer palavra que o editor encontre no arquivo de tags. E |
||||||
|
o arquivo de tags pode ser definido em `:set tags`. Por padrão, são verificados |
||||||
|
os arquivos `./tags` ("tags" no diretório atual do editor), `./TAGS`, `tags` |
||||||
|
(arquivo "tags" em algum diretório de pesquisa) e `TAGS`. |
||||||
|
|
||||||
|
Acontece que não é qualquer arquivo com este nome que o torna válido. Existem |
||||||
|
um formato específico em que as coisas devem estar declaradas para serem |
||||||
|
detectadas como tags. E o formato é |
||||||
|
|
||||||
|
``` |
||||||
|
{tagname}{tagfile}{tagaddress} |
||||||
|
``` |
||||||
|
|
||||||
|
(onde "tagname" é a tag em si, "tagfile" é o nome do arquivo onde a tag se |
||||||
|
encontra e "tagaddress" é uma expressão Ex para encontrar a tag -- por exemplo, |
||||||
|
"89" para ir para linha 89). |
||||||
|
|
||||||
|
Sim, só isso. E eu sei que manter um arquivo assim é chato horrores, e por isto |
||||||
|
existem ferramentas que já fazem isso. A mais completa de todas é "Exuberant |
||||||
|
CTags"" e pode ser encontrada em praticamente todas as distribuições Linux |
||||||
|
atuais, gerenciadores de pacotes do OS X e ainda vem um pacote para Windows. |
||||||
|
|
||||||
|
A grande vantagem do Exuberant é a quantidade de linguagens suportadas. Assim, |
||||||
|
se você estiver num projeto em Python e depois passar para um projeto em C, |
||||||
|
você ainda pode usar o mesmo aplicativo. |
||||||
|
|
||||||
|
A sintaxe gerado do Exuberant é "ctags {arquivos}", onde "{arquivos}" são os |
||||||
|
arquivos a serem processados (expressões como "\*.py" são válidas) ou, da forma |
||||||
|
mais simples "ctags -R", para que todos os arquivos do diretório atual e |
||||||
|
subdiretórios sejam processados. |
||||||
|
|
||||||
|
Uma vez que este arquivo tenha sido criado, dentro do editor você pode usar |
||||||
|
`[Ctrl]]` para tentar achar a definição da tag (que, com o uso do Exuberant |
||||||
|
significa definição de funções ou definições de variáveis) e `[Ctrl]t` para |
||||||
|
retornar para a localização anterior. Se houver mais de um arquivo com uma |
||||||
|
definição válida, o VIM irá mostrar uma lista das localizações e você poderá |
||||||
|
selecionar qual deve ser acessada. |
||||||
|
|
||||||
|
A única dica que sobra aqui é cuidar com arquivos minificados. Isso porque o |
||||||
|
Exuberant entende arquivos CSS. Não que arquivos CSS sejam um problema, mas o |
||||||
|
Exuberant coloca a expressão regular da linha onde a tag se encontra e, num |
||||||
|
arquivo minificado, a expressão acaba sendo uma linha gigantesca, que fica se |
||||||
|
repetindo em vários lugares do arquivo, deixando-o gigantesco. Se você tiver |
||||||
|
algo desse tipo, use a opção "--exclude={expressão}", onde "{expressão}" é a |
||||||
|
expressão regular que define o nome dos arquivos que devem ser ignorados. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./12-modelines", prev_chapter_title="Modelines", next_chapter_link="./14-01-vundle", next_chapter_title="Plugins - Vundle") }} |
@ -0,0 +1,112 @@ |
|||||||
|
+++ |
||||||
|
title = "Plugins - Vundle" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que começamos a mexer ao redor do VIM. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Vamos começar a ver como adicionar funcionalidades no VIM com plugins. E, para |
||||||
|
isso, vamos ver Vundle, que é um gerenciador de plugins. |
||||||
|
|
||||||
|
A pergunta que você deveria estar se fazendo agora é "E por que usar o |
||||||
|
Vundle?". Na verdade, esta pergunta tem duas respostas: |
||||||
|
|
||||||
|
A primeira é: Apesar de ser extremamente fácil de adicionar um plugin no VIM -- |
||||||
|
normalmente é uma questão de descompactar um arquivo dentro do diretório |
||||||
|
`$HOME/.vim` -- a parte chata é manter os scripts atualizados (e ficar preso à um |
||||||
|
arquivo compactado) e removê-los depois, se você encher o saco de um. |
||||||
|
|
||||||
|
A segunda é: Vundle não é o único gerenciador de plugins para VIM, mas consegue |
||||||
|
instalar plugins por conta própria (Pathogen requer que você baixe os plugins |
||||||
|
manualmente, assumindo depois o controle para manter atualizado); a desvantagem |
||||||
|
é que Vundle requer que os scripts tenham uma determinada estrutura de arquivos |
||||||
|
e diretórios, mas praticamente todos os scripts hoje utilizam esta estrutura. |
||||||
|
|
||||||
|
Então vamos lá, instalar o Vundle: |
||||||
|
|
||||||
|
Primeiro, você deve baixar o plugin em si. Para isso, você tem que ter o Git |
||||||
|
instalado e executar: |
||||||
|
|
||||||
|
``` |
||||||
|
git clone https://github.com/gmarik/vundle.git ~/.vim/bundle/vundle |
||||||
|
``` |
||||||
|
|
||||||
|
Simplesmente, você está copiando o repositório do vundle para um diretório do |
||||||
|
próprio VIM. Até aqui nenhuma surpresa, exceto que o diretório de plugins é |
||||||
|
`$HOME/.vim/plugin` (ou `~/.vim/plugin`) e o clone colocou no diretório |
||||||
|
`~/.vim/bundle`. Ou seja, o Vundle não está ativo como um plugin do VIM (ainda). |
||||||
|
O Vundle faz isso de propósito, para que os scripts instalados com o Vundle não |
||||||
|
se misturem com os plugins instalados manualmente. |
||||||
|
|
||||||
|
A seguir, é preciso ativar o Vundle. Para isso, nós vamos adicionar o diretório |
||||||
|
do Vundle no path do VIM e chamar o script de inicialização. Para isto, |
||||||
|
adicione as seguintes linhas no seu vimrc: |
||||||
|
|
||||||
|
```vim |
||||||
|
set rtp+=~/.vim/bundle/vundle/ |
||||||
|
call vundle#rc() |
||||||
|
``` |
||||||
|
|
||||||
|
Explicando: "rtp" é a forma curta de "runtimepath", que identifica os |
||||||
|
diretórios onde o VIM irá procurar scripts, se preciso. No caso, estamos |
||||||
|
adicionando o diretório do Vundle, que clonamos anteriormente. A seguir é |
||||||
|
chamado o script de inicialização do Vundle. |
||||||
|
|
||||||
|
Pronto! Agora o Vundle está instalado. |
||||||
|
|
||||||
|
A questão é: E agora que o Vundle está instalado, "faz o que?" |
||||||
|
|
||||||
|
O Vundle tem mais comandos disponíveis, entre eles `:Plugin "{bundle}"`[^1]. Este |
||||||
|
comando adiciona um bundle/plugin/script na lista de bundles/plugins/scripts |
||||||
|
gerenciados pelo Vundle. A única coisa que esse comando faz é adicionar o |
||||||
|
bundle na lista; ele não vai instalar o bundle ainda, ele não vai remover o |
||||||
|
bundle, ele não vai atualizar o bundle. Apenas adicionar na lista. |
||||||
|
|
||||||
|
O parâmetro do comando, {bundle} pode ser: |
||||||
|
|
||||||
|
* O nome de um plugin conforme listado no repositórios de scripts do VIM; |
||||||
|
apenas uma string (por exemplo, `:Plugin "vundle"` para instalar este script |
||||||
|
(que é a descrição do Vundle nos repositórios de script); |
||||||
|
|
||||||
|
* O nome de um plugin no Github, no formato "{usuário}/{repositório}", que você |
||||||
|
pode ver na parte superior de qualquer repositório (por exemplo, `:Bundle " |
||||||
|
gmarik/vundle"` para instalar o Vundle a partir do repositório -- que tende a |
||||||
|
ser atualizado com maior frequência); |
||||||
|
|
||||||
|
* Uma URL, que pode ser clonada com Git (por exemplo, `:Plugin |
||||||
|
"https://github.com/gmarik/vundle"` para fazer o mesmo que acima. |
||||||
|
|
||||||
|
Uma vez que você tenha a lista de plugins que você quer no sistema, você pode |
||||||
|
instalar todos usando `:PluginInstall`; se quiser remover um plugin, você |
||||||
|
simplesmente o deixa fora da lista de plugins desejados e executa `:PluginClean`; |
||||||
|
e, para atualizar os plugins que estão instalados, `:PluginUpdate.` |
||||||
|
|
||||||
|
Acho que você já percebeu que o problema de se manter uma lista de plugins |
||||||
|
manualmente é meio chato: Toda vez que você quiser verificar se há atualizações |
||||||
|
dos plugins, você tem que entrar a lista inteira; se você esquecer de um plugin |
||||||
|
e fizer `:PluginClean` irá remover esse plugin. Para evitar essa complicação, |
||||||
|
você pode adicionar os comandos Plugin diretamente no seu vimrc[^2]. Assim, cada |
||||||
|
vez que você usar qualquer comando do Vundle, você não precisa se preocupar em |
||||||
|
lembrar de todos os plugins instalados. |
||||||
|
|
||||||
|
E, como última dica, fica o seguinte: Logo após a linha do "call vundle#rc()", |
||||||
|
adicione |
||||||
|
|
||||||
|
```viml |
||||||
|
Plugin 'gmarik/vundle' |
||||||
|
``` |
||||||
|
|
||||||
|
.. que nada mais é que o repositório que fizemos o clone logo no começo; desta |
||||||
|
forma, quando você fizer um `:PluginUpdate`, o próprio Vundle poderá ser |
||||||
|
atualizado com a última versão disponível. |
||||||
|
|
||||||
|
[^1] Lembram que eu falei que plugins poderiam adicionar novos comandos e que |
||||||
|
estes teriam pelo menos a primeira letra em maiúsculas? Pois é... |
||||||
|
|
||||||
|
[^2] Lembre-se também que o vimrc é um arquivo executado em modo Ex e o modo Ex |
||||||
|
nada mais é que o modo de comando sem precisar colocar `:` na frente de cada |
||||||
|
comando. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./13-tags", prev_chapter_title="Tags", next_chapter_link="./14-02-airline", next_chapter_title="Plugins - Airline") }} |
After Width: | Height: | Size: 27 KiB |
After Width: | Height: | Size: 7.0 KiB |
After Width: | Height: | Size: 7.1 KiB |
@ -0,0 +1,110 @@ |
|||||||
|
+++ |
||||||
|
title = "Plugins - Airline" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que o "laststatus" fica interessante. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Quando estávamos falando de configurações, falamos de uma configuração chamada |
||||||
|
“laststatus”. Esta configuração tem 3 valores possíveis: |
||||||
|
|
||||||
|
* 0 – não apresenta a barra de status, nunca. |
||||||
|
* 1 – apresenta a barra de status se houver pelo menos um split. |
||||||
|
* 2 – sempre apresenta a barra de status. |
||||||
|
|
||||||
|
E, conforme eu mostrei no meu arquivo de configuração, eu sempre deixo com 2". |
||||||
|
|
||||||
|
Acontece que a barra de status não é tããão informativa assim. |
||||||
|
|
||||||
|
![](laststatus.png) |
||||||
|
|
||||||
|
Ela tem o básico, mas o básico não é o suficiente, sejamos honestos. É possível |
||||||
|
adicionar mais informações setando "statusline" (que eu não vou entrar em |
||||||
|
detalhes aqui, mas para configurar, você tem que usar letras únicas indicado |
||||||
|
para cada coisa que deseja apresentar tal como se faz com "guioptions") mas, |
||||||
|
mesmo assim, certas coisas tem que vir de scripts externos (por exemplo, para |
||||||
|
mostrar o branch atual que você está) e, como eu falei, essa parte é meio |
||||||
|
chata. |
||||||
|
|
||||||
|
Para aliviar essa confusão, existe um plugin chamado "Vim-Airline", que tem uma |
||||||
|
apresentação mais complexa e oferece mais informações, baseados plugins que |
||||||
|
você tem instalado. |
||||||
|
|
||||||
|
Ainda, o Airline é uma versão mais leve do Powerline, que na verdade passou de |
||||||
|
ser um simples plugin para VIM para ser um plugin para praticamente tudo (hoje |
||||||
|
eu uso o Powerline para configurar meu prompt do terminal, por exemplo) e |
||||||
|
algumas coisas ainda são usadas do Powerline (por exemplo, as fontes, mas |
||||||
|
esperem aí que eu já explico o porque o Airline usa fontes especiais.) |
||||||
|
|
||||||
|
(Conforme formos passando a lista de plugins que eu tenho, vocês vão ver o |
||||||
|
Airline mudando de formato com o tempo.) |
||||||
|
|
||||||
|
Como falei do Vundle como gerenciador de plugins, vamos usar o mesmo para |
||||||
|
instalar (e manter, no futuro) o Airline. |
||||||
|
|
||||||
|
No seu vimrc, adicione o seguinte: |
||||||
|
|
||||||
|
```viml |
||||||
|
Plugin "bling/vim-airline" |
||||||
|
``` |
||||||
|
|
||||||
|
E, revisando: `:Plugin` adiciona um plugin na lista de plugins gerenciados pelo |
||||||
|
Vundle (e apenas isso, nada mais); por ter uma barra no meio, estamos falando |
||||||
|
de um repositório do Github; para instalar o plugin, você precisa ou adicionar |
||||||
|
o plugin na lista manualmente (com o comando `:Plugin`) ou reiniciar o VIM caso |
||||||
|
você queria conferir se a configuração no seu vimrc está certa e fazer |
||||||
|
`:PluginInstall.` |
||||||
|
|
||||||
|
Se nada apareceu, é porque o seu "laststatus" não está em "2". |
||||||
|
|
||||||
|
Se tudo deu certo, você verá o seguinte: |
||||||
|
|
||||||
|
![](airline-nofonts.png) |
||||||
|
|
||||||
|
Não que tenha melhorado muito, mas agora você tem informações sobre qual o modo |
||||||
|
que você está atualmente (que vai mudar de cor conforme você passa para o modo |
||||||
|
de inserção ou visual), o nome do arquivo, o tipo de arquivo (que define qual a |
||||||
|
sintaxe está sendo usada), posição do cursor em relação ao todo do arquivo (em |
||||||
|
percentual) e a posição absoluta do mesmo (em linhas em colunas). |
||||||
|
|
||||||
|
Ok, duas coisas: Ainda não é muito melhor (embora a parte de mostrar o modo |
||||||
|
ajude, acredite), mas temos alguns caracteres estranhos na barra. |
||||||
|
|
||||||
|
É aí que entra a história do Powerline de novo: Os criadores do Powerline |
||||||
|
usaram "posições" não usadas nas fontes unicode para adicionar outros |
||||||
|
caracteres que são usados para melhorar a apresentação do status. Eles mantém |
||||||
|
[um repositório com fontes já com os caracteres especiais](https://github.com/powerline/fonts) |
||||||
|
e, caso a fonte que você queria não esteja na lista deles, [eles tem um script |
||||||
|
para "patchear" a fonte desejada](https://github.com/powerline/powerline/tree/develop/font). |
||||||
|
|
||||||
|
Uma vez que você tenha a fonte disponível no seu sistema, você deve adicionar no seu vimrc |
||||||
|
|
||||||
|
```viml |
||||||
|
let g:airline_powerline_fonts = 1 |
||||||
|
``` |
||||||
|
|
||||||
|
E o seu Airline, na próxima execução, deve ficar |
||||||
|
|
||||||
|
![](airline-laststatus.png) |
||||||
|
|
||||||
|
Que é mais bonito, mas ainda continua mostrando as mesmas informações. Mais pra |
||||||
|
frente veremos ã integração com “Fugitive” (um plugin para VIM para Git) e o |
||||||
|
Syntastic (para validar o código com ferramentas externas) e como ambos são |
||||||
|
suportados pelo Airline, você terá todas as informações ao alcance do rodapé da |
||||||
|
janela. |
||||||
|
|
||||||
|
![](airline-everything.png) |
||||||
|
|
||||||
|
Uma última nota: O Airline vem com suporte a temas, que você pode trocar usando |
||||||
|
`:AirlineTheme` (e um duplo [Tab] depois disso irá mostrar os temas instalados). |
||||||
|
Depois que escolher um, você pode definir |
||||||
|
|
||||||
|
``` |
||||||
|
let g:airline_theme = '{nome do tema}' |
||||||
|
``` |
||||||
|
|
||||||
|
no seu vimrc. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./14-01-vundle", prev_chapter_title="Plugins - Vundle", next_chapter_link="./14-03-fugitive", next_chapter_title="Plugins - Fugitive") }} |
After Width: | Height: | Size: 5.0 KiB |
@ -0,0 +1,66 @@ |
|||||||
|
+++ |
||||||
|
title = "Plugins - Fugitive" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte que só faz sentido se você usa Git. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
O terceiro plugin que eu vou comentar é |
||||||
|
[Fugitive](https://github.com/tpope/vim-fugitive), que adiciona comandos para |
||||||
|
gerenciar seu repositório Git dentro do VIM. |
||||||
|
|
||||||
|
Para instalar, ou você baixa a versão do Github (no link acima) ou usa o Vundle: |
||||||
|
|
||||||
|
```viml |
||||||
|
Plugin "tpope/vim-fugitive" |
||||||
|
``` |
||||||
|
|
||||||
|
(E, de novo: depois de adicionar essa linha no seu vimrc, você deve sair do VIM |
||||||
|
-- ou, se não quiser fazer tudo isso, basta usar o comando acima em modo de |
||||||
|
comando -- e usar `:PluginInstall` para instalar o plugin.) |
||||||
|
|
||||||
|
A princípio, nada de diferente deve aparecer. Mas você agora pode usar qualquer |
||||||
|
comando do Git com `:Git {comando}`, como faria no shell. |
||||||
|
|
||||||
|
Mas só adicionar um comando não é o que o Fugitive faz. Ele também adiciona |
||||||
|
outros comandos: |
||||||
|
|
||||||
|
* `:Gwrite` (ou `:Gw`): salva o arquivo atual e já adiciona no index para o |
||||||
|
próximo commit. |
||||||
|
* `:Gblame`: Faz um split da tela, mostrando do lado direito o fonte que já |
||||||
|
estava aberto e do lado esquerdo, o último commit (SHA1) e o autor do commit. |
||||||
|
* `:Gread`: Descarta as alterações locais e recupera o arquivo atual na sua |
||||||
|
última revisão dentro do repositório do Git (ou seja, revert). |
||||||
|
* `:Gdiff`: Mostra um diff da versão atual com a versão no repositório, com |
||||||
|
splits. |
||||||
|
* `:Gcommit`: Faz o commit dos arquivos que estão no index. |
||||||
|
* `:Gstatus`: Faz um "git status", mas deixa que você altere os arquivos no |
||||||
|
index (usando "-" para adicionar ou remover o arquivo -- leia o texto com |
||||||
|
atenção) e faça commit dos selecionados (usando "cc") [Note que ambos os |
||||||
|
comandos devem ser usados em modo normal dentro do split aberto por |
||||||
|
`:Gstatus`.] |
||||||
|
|
||||||
|
Existem outros, mas você vai usar principalmente estes. E cuide para que você |
||||||
|
esteja dentro de um repositório Git antes de tentar usar os comandos; se o VIM |
||||||
|
não estiver num diretório com um repositório válido, nenhum dos comandos do |
||||||
|
Fugitive ficarão disponíveis[^1]. |
||||||
|
|
||||||
|
E, como última dica: Se você estiver usando o Airline (comentado no capítulo |
||||||
|
anterior), adicione |
||||||
|
|
||||||
|
```viml |
||||||
|
let g:airline_enable_branch = 1 |
||||||
|
``` |
||||||
|
|
||||||
|
... no seu vimrc e o branch atual será apresentando dentro do status do |
||||||
|
Airline, logo após o indicador de modo. |
||||||
|
|
||||||
|
[^1] Eu só preciso adimitir que não testei para ver o que acontece se você |
||||||
|
abrir o VIM fora de um repositório e depois usar `:cd` para mudar para um |
||||||
|
diretório que tem um repositório ou tentar abrir um arquivo que está |
||||||
|
dentro de um repositório para verificar se os comandos se tornam |
||||||
|
disponíveis. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./14-02-airline", prev_chapter_title="Plugins - Airline", next_chapter_link="./14-04-commentary", next_chapter_title="Plugins - Commentary") }} |
@ -0,0 +1,56 @@ |
|||||||
|
+++ |
||||||
|
title = "Plugins - Commentary" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que automatizamos a técnica de sumir código sem sumir com o |
||||||
|
código. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
O quarto plugin da lista de plugins é |
||||||
|
[Commentary](https://github.com/tpope/vim-commentary). |
||||||
|
|
||||||
|
Como de costume, para instalar, você pode baixar o conteúdo do repositório |
||||||
|
acima para dentro do seu ~/.vim/ (o diretório, não o arquivo de inicialização) |
||||||
|
ou usar o Vundle: |
||||||
|
|
||||||
|
```viml |
||||||
|
Plugin "tpope/vim-commentary" |
||||||
|
``` |
||||||
|
|
||||||
|
Commentary não é um plugin visual, o que significa que, mais uma vez, depois de |
||||||
|
instalado você não verá nada de novo. |
||||||
|
|
||||||
|
O que o Commentary faz é adicionar um atalho para comentar linhas de código, |
||||||
|
baseado no tipo de arquivo atual. O atalho é \\\\{movimentação} ou \\\\\\ para |
||||||
|
comentar a linha atual (ou você pode entrar em modo visual para selecionar as |
||||||
|
linhas e fazer \\\\ e a parte selecionada vai ficar comentada); para descomentar, |
||||||
|
basta fazer a mesma coisa (ou seja, se o pedaço selecionado não estiver |
||||||
|
comentado, ele será comentado; se já estiver comentado, o comentário será |
||||||
|
removido.) |
||||||
|
|
||||||
|
E era isso. |
||||||
|
|
||||||
|
A única ressalva aqui fica por conta de um comportamento padrão do VIM: O VIM |
||||||
|
tem apenas um tipo de arquivo (definido com `:set filetype={sintaxe}`) que vale |
||||||
|
para todo o arquivo. Assim, se você estiver usando a sintaxe de HTML, |
||||||
|
Commentary provavelmente não irá comentar seu código JavaScript corretamente. A |
||||||
|
coisa fica pior se você estiver editando um arquivo com sintaxe de template, já |
||||||
|
que o tipo de arquivo é o template, não HTML ou JavaScript ou CSS. |
||||||
|
|
||||||
|
Ainda, aproveitando o gancho, existem sintaxes e sintaxes. Algumas sintaxes são |
||||||
|
antigas e estão definidas de uma forma que o VIM perde o contexto do código |
||||||
|
apresentado e apresenta com a coloração errada (andar no texto em direção ao |
||||||
|
começo do arquivo, com [PageUp], normalmente resolve esse problema, pois o VIM |
||||||
|
encontra um ponto onde a sintaxe volta a fazer sentido). Por exemplo, a sintaxe |
||||||
|
"htmldjango", que funciona também para arquivos Jinja2 tem a leve tendência de |
||||||
|
se perder em arquivos muito longos; usando uma sintaxe externa para Jinja2 |
||||||
|
(usando `:Plugin "Glench/Vim-Jinja2-Syntax"`) esse problema não acontece. |
||||||
|
|
||||||
|
Então lembre-se: Se a sintaxe "pirar", voltar um pouco para o começo do arquivo |
||||||
|
deve resolver (e, depois disso, o VIM carrega o contexto a medida que você for |
||||||
|
voltando para o ponto original) e sempre verifique se não há um arquivo de |
||||||
|
sintaxe que corresponda melhor às suas necessidades. |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./14-03-fugitive", prev_chapter_title="Plugins - Fugitive", next_chapter_link="./14-05-tabular", next_chapter_title="Plugins - Tabular") }} |
@ -0,0 +1,100 @@ |
|||||||
|
+++ |
||||||
|
title = "Plugins - Tabular" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que deixamos as coisas alinhadas. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
O quinto plugin da lista de plugins é |
||||||
|
[Tabular](https://github.com/godlygeek/tabular), um plugin para alinhar |
||||||
|
elementos baseados em expressões regulares (calma, não é tão complicado quando |
||||||
|
parece.) |
||||||
|
|
||||||
|
Mais uma vez, para instalar pelo Vundle: |
||||||
|
|
||||||
|
```viml |
||||||
|
Plugin "godlygeek/tabular" |
||||||
|
``` |
||||||
|
|
||||||
|
Assim como Fugitive e Commentary, Tabular não é um plugin visual, mas adiciona |
||||||
|
um novo comando `:{range}Tabularize {expressão regular}`. |
||||||
|
|
||||||
|
(Apenas lembrando de {range}: são dois indicadores separados por vírgula, |
||||||
|
números são linhas, "$" é a última linha do arquivo, "%" é igual à "1,$" (todo o |
||||||
|
arquivo), "'{marcador1},'{marcador2}" vai do marcador1 até o marcador2 e, se você |
||||||
|
selecionar uma região no modo visual, ao pressionar `:`, o prompt deve ficar "'< |
||||||
|
,'>" que são os marcadores especiais de início e fim, respectivamente, da área |
||||||
|
visual. Todos os exemplos que eu vou mostrar daqui pra frente vão usar o |
||||||
|
{range} de início e fim do bloco visual, porque faz mais sentido.) |
||||||
|
|
||||||
|
A forma mais simples de usar o Tabular é passar um único caractere, que indica |
||||||
|
qual o ponto onde os elementos serão alinhados. Por exemplo, com o seguinte |
||||||
|
trecho de código: |
||||||
|
|
||||||
|
```javascript |
||||||
|
var pos = 1; |
||||||
|
var element = $(this); |
||||||
|
var i = 0; |
||||||
|
``` |
||||||
|
|
||||||
|
Se você selecionar o mesmo visualmente e fizer `:'< ,'>Tabularize /=`, o resultado será: |
||||||
|
|
||||||
|
```javascript |
||||||
|
var pos = 1; |
||||||
|
var element = $(this); |
||||||
|
var i = 0; |
||||||
|
``` |
||||||
|
|
||||||
|
Ao contrário da pesquisa (e da substituição), Tabularize aceita um segundo |
||||||
|
parâmetro que indica como os elementos devem ser alinhados e qual o espaçamento |
||||||
|
que deve existir entre os elementos. Este parâmetro pode ser até 3 pares, no |
||||||
|
formato {alinhamento}{espaços depois do elemento} que, apesar da minha péssima |
||||||
|
descrição, não é tão complicado assim. |
||||||
|
|
||||||
|
Por exemplo, imagine que eu tenho o seguinte pedaço de código em HTML: |
||||||
|
|
||||||
|
```html |
||||||
|
<input class='block-size disabled' |
||||||
|
id='input-box' |
||||||
|
name='login' |
||||||
|
value='' |
||||||
|
placeholder='Enter your login'> |
||||||
|
``` |
||||||
|
|
||||||
|
No caso, eu estou quebrando cada um dos elementos para diminuir o tamanho da |
||||||
|
linha, já que ainda não coloquei minhas opções de templating e cada uma destas |
||||||
|
linhas deve ficar bem maior. Mas, como exemplo, serve. |
||||||
|
|
||||||
|
O que eu quero é que os "=" fiquem alinhados (mais ou menos o que o Xcode faz |
||||||
|
com código Objective-C). Assim, eu posso fazer `:'< ,'>Tabularize /=/r0c0l0` para |
||||||
|
obter: |
||||||
|
|
||||||
|
```html |
||||||
|
<input class='block-size disabled' |
||||||
|
id='input-box' |
||||||
|
name='login' |
||||||
|
value='' |
||||||
|
placeholder='Enter your login'> |
||||||
|
``` |
||||||
|
|
||||||
|
A explicação está no parámetro: o primeiro par, "r0" siginfica que o elemento |
||||||
|
antes do alinhamento deve ser alinhado à direita ("r") com 0 espaços depois do |
||||||
|
elemento; "c0" significa que o elemento de alinhamento (no nosso caso, "=") |
||||||
|
deve ser centralizado ("c") também com 0 espaços depois; e finalmente "l0" |
||||||
|
significa que o elemento depois do alinhamento deve ficar à esquerda ("l") e |
||||||
|
nenhum espaço deve ser adicionado. |
||||||
|
|
||||||
|
Se eu quisesse que o espaço não ficasse grudado tanto na esquerda quando na |
||||||
|
direita, eu teria que fazer `:'< ,'>Tabularize /=/r1c1l0` para obter: |
||||||
|
|
||||||
|
```html |
||||||
|
<input class = 'block-size disabled' |
||||||
|
id = 'input-box' |
||||||
|
name = 'login' |
||||||
|
value = '' |
||||||
|
placeholder = 'Enter your login'> |
||||||
|
``` |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./14-04-commentary", prev_chapter_title="Plugins - Commentary", next_chapter_link="./14-06-autopairs", next_chapter_title="Plugins - Auto-pairs") }} |
@ -0,0 +1,72 @@ |
|||||||
|
+++ |
||||||
|
title = "Plugins - Auto-Pairs" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que o VIM fecha as coisas pra você. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
O sexto plugin da lista de plugins que eu vou falar é |
||||||
|
[Auto-Pairs](https://github.com/jiangmiao/auto-pairs). Como de costume, para |
||||||
|
instalar o plugin pelo Vundle: |
||||||
|
|
||||||
|
```viml |
||||||
|
Plugin "jiangmiao/auto-pairs" |
||||||
|
``` |
||||||
|
|
||||||
|
Uma vez instalado o plugin, você verá que cada `'`, `"`, `(`, `[` e `{` irá, |
||||||
|
automagicamente, gerar o seu respectivo `'`, `"`, `)`, `]` e `}`. Simples assim. |
||||||
|
|
||||||
|
Entretanto, Auto-Pairs não funciona bem com o modo visual (se você já usou |
||||||
|
TextMate ou Sublime Text, deve ter percebido que se você usar uma das |
||||||
|
combinações acima com uma área selecionada, o editor vai "circular" a área |
||||||
|
selecionada com o par indicado). O que existe é `[Alt]e` em modo de inserção que |
||||||
|
faz a troca rápida entre o caractere de fechamento de pair com a próxima |
||||||
|
palavra. |
||||||
|
|
||||||
|
Por exemplo, se você tiver |
||||||
|
|
||||||
|
``` |
||||||
|
''auto |
||||||
|
``` |
||||||
|
|
||||||
|
... com o cursor posicionado entre as duas aspas e usar `[Alt]e`, você irá ficar com |
||||||
|
|
||||||
|
``` |
||||||
|
'auto' |
||||||
|
``` |
||||||
|
|
||||||
|
Ainda, o Auto-pairs tem um controle para "pular" sobre os caracteres de |
||||||
|
fechamento já existentes. Se ele adicionar um ")" (que deve ficar antes do |
||||||
|
cursor), quando você pressionar ")" no seu teclado, ao invés de adicionar mais |
||||||
|
um ")", o cursor irá pular o ")" existente. |
||||||
|
|
||||||
|
Embora isso pareça bom, em certos casos pode ser um problema. Por exemplo, caso |
||||||
|
você tenha o seguinte trecho de código: |
||||||
|
|
||||||
|
```javascript |
||||||
|
$(function () { |
||||||
|
$('#button').on('click', function () { |
||||||
|
|
||||||
|
}) |
||||||
|
``` |
||||||
|
|
||||||
|
Se você tentar fechar a função interna, o Auto-Pairs irá, na verdade, saltar |
||||||
|
para o fechamento da função externa, efetivamente "proibindo" que você feche as |
||||||
|
funções corretamente. Soluções são: |
||||||
|
|
||||||
|
* Fechar a função externa de novo, forçando o que era para encerrar a função |
||||||
|
externa em encerramento da função interna (depois você pode alinhar as duas |
||||||
|
novamente usando o modo visual e `=` em modo normal); |
||||||
|
|
||||||
|
* Copiar e colar o fechamento da função externa; |
||||||
|
|
||||||
|
* Desligar o "salto" de elementos de fechamento com `:let g:AutoPairsFlyMode = 0` |
||||||
|
(e, se você realmente preferir que o salto nunca seja feito, pode adicionar |
||||||
|
esta linha no seu vimrc); |
||||||
|
|
||||||
|
* Desligar temporariamente o Auto-Pairs com `[Alt]p` em modo de inserção (usar |
||||||
|
`[Alt]p` novamente irá reativar o Auto-Pairs). |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./14-05-tabular", prev_chapter_title="Plugins - Tabular", next_chapter_link="./14-07-syntastic", next_chapter_title="Plugins - Syntastic") }} |
@ -0,0 +1,60 @@ |
|||||||
|
+++ |
||||||
|
title = "Plugins - Syntastic" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte que o VIM ajuda você a achar o que tem de errado no seu |
||||||
|
código. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
O sétimo plugin discutido é o [Syntastic](https://github.com/scrooloose/syntastic). |
||||||
|
Para instalar com Vundle: |
||||||
|
|
||||||
|
```viml |
||||||
|
Plugin "scrooloose/syntastic" |
||||||
|
``` |
||||||
|
|
||||||
|
Inicialmente, Syntastic não faz nada. O que ele faz é, depois de salvar o |
||||||
|
arquivo em disco, chama a função de lint para o tipo de arquivo atual e mostra |
||||||
|
os problemas encontrados no canto esquerdo do código; ao passar pela linha com |
||||||
|
problema, o erro encontrado é reportado na linha de comando. |
||||||
|
|
||||||
|
![](syntastic.png) |
||||||
|
|
||||||
|
Para ver quais são todos os erros encontrados pelo aplicativo de lint, use |
||||||
|
`:Errors`, que irá abrir uma janela de quickfix com a lista de erros encontrados. |
||||||
|
Ações de janelas e de quickfix, que já vinhamos vendo, continuam valendo. É só |
||||||
|
o comando para abrir o quickfix que é diferente neste caso. |
||||||
|
|
||||||
|
Você pode selecionar quais lints serão usados adicionado com `let |
||||||
|
g:syntastic_{linguagem}_checkers=['']` (por exemplo, para verificar arquivos Python apenas |
||||||
|
com PyLint, você deve usar `let g:syntastic_python_checkers=['pylint']` mas nunca |
||||||
|
tive problemas com os lints atuais). |
||||||
|
|
||||||
|
Uma coisa que deve ser cuidada é que o lint deve estar disponível no momento |
||||||
|
que o VIM abriu o arquivo, senão ele não será usado. Por exemplo, se você tiver |
||||||
|
pylint disponível apenas dentro de um virtualenv, chamar o VIM antes de estar |
||||||
|
no virtualenv fará com que Syntastic não encontre o pylint e, com isso, nenhum |
||||||
|
erro será reportado. |
||||||
|
|
||||||
|
Ainda, assim como aconteceu com Commentary, Syntastic usa o tipo de arquivo |
||||||
|
atual, não o do bloco. Por exemplo, ao editar um arquivo de template de Django, |
||||||
|
que tem partes na linguagem de template do Django, HTML, CSS e JavaScript, |
||||||
|
mesmo que você tenha os lints para HTML, CSS e JavaScript instalados, estes não |
||||||
|
serão executados -- porque o VIM considera o arquivo um tipo inteiro, não um |
||||||
|
conjunto de pequenos blocos de tipos diferentes. |
||||||
|
|
||||||
|
E, por último, Airline tem suporte para mostrar os erros encontrados pelo |
||||||
|
Syntastic na barra de status. Se você adicionar |
||||||
|
|
||||||
|
```viml |
||||||
|
let g:airline_enable_syntastic = 1 |
||||||
|
``` |
||||||
|
|
||||||
|
... no seu vimrc, o canto direito da barra de status irá mostrar a primeira |
||||||
|
linha com erro e a quantidade de erros encontrados. |
||||||
|
|
||||||
|
![](syntastic-airline.png) |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./14-06-autopairs", prev_chapter_title="Plugins - Auto-Pairs", next_chapter_link="./14-08-snipmate", next_chapter_title="Plugins - SnipMate") }} |
After Width: | Height: | Size: 13 KiB |
After Width: | Height: | Size: 5.4 KiB |
@ -0,0 +1,107 @@ |
|||||||
|
+++ |
||||||
|
title = "Plugins - Snipmate" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte que automatizamos a digitação de coisas repetidas. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Para o oitavo plugin, iremos falar sobre [SnipMate](https://github.com/msanders/snipmate.vim). |
||||||
|
|
||||||
|
Como de costume, instalando pelo Vundle: |
||||||
|
|
||||||
|
```viml |
||||||
|
Plugin "msanders/snipmate.vim" |
||||||
|
``` |
||||||
|
|
||||||
|
SnipMate adiciona a funcionalidade de snippets dentro do VIM. Para quem não |
||||||
|
sabe, snippets são trechos de código que são adicionados automaticamente (ou |
||||||
|
com a ação de alguma combinação de teclas) a partir de uma simples palavra. |
||||||
|
|
||||||
|
Por exemplo, um dos snippets que já estão inclusos no pacote do SnipMate, você |
||||||
|
pode, num arquivo JavaScript, simplesmente digitar: |
||||||
|
|
||||||
|
```javascript |
||||||
|
fun |
||||||
|
``` |
||||||
|
|
||||||
|
... e, ao pressionar [Tab], o SnipMate irá adicionar, automaticamente |
||||||
|
|
||||||
|
```javascript |
||||||
|
function function_name (argument) { |
||||||
|
// body... |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
... posicionando o cursor diretamente sobre "function_name" para que você coloque |
||||||
|
o nome da função; pressionando [Tab] irá posicionar o cursor sobre "argument" e |
||||||
|
pressionando [Tab] de novo, o cursor ficará sobre "// body..." (depois disso, |
||||||
|
[Tab] irá funcionar como tabulação, como normalmente é). |
||||||
|
|
||||||
|
Para criar seus próprios snippets, você tem duas opções e ambas devem ficar no |
||||||
|
diretório $HOME/.vim/snippets: |
||||||
|
|
||||||
|
A primeira forma é através de um único arquivo, com o nome do tipo de arquivo |
||||||
|
em que os snippets serão válidos (que você pode ver usando `:set ft`) com a |
||||||
|
extensão snippets (por exemplo, para snippets para arquivos Python, você teria |
||||||
|
um arquivo "$HOME/.vim/snippets/python.snippets"). Neste arquivo você deve |
||||||
|
iniciar os snippets com a palavra snippet, seguida da palavra que será |
||||||
|
utilizada para identificar o snippet, seguido pelo snippet em si, com uma |
||||||
|
tabulação na frente (quando não houver tabulação, SnipMate considera que o |
||||||
|
snippet terminou). Os pontos onde você quer que o cursor pare devem ser |
||||||
|
identificados por "$\{\{número}:{texto\}\}" e, se ficou confuso, é porque eu estou |
||||||
|
usando "coisas que você substituir" com {} e o próprio SnipMate usa {} para |
||||||
|
blocos, mas deve ficar mais claro com este exemplo: |
||||||
|
|
||||||
|
```viml |
||||||
|
snippet for |
||||||
|
{% for ${1:record} in ${2:list} %} |
||||||
|
${3:content} |
||||||
|
{% endfor %} |
||||||
|
``` |
||||||
|
|
||||||
|
Este snippet, para Django e Jinja, faz um loop "for". Ao digitar "for" e |
||||||
|
pressionar [Tab], o conteúdo será adicionado, o cursor será posicionando onde |
||||||
|
`${1:record}` está permitindo a alteração do mesmo, pressionando [Tab] de novo |
||||||
|
irá posicionar em `${2:list}` e assim por diante. |
||||||
|
|
||||||
|
E, caso você esteja se perguntando "E o que acontece se eu colocar o mesmo |
||||||
|
número em dois lugares diferentes?", a resposta é: lugares com o mesmo número |
||||||
|
são alterados ao mesmo tempo. Por exemplo, o snippet: |
||||||
|
|
||||||
|
```viml |
||||||
|
snippet block |
||||||
|
{% block ${1:blockname} %} |
||||||
|
${2:{% content %}} |
||||||
|
{% endblock $1 %} |
||||||
|
``` |
||||||
|
|
||||||
|
... tem o número "1" duas vezes (uma depois de "block" e outra depois de |
||||||
|
"endblock"). Quando você colocar o nome do bloco no primeiro (do lado de |
||||||
|
"block"), o outro (depois de "endblock") será preenchido automaticamente. |
||||||
|
|
||||||
|
A segunda forma de adicionar snippets é através de arquivos individuais. Ao |
||||||
|
invés de ter um arquivo com o tipo de arquivo com todos os snippets dentro, |
||||||
|
você irá criar um diretório com o tipo de arquivo e cada arquivo dentro deste |
||||||
|
diretório deve ser "{palavra}.snippet". Assim, como no exemplo anterior tínhamos |
||||||
|
um arquivo "$HOME/.vim/snippets/htmldjango.snippets", poderíamos ter, na verdade, |
||||||
|
um diretório "$HOME/.vim/snippets/htmldjango/" e, dentro deste diretório, um |
||||||
|
arquivo chamando "block.snippet" com o conteúdo do snippet, sem as tabulações (já |
||||||
|
que agora o SnipMate sabe exatamente onde termina o snippet: no final do |
||||||
|
arquivo). |
||||||
|
|
||||||
|
E quando usar um ou outro? Você deve usar arquivos individuais se o SnipMate já |
||||||
|
tiver um arquivo de snippets para o tipo de arquivo especificado. Assim, se |
||||||
|
você quiser adicionar novos snippets para Python, que já tem uma série de |
||||||
|
snippets prontos incluídos no pacote do próprio SnipMate, você deve usar a |
||||||
|
segunda forma. Caso contrário, fica por preferência pessoal. |
||||||
|
|
||||||
|
E, para concluir: Ao escrever este post, descobri que existe um fork da versão |
||||||
|
apresentada aqui. A versão do "msanders" não é atualizada a 4 anos -- mas |
||||||
|
funciona perfeitamente e tenho usado sem problemas a bastante tempo. Se você |
||||||
|
quiser algo mais recente (por algum motivo), o fork está em |
||||||
|
github.com/garbas/vim-snipmate (e requer mais dependências que a versão |
||||||
|
original). |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./14-07-syntastic", prev_chapter_title="Plugins - Syntastic", next_chapter_link="./14-09-ctrlp", next_chapter_title="Plugins - CtrlP e CtrlPFunky") }} |
After Width: | Height: | Size: 40 KiB |
@ -0,0 +1,105 @@ |
|||||||
|
+++ |
||||||
|
title = "Plugins - CtrlP and CtrlPFunky" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que você vai ter a impressão de estar programando em Perl, |
||||||
|
porque qualquer caractere é válido. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
O nono e penúltimo plugin (na verdade os nonos e penúltimos plugins) discutido |
||||||
|
é o [CtrlP](https://github.com/kien/ctrlp.vim) e seu plugin (sim, um plugin do |
||||||
|
plugin[^1]) [CtrlPFunky](https://github.com/tacahiroy/ctrlp-funky) |
||||||
|
|
||||||
|
Para instalar os dois, com Vundle: |
||||||
|
|
||||||
|
```viml |
||||||
|
Plugin "kien/ctrlp.vim" |
||||||
|
Plugin "tacahiroy/ctrlp-funky" |
||||||
|
``` |
||||||
|
|
||||||
|
CtrlP é um plugin que facilita encontrar e abrir arquivos, com procura fuzzy. |
||||||
|
E, por procura fuzzy eu quero dizer que ele encontra qualquer arquivo que tenha |
||||||
|
as letras digitadas na ordem que você digitou. |
||||||
|
|
||||||
|
![](ctrlp.png) |
||||||
|
|
||||||
|
Para acionar o CtrlP, você deve digitar, logicamente, `[Ctrl]p`. Ao fazer isso, |
||||||
|
uma janela parecida com a Quickfix irá aparecer, mostrando alguns arquivos e um |
||||||
|
prompt para que você digite o que quer encontrar. No exemplo acima, como que |
||||||
|
digitei "vim", ele encontrou todos os arquivos a partir do diretório atual que |
||||||
|
começavam com "v", tinham um "i" no meio e terminavam com "m" (seria |
||||||
|
basicamente o mesmo que pegar a lista de arquivos a partir do diretório atual e |
||||||
|
seus sub-diretórios e procurar pela regex "v.\*i.\*m".) |
||||||
|
|
||||||
|
Uma vez que você encontre o arquivo desejado na lista (ela não tem rolagem, |
||||||
|
então se você ainda não estiver vendo o arquivo, continue adicionando |
||||||
|
caracteres para que o arquivo desejado apareça na lista -- uma vez lá, você pode |
||||||
|
selecioná-lo com as setas), você pode: |
||||||
|
|
||||||
|
* Pressionar `[Enter]` para abrir o arquivo na janela atual. |
||||||
|
* Pressionar `[Ctrl]t` para abrir o arquivo em outra aba. |
||||||
|
* Pressionar `[Ctrl]s` para fazer um split horizontal e abrir o arquivo no novo |
||||||
|
split. |
||||||
|
* Pressionar `[Ctrl]v` para fazer um split vertical e abrir o arquivo no novo |
||||||
|
split. |
||||||
|
|
||||||
|
Um problema que você talvez encontre é que o CtrlP costuma listar tudo que se |
||||||
|
encaixar na expressão utilizada, inclusive arquivos binário, objetos |
||||||
|
intermediários, etc. Para remover estes arquivos da listagem, você pode usar |
||||||
|
`:set wildignore`, que também afeta a lista de arquivos que o VIM mostra quando |
||||||
|
você estiver usando os comandos normais de abertura de arquivo (`:e`, `:tabe`, |
||||||
|
etc). |
||||||
|
|
||||||
|
Como a configuração do wildignore é uma lista, você pode adicionar ou remover |
||||||
|
usando += e -=. Por exemplo, para ignorar os arquivos de objetos compilados do |
||||||
|
Python e o diretório que o setup.py constuma usar para construir o pacote de |
||||||
|
distribuição do módulo, você teria: |
||||||
|
|
||||||
|
```viml |
||||||
|
set wildignore+=*.pyc |
||||||
|
set wildignore+=*/build/* |
||||||
|
``` |
||||||
|
|
||||||
|
ou ainda, para economizar uma linha: |
||||||
|
|
||||||
|
```viml |
||||||
|
set wildignore+=*.pyc,*/build/* |
||||||
|
``` |
||||||
|
|
||||||
|
CtrlP tem um plugin, chamado CtrlPFunky. O que ele faz é basicamente o mesmo |
||||||
|
que o CtrlP, mas procurando funções, não arquivos. |
||||||
|
|
||||||
|
Para ativar o CtrlPFunky, você precisa primeiro adicionar o mesmo como uma |
||||||
|
extensão do CtrlP (e, só pra avisar, isso é específico do CtrlP, não algo que |
||||||
|
funciona com todo e qualquer plugin): |
||||||
|
|
||||||
|
```viml |
||||||
|
let g:ctrlp_extensions = ['funky'] |
||||||
|
``` |
||||||
|
|
||||||
|
Uma vez instalado, você pode usar `:CtrlPFunky` para mostrar a lista de funções |
||||||
|
no fonte (e a procura continua igual). O problema com CtrlPFunky é que, assim |
||||||
|
como todas as demais coisas que vínhamos vendo, ele se basea no tipo de arquivo |
||||||
|
atual (`:set ft`) e para arquivos em que o conteúdo e uma mistura de várias |
||||||
|
linguagens (p.ex., arquivo template com a linguagem de template, HTML, CSS e |
||||||
|
JavaScript), a listagem de funções pode não ser o que você está esperando (ou |
||||||
|
sequer vai funcionar). |
||||||
|
|
||||||
|
Para facilitar a sua vida, você pode fazer um mapeamento do comando para um |
||||||
|
atalho de teclado. Por exemplo, eu coloquei `[Ctrl]o` para chamar o CtrlPFunky |
||||||
|
com |
||||||
|
|
||||||
|
```viml |
||||||
|
nnoremap <C-O> :CtrlPFunky<CR> |
||||||
|
``` |
||||||
|
|
||||||
|
[^1] "Plugin-ception" har har har[^2]. |
||||||
|
|
||||||
|
[^2] Eu não consigo entender porque as pessoas utilizando tanto o "ception" |
||||||
|
quando encontram um meta desta jeito. Um "inception" é a inserção de uma |
||||||
|
idéia de forma que a pessoa pense que a idéia é dela, não uma |
||||||
|
"[Matrioska](http://pt.wikipedia.org/wiki/Matrioska)". |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./14-08-snipmate", prev_chapter_title="Plugins - SnipMate", next_chapter_link="./14-10-multiple-cursors", next_chapter_title="Plugins - Vim-Multiple-Cursors") }} |
@ -0,0 +1,52 @@ |
|||||||
|
+++ |
||||||
|
title = "Plugins - Vim-Multiple-Cursors" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que você pode repetir várias coisas, visualmente. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
O último plugin da lista de plugins é o [Vim-Multiple-Cursors](https://github.com/terryma/vim-multiple-cursors). |
||||||
|
|
||||||
|
Já que sempre falamos em usar Vundle... |
||||||
|
|
||||||
|
```viml |
||||||
|
Plugin "terryma/vim-multiple-cursors" |
||||||
|
``` |
||||||
|
|
||||||
|
Assim como outros plugins já comentados, Vim-Multiple-Cursors não tem nenhuma |
||||||
|
apresentação inicial. O que este plugin faz é permitir que você tenha várias |
||||||
|
cursores no texto ao mesmo tempo, aplicando a mesma transformação em todos os |
||||||
|
lugares. |
||||||
|
|
||||||
|
A forma mais simples de usar Vim-Multiple-Cursors é ir até a palavra que você |
||||||
|
quer alterar e pressionar `[Ctrl]n`. Você vai notar que o VIM irá mostrar como se |
||||||
|
você tivesse entrado em modo visual e selecionado apenas aquela palavra, o que |
||||||
|
não é nada impressionante. No entanto, se você pressionar `[Ctrl]n` de novo, você |
||||||
|
verá que o cursor irá para a próxima ocorrência da palavra. Na verdade, o que |
||||||
|
você tem agora são dois cursores e tudo que você fizer em um será repetido no |
||||||
|
outro. Por exemplo, se você fizer ce sobre a palavra, você verá as duas |
||||||
|
palavras mudando ao mesmo tempo. |
||||||
|
|
||||||
|
De certa forma, o que você está fazendo é um "search and replace" só que está |
||||||
|
vendo exatamente o que vai ser alterado. |
||||||
|
|
||||||
|
Teoricamente, você poderia fazer `I"[Esc]ea"` para adicionar aspas ao redor da |
||||||
|
palavra, mas há um pequeno inconveniente: `[Esc]`, que você precisa usar para |
||||||
|
retornar para o modo normal depois de entrar em modo de inserção com `I` irá |
||||||
|
também terminar o modo de múltiplos cursores. |
||||||
|
|
||||||
|
A segunda forma de usar Vim-Multiple-Cursors é fazer uma seleção visual e usar |
||||||
|
`[Ctrl]n`. Para cada linha da seleção, será adicionado um novo cursor. E, |
||||||
|
novamente, o que você fizer em um deles será repetido em todos. |
||||||
|
|
||||||
|
Simples assim. |
||||||
|
|
||||||
|
A única coisa que eu posso deixar de aviso é que, por algum motivo, utilizando |
||||||
|
uma seleção visual de várias linhas (`[Shift]v`), entrando em modo de múltiplos |
||||||
|
cursores (`[Ctrl]n`) e usando aspas (com o Auto-Pairs), meu undo acabou sendo |
||||||
|
perdido (`u` removia o texto inteiro, não a alteração feita com |
||||||
|
Vim-Multiple-Cursors). |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./14-09-ctrlp", prev_chapter_title="Plugins - CtrlP e CtrlPFunky", next_chapter_link="./15-conclusao", next_chapter_title="Conclusão") }} |
@ -0,0 +1,53 @@ |
|||||||
|
+++ |
||||||
|
title = "Plugins - Vim-Multiple-Cursors" |
||||||
|
date = 2015-12-22 |
||||||
|
+++ |
||||||
|
|
||||||
|
Essa é a parte em que nos despedimos. |
||||||
|
|
||||||
|
<!-- more --> |
||||||
|
|
||||||
|
Pessoalmente, a palavra que eu usaria para descrever o VIM é extensível. Não |
||||||
|
apenas pela quantidade de plugins criados e aperfeiçoados nestes 20 anos de |
||||||
|
editor (na verdade, 22 se você considerar a [primeira versão |
||||||
|
disponibilizada](http://en.wikipedia.org/wiki/Vim_%28text_editor%29) em 1991 ou |
||||||
|
25 se você considerar quando Bram Moolenaar fez a versão 1.0 para o Amiga), mas |
||||||
|
pela forma como os comandos foram projetados: Você sabe que uma movimentação do |
||||||
|
cursor com um número da frente “pula” outras ocorrências, então qualquer |
||||||
|
comando que você descobre como movimentação repete esse comportamento; Você |
||||||
|
sabe que comandos que requerem movimentação aceitam qualquer comando de |
||||||
|
movimentação (incluindo a quantidade, discutido antes); e assim por diante. |
||||||
|
Claro que isto permite várias formas diferentes de fazer a mesma coisa, mas |
||||||
|
isto também garante que você vai achar uma forma que se encaixe com o seu |
||||||
|
workflow de desenvolvimento. |
||||||
|
|
||||||
|
E não que, como eu falei lá no começo, VIM seja o editor perfeito para todas as |
||||||
|
condições: Existem coisas novas surgindo a todo momento (por exemplo, a idéia |
||||||
|
de múltiplos cursores só foi popularizado quando o TextMate foi lançado no OS |
||||||
|
X) e que o editor base não consegue fazer -- mas como o editor é extensível em |
||||||
|
várias formas, alguém já fez um plugin para repetir o comportamento no editor. |
||||||
|
Existem arquivos de sintaxe que são terríveis, e mesmo assim fazem parte do |
||||||
|
pacote original -- e existem formas de atualizar por versões melhores. Existem |
||||||
|
plugins que baseiam-se unicamente no tipo de arquivo inteiro e não no bloco -- |
||||||
|
mas não há nada que não garanta que, no futuro, alguém consiga fazer um plugin |
||||||
|
que troque automaticamente de modo baseado no contexto atual. |
||||||
|
|
||||||
|
Na contrapartida, existem certas coisas que o VIM consegue fazer que outros |
||||||
|
editores não fazem: Pular para o ponto onde o texto foi inserido da última vez |
||||||
|
é o que sempre me faz voltar a usar o VIM e que eu sinto uma tremenda falta nos |
||||||
|
outros editores -- que, diga-se de passagem, é fácil do editor controlar pela |
||||||
|
existência dos modos. |
||||||
|
|
||||||
|
E, como dicas de despedida: Quando alguém comentar sobre uma feature em outro |
||||||
|
editor, lembre-se de procurar por "vim {feature}" na internet; muito |
||||||
|
provavelmente a feature já existe em alguma forma para o VIM ou já tem alguém |
||||||
|
tentando escrever um plugin para fazer a mesma coisa. E lembre-se sempre que |
||||||
|
`:wq` só funciona no VIM, não nos demais editores ou no seu emulador de |
||||||
|
terminal[^1]. |
||||||
|
|
||||||
|
[^1] Você pode perguntar para qualquer usuário de longa data quantas vezes eles |
||||||
|
tentaram fechar o terminal ou mesmo um editor de textos como Word ou |
||||||
|
LibreOffice com `:wq` e a resposta provavelmente vai ser "mais vezes que eu |
||||||
|
posso lembrar". |
||||||
|
|
||||||
|
{{ chapters(prev_chapter_link="./14-10-multiple-cursors", prev_chapter_title="Plugins - Vim-Multiple-Cursors") }} |
@ -0,0 +1,38 @@ |
|||||||
|
+++ |
||||||
|
transparent = false |
||||||
|
title = "Uma Lição de VIM" |
||||||
|
template = "section-contentless.html" |
||||||
|
+++ |
||||||
|
|
||||||
|
* [Introdução](00-intro) |
||||||
|
* [Modos](01-modos) |
||||||
|
* [Modo normal](01-01-modo-normal) |
||||||
|
* [Entendendo o Cursor](01-02-entendendo-o-cursor) |
||||||
|
* [Mudando de Modos - Modo de Inserção](01-03-modo-de-insercao) |
||||||
|
* [Mudando de Modos - Modo Visual](01-04-modo-visual) |
||||||
|
* [Mudando de Modos - Modo de Comando](01-05-modo-de-comando) |
||||||
|
* [Outros Comandos](02-outros-comandos) |
||||||
|
* [Recortar, Copiar e Colar](03-recortar-copiar-colar) |
||||||
|
* [Registradores](04-registradores) |
||||||
|
* [Marcadores](05-marcadores) |
||||||
|
* [Macros de Teclado](06-macros-de-teclado) |
||||||
|
* [Procurar em Vários Arquivos](07-procurar-varios-arquivos) |
||||||
|
* [Localizar e Substituir](08-localizar-substituir) |
||||||
|
* [Splits](09-splits) |
||||||
|
* [Abas](10-abas) |
||||||
|
* [Arquivos de Configuração](11-config) |
||||||
|
* [Meu .vimrc](11-01-vimrc) |
||||||
|
* [Meu .gvimrc](11-02-gvimrc) |
||||||
|
* [Modelines](12-modelines) |
||||||
|
* [Tags](13-tags) |
||||||
|
* [Plugins - Vundle](14-01-vundle) |
||||||
|
* [Plugins - Airline](14-02-airline) |
||||||
|
* [Plugins - Fugitive](14-03-fugitive) |
||||||
|
* [Plugins - Commentary](14-04-commentary) |
||||||
|
* [Plugins - Tabular](14-05-tabular) |
||||||
|
* [Plugins - Auto-pairs](14-06-autopairs) |
||||||
|
* [Plugins - Syntastic](14-07-syntastic) |
||||||
|
* [Plugins - Snipmate](14-08-snipmate) |
||||||
|
* [Plugins - CtrlP e CtrlPFunky](14-09-ctrlp) |
||||||
|
* [Plugins - Vim-Multiple-Cursors](14-10-multiple-cursors) |
||||||
|
* [Conclusão](15-conclusao) |