diff --git a/content/books/_index.md b/content/books/_index.md new file mode 100644 index 0000000..d7f8a96 --- /dev/null +++ b/content/books/_index.md @@ -0,0 +1,8 @@ ++++ +title = "My Books" +template = "section-contentless.html" ++++ + +## Portuguese/Português + +* [Uma Lição de Vim](uma-licao-de-vim) diff --git a/content/books/uma-licao-de-vim/00-intro/index.md b/content/books/uma-licao-de-vim/00-intro/index.md new file mode 100644 index 0000000..fd5df88 --- /dev/null +++ b/content/books/uma-licao-de-vim/00-intro/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/00-intro/vim-zero.png b/content/books/uma-licao-de-vim/00-intro/vim-zero.png new file mode 100644 index 0000000..580b5e9 Binary files /dev/null and b/content/books/uma-licao-de-vim/00-intro/vim-zero.png differ diff --git a/content/books/uma-licao-de-vim/01-modos/index.md b/content/books/uma-licao-de-vim/01-modos/index.md new file mode 100644 index 0000000..b8a701b --- /dev/null +++ b/content/books/uma-licao-de-vim/01-modos/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/01-modos/so-what.jpg b/content/books/uma-licao-de-vim/01-modos/so-what.jpg new file mode 100644 index 0000000..20878cf Binary files /dev/null and b/content/books/uma-licao-de-vim/01-modos/so-what.jpg differ diff --git a/content/books/uma-licao-de-vim/01-modos/whatdoesitmean1.jpg b/content/books/uma-licao-de-vim/01-modos/whatdoesitmean1.jpg new file mode 100644 index 0000000..ed355d6 Binary files /dev/null and b/content/books/uma-licao-de-vim/01-modos/whatdoesitmean1.jpg differ diff --git a/content/books/uma-licao-de-vim/01.01-modo-normal/Mind-Blown.jpg b/content/books/uma-licao-de-vim/01.01-modo-normal/Mind-Blown.jpg new file mode 100644 index 0000000..b50eb16 Binary files /dev/null and b/content/books/uma-licao-de-vim/01.01-modo-normal/Mind-Blown.jpg differ diff --git a/content/books/uma-licao-de-vim/01.01-modo-normal/index.md b/content/books/uma-licao-de-vim/01.01-modo-normal/index.md new file mode 100644 index 0000000..7e450bc --- /dev/null +++ b/content/books/uma-licao-de-vim/01.01-modo-normal/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/01.02-entendendo-o-cursor/areyoufuckingkiddingme.jpg b/content/books/uma-licao-de-vim/01.02-entendendo-o-cursor/areyoufuckingkiddingme.jpg new file mode 100644 index 0000000..23d7ebd Binary files /dev/null and b/content/books/uma-licao-de-vim/01.02-entendendo-o-cursor/areyoufuckingkiddingme.jpg differ diff --git a/content/books/uma-licao-de-vim/01.02-entendendo-o-cursor/index.md b/content/books/uma-licao-de-vim/01.02-entendendo-o-cursor/index.md new file mode 100644 index 0000000..f8b9f52 --- /dev/null +++ b/content/books/uma-licao-de-vim/01.02-entendendo-o-cursor/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/01.02-entendendo-o-cursor/vim-cursor.png b/content/books/uma-licao-de-vim/01.02-entendendo-o-cursor/vim-cursor.png new file mode 100644 index 0000000..f34e21b Binary files /dev/null and b/content/books/uma-licao-de-vim/01.02-entendendo-o-cursor/vim-cursor.png differ diff --git a/content/books/uma-licao-de-vim/01.03-modo-de-insercao/enhanced-buzz-5697-1327086181-19.jpg b/content/books/uma-licao-de-vim/01.03-modo-de-insercao/enhanced-buzz-5697-1327086181-19.jpg new file mode 100644 index 0000000..bb0bd04 Binary files /dev/null and b/content/books/uma-licao-de-vim/01.03-modo-de-insercao/enhanced-buzz-5697-1327086181-19.jpg differ diff --git a/content/books/uma-licao-de-vim/01.03-modo-de-insercao/iStock_000014784346Small.jpg b/content/books/uma-licao-de-vim/01.03-modo-de-insercao/iStock_000014784346Small.jpg new file mode 100644 index 0000000..8f0b7c9 Binary files /dev/null and b/content/books/uma-licao-de-vim/01.03-modo-de-insercao/iStock_000014784346Small.jpg differ diff --git a/content/books/uma-licao-de-vim/01.03-modo-de-insercao/index.md b/content/books/uma-licao-de-vim/01.03-modo-de-insercao/index.md new file mode 100644 index 0000000..bdcd333 --- /dev/null +++ b/content/books/uma-licao-de-vim/01.03-modo-de-insercao/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/01.03-modo-de-insercao/jaw-drop.jpg b/content/books/uma-licao-de-vim/01.03-modo-de-insercao/jaw-drop.jpg new file mode 100644 index 0000000..c139613 Binary files /dev/null and b/content/books/uma-licao-de-vim/01.03-modo-de-insercao/jaw-drop.jpg differ diff --git a/content/books/uma-licao-de-vim/01.04-modo-visual/index.md b/content/books/uma-licao-de-vim/01.04-modo-visual/index.md new file mode 100644 index 0000000..5fc73da --- /dev/null +++ b/content/books/uma-licao-de-vim/01.04-modo-visual/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/01.05-modo-de-comando/index.md b/content/books/uma-licao-de-vim/01.05-modo-de-comando/index.md new file mode 100644 index 0000000..41e143a --- /dev/null +++ b/content/books/uma-licao-de-vim/01.05-modo-de-comando/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/02-outros-comandos/index.md b/content/books/uma-licao-de-vim/02-outros-comandos/index.md new file mode 100644 index 0000000..088110d --- /dev/null +++ b/content/books/uma-licao-de-vim/02-outros-comandos/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/03-recortar-copiar-colar/index.md b/content/books/uma-licao-de-vim/03-recortar-copiar-colar/index.md new file mode 100644 index 0000000..1bbb08d --- /dev/null +++ b/content/books/uma-licao-de-vim/03-recortar-copiar-colar/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/04-registradores/index.md b/content/books/uma-licao-de-vim/04-registradores/index.md new file mode 100644 index 0000000..15642f9 --- /dev/null +++ b/content/books/uma-licao-de-vim/04-registradores/index.md @@ -0,0 +1,76 @@ ++++ +title = "Registradores" +date = 2015-12-22 ++++ + +Essa é a parte que o VIM fica melhor que os outros editores. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/05-marcadores/index.md b/content/books/uma-licao-de-vim/05-marcadores/index.md new file mode 100644 index 0000000..c06bcbb --- /dev/null +++ b/content/books/uma-licao-de-vim/05-marcadores/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/06-macros-de-teclado/index.md b/content/books/uma-licao-de-vim/06-macros-de-teclado/index.md new file mode 100644 index 0000000..49f4164 --- /dev/null +++ b/content/books/uma-licao-de-vim/06-macros-de-teclado/index.md @@ -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. + + + +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 99a execução da macro ou a +1a. 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") }} diff --git a/content/books/uma-licao-de-vim/07-procurar-varios-arquivos/index.md b/content/books/uma-licao-de-vim/07-procurar-varios-arquivos/index.md new file mode 100644 index 0000000..f12f66c --- /dev/null +++ b/content/books/uma-licao-de-vim/07-procurar-varios-arquivos/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/08-localizar-substituir/index.md b/content/books/uma-licao-de-vim/08-localizar-substituir/index.md new file mode 100644 index 0000000..c8c556e --- /dev/null +++ b/content/books/uma-licao-de-vim/08-localizar-substituir/index.md @@ -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. + + + +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: + +
+
g
+
Substitui todas as ocorrências da expressão de procura na linha, não apenas + a primeira.
+
i
+
Ignora maiúsculas e minúsculas ("ignore case")
+
c
+
Pede confirmação em cada alteração.
+
+ +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") }} diff --git a/content/books/uma-licao-de-vim/09-splits/all.png b/content/books/uma-licao-de-vim/09-splits/all.png new file mode 100644 index 0000000..e96f78d Binary files /dev/null and b/content/books/uma-licao-de-vim/09-splits/all.png differ diff --git a/content/books/uma-licao-de-vim/09-splits/horizontal-split.png b/content/books/uma-licao-de-vim/09-splits/horizontal-split.png new file mode 100644 index 0000000..4f417c7 Binary files /dev/null and b/content/books/uma-licao-de-vim/09-splits/horizontal-split.png differ diff --git a/content/books/uma-licao-de-vim/09-splits/index.md b/content/books/uma-licao-de-vim/09-splits/index.md new file mode 100644 index 0000000..0dbdf9e --- /dev/null +++ b/content/books/uma-licao-de-vim/09-splits/index.md @@ -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. + + + +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 3o 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 3o 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") }} diff --git a/content/books/uma-licao-de-vim/09-splits/vertical-split.png b/content/books/uma-licao-de-vim/09-splits/vertical-split.png new file mode 100644 index 0000000..ca26dba Binary files /dev/null and b/content/books/uma-licao-de-vim/09-splits/vertical-split.png differ diff --git a/content/books/uma-licao-de-vim/10-abas/index.md b/content/books/uma-licao-de-vim/10-abas/index.md new file mode 100644 index 0000000..db26f91 --- /dev/null +++ b/content/books/uma-licao-de-vim/10-abas/index.md @@ -0,0 +1,44 @@ ++++ +title = "Abas" +date = 2015-12-22 ++++ + +Essa é a parte me que você acha coisas que já fazia antes. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/11-config/index.md b/content/books/uma-licao-de-vim/11-config/index.md new file mode 100644 index 0000000..6738b22 --- /dev/null +++ b/content/books/uma-licao-de-vim/11-config/index.md @@ -0,0 +1,162 @@ ++++ +title = "Arquivos de Configuração" +date = 2015-12-22 ++++ + +Essa é a parte em que eu menti. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/11-config/muahaha.jpg b/content/books/uma-licao-de-vim/11-config/muahaha.jpg new file mode 100644 index 0000000..1621b2c Binary files /dev/null and b/content/books/uma-licao-de-vim/11-config/muahaha.jpg differ diff --git a/content/books/uma-licao-de-vim/11.01-vimrc/index.md b/content/books/uma-licao-de-vim/11.01-vimrc/index.md new file mode 100644 index 0000000..e3227ea --- /dev/null +++ b/content/books/uma-licao-de-vim/11.01-vimrc/index.md @@ -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. + + + +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 :%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+) +if has(‘mac’) + map :tabn 1 + map :tabn 2 + map :tabn 3 + map :tabn 4 + map :tabn 5 + map :tabn 6 + map :tabn 7 + map :tabn 8 + map :tabn 9 + map :tabn 10 + + imap :tabn 1a + imap :tabn 2a + imap :tabn 3a + imap :tabn 4a + imap :tabn 5a + imap :tabn 6a + imap :tabn 7a + imap :tabn 8a + imap :tabn 9a + imap :tabn 10a +else + map :tabn 1 + map :tabn 2 + map :tabn 3 + map :tabn 4 + map :tabn 5 + map :tabn 6 + map :tabn 7 + map :tabn 8 + map :tabn 9 + map :tabn 10 + + imap :tabn 1a + imap :tabn 2a + imap :tabn 3a + imap :tabn 4a + imap :tabn 5a + imap :tabn 6a + imap :tabn 7a + imap :tabn 8a + imap :tabn 9a + imap :tabn 10a +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 , 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") }} diff --git a/content/books/uma-licao-de-vim/11.02-gvimrc/index.md b/content/books/uma-licao-de-vim/11.02-gvimrc/index.md new file mode 100644 index 0000000..6e24177 --- /dev/null +++ b/content/books/uma-licao-de-vim/11.02-gvimrc/index.md @@ -0,0 +1,108 @@ ++++ +title = "Meu .gvimrc" +date = 2015-12-22 ++++ + +Essa é a parte em que veremos mais do mesmo. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/12-modelines/index.md b/content/books/uma-licao-de-vim/12-modelines/index.md new file mode 100644 index 0000000..768c2c3 --- /dev/null +++ b/content/books/uma-licao-de-vim/12-modelines/index.md @@ -0,0 +1,70 @@ ++++ +title = "Modelines" +date = 2015-12-22 ++++ + +Essa é a parte em que você ignora seus arquivos de configuração. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/13-tags/index.md b/content/books/uma-licao-de-vim/13-tags/index.md new file mode 100644 index 0000000..bb75c05 --- /dev/null +++ b/content/books/uma-licao-de-vim/13-tags/index.md @@ -0,0 +1,60 @@ ++++ +title = "Tags" +date = 2015-12-22 ++++ + +Essa é a parte em que você vai entender Unix um pouco. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/14.01-vundle/index.md b/content/books/uma-licao-de-vim/14.01-vundle/index.md new file mode 100644 index 0000000..9d18b7d --- /dev/null +++ b/content/books/uma-licao-de-vim/14.01-vundle/index.md @@ -0,0 +1,112 @@ ++++ +title = "Plugins - Vundle" +date = 2015-12-22 ++++ + +Essa é a parte em que começamos a mexer ao redor do VIM. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/14.02-airline/airline-everything.png b/content/books/uma-licao-de-vim/14.02-airline/airline-everything.png new file mode 100644 index 0000000..112be77 Binary files /dev/null and b/content/books/uma-licao-de-vim/14.02-airline/airline-everything.png differ diff --git a/content/books/uma-licao-de-vim/14.02-airline/airline-laststatus.png b/content/books/uma-licao-de-vim/14.02-airline/airline-laststatus.png new file mode 100644 index 0000000..f91d4c5 Binary files /dev/null and b/content/books/uma-licao-de-vim/14.02-airline/airline-laststatus.png differ diff --git a/content/books/uma-licao-de-vim/14.02-airline/airline-nofonts.png b/content/books/uma-licao-de-vim/14.02-airline/airline-nofonts.png new file mode 100644 index 0000000..ce8a973 Binary files /dev/null and b/content/books/uma-licao-de-vim/14.02-airline/airline-nofonts.png differ diff --git a/content/books/uma-licao-de-vim/14.02-airline/index.md b/content/books/uma-licao-de-vim/14.02-airline/index.md new file mode 100644 index 0000000..a92ffd0 --- /dev/null +++ b/content/books/uma-licao-de-vim/14.02-airline/index.md @@ -0,0 +1,110 @@ ++++ +title = "Plugins - Airline" +date = 2015-12-22 ++++ + +Essa é a parte em que o "laststatus" fica interessante. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/14.02-airline/laststatus.png b/content/books/uma-licao-de-vim/14.02-airline/laststatus.png new file mode 100644 index 0000000..018b299 Binary files /dev/null and b/content/books/uma-licao-de-vim/14.02-airline/laststatus.png differ diff --git a/content/books/uma-licao-de-vim/14.03-fugitive/index.md b/content/books/uma-licao-de-vim/14.03-fugitive/index.md new file mode 100644 index 0000000..bf9cc2c --- /dev/null +++ b/content/books/uma-licao-de-vim/14.03-fugitive/index.md @@ -0,0 +1,66 @@ ++++ +title = "Plugins - Fugitive" +date = 2015-12-22 ++++ + +Essa é a parte que só faz sentido se você usa Git. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/14.04-commentary/index.md b/content/books/uma-licao-de-vim/14.04-commentary/index.md new file mode 100644 index 0000000..7aa8687 --- /dev/null +++ b/content/books/uma-licao-de-vim/14.04-commentary/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/14.05-tabular/index.md b/content/books/uma-licao-de-vim/14.05-tabular/index.md new file mode 100644 index 0000000..4339718 --- /dev/null +++ b/content/books/uma-licao-de-vim/14.05-tabular/index.md @@ -0,0 +1,100 @@ ++++ +title = "Plugins - Tabular" +date = 2015-12-22 ++++ + +Essa é a parte em que deixamos as coisas alinhadas. + + + +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 + +``` + +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 + +``` + +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 + +``` + +{{ chapters(prev_chapter_link="./14-04-commentary", prev_chapter_title="Plugins - Commentary", next_chapter_link="./14-06-autopairs", next_chapter_title="Plugins - Auto-pairs") }} diff --git a/content/books/uma-licao-de-vim/14.06-autopairs/index.md b/content/books/uma-licao-de-vim/14.06-autopairs/index.md new file mode 100644 index 0000000..0a0a903 --- /dev/null +++ b/content/books/uma-licao-de-vim/14.06-autopairs/index.md @@ -0,0 +1,72 @@ ++++ +title = "Plugins - Auto-Pairs" +date = 2015-12-22 ++++ + +Essa é a parte em que o VIM fecha as coisas pra você. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/14.07-syntastic/index.md b/content/books/uma-licao-de-vim/14.07-syntastic/index.md new file mode 100644 index 0000000..a10fe5e --- /dev/null +++ b/content/books/uma-licao-de-vim/14.07-syntastic/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/14.07-syntastic/syntastic-airline.png b/content/books/uma-licao-de-vim/14.07-syntastic/syntastic-airline.png new file mode 100644 index 0000000..5c0a280 Binary files /dev/null and b/content/books/uma-licao-de-vim/14.07-syntastic/syntastic-airline.png differ diff --git a/content/books/uma-licao-de-vim/14.07-syntastic/syntastic.png b/content/books/uma-licao-de-vim/14.07-syntastic/syntastic.png new file mode 100644 index 0000000..d985ae0 Binary files /dev/null and b/content/books/uma-licao-de-vim/14.07-syntastic/syntastic.png differ diff --git a/content/books/uma-licao-de-vim/14.08-snipmate/index.md b/content/books/uma-licao-de-vim/14.08-snipmate/index.md new file mode 100644 index 0000000..64c15fa --- /dev/null +++ b/content/books/uma-licao-de-vim/14.08-snipmate/index.md @@ -0,0 +1,107 @@ ++++ +title = "Plugins - Snipmate" +date = 2015-12-22 ++++ + +Essa é a parte que automatizamos a digitação de coisas repetidas. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/14.09-ctrlp/ctrlp.png b/content/books/uma-licao-de-vim/14.09-ctrlp/ctrlp.png new file mode 100644 index 0000000..ac3c4c7 Binary files /dev/null and b/content/books/uma-licao-de-vim/14.09-ctrlp/ctrlp.png differ diff --git a/content/books/uma-licao-de-vim/14.09-ctrlp/index.md b/content/books/uma-licao-de-vim/14.09-ctrlp/index.md new file mode 100644 index 0000000..36bb049 --- /dev/null +++ b/content/books/uma-licao-de-vim/14.09-ctrlp/index.md @@ -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. + + + +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 :CtrlPFunky +``` + +[^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") }} diff --git a/content/books/uma-licao-de-vim/14.10-multiple-cursors/index.md b/content/books/uma-licao-de-vim/14.10-multiple-cursors/index.md new file mode 100644 index 0000000..5aa7f98 --- /dev/null +++ b/content/books/uma-licao-de-vim/14.10-multiple-cursors/index.md @@ -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. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/15-conclusao/index.md b/content/books/uma-licao-de-vim/15-conclusao/index.md new file mode 100644 index 0000000..bce12b1 --- /dev/null +++ b/content/books/uma-licao-de-vim/15-conclusao/index.md @@ -0,0 +1,53 @@ ++++ +title = "Plugins - Vim-Multiple-Cursors" +date = 2015-12-22 ++++ + +Essa é a parte em que nos despedimos. + + + +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") }} diff --git a/content/books/uma-licao-de-vim/_index.md b/content/books/uma-licao-de-vim/_index.md new file mode 100644 index 0000000..087e5dd --- /dev/null +++ b/content/books/uma-licao-de-vim/_index.md @@ -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) diff --git a/themes/nighttime b/themes/nighttime index 85d3db5..c9a6aff 160000 --- a/themes/nighttime +++ b/themes/nighttime @@ -1 +1 @@ -Subproject commit 85d3db539b3e72076e4a9352ca890920996dc44e +Subproject commit c9a6aff5b4b60f19a2b784a830d5c2eba81a20fb