Merge branch 'draft/vim-book' into preview

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)

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.
+
+<!-- more -->
+
+Em 2000 tive meu primeiro contato com programação em Linux e, como era de se
+esperar, o primeiro editor sugerido foi o "VIM".
+
+Foi WTF à primeira vista (e o clássico "Como é que eu fecho isso?").
+
+![Ok, não é a mesma versão que eu usei a 8 anos atrás, mas a sensação é a mesma.](vim-zero.png)
+
+Depois de usar outros editores por algum tempo (*cough* FTE *cough*), finalmente
+decidi dar o braço a torcer e passei a usar VIM, continuo usando até hoje. Não
+que eu tenha usado somente VIM desde então, utilizei outros editores (TextMate,
+Sublime Text 2, Gedit) mas eu sempre sinto falta de alguma coisa nos outros
+editores que acabei de acostumando no VIM. E, ainda, VIM ainda é o editor que
+eu mais ouço "Cara, como é que tu fez isso?".
+
+Não que VIM seja um editor completo e perfeito. Existem coisas novas surgindo a
+todo momento que ninguém sequer imaginava quando VIM foi criado; existem coisas
+que pelas próprias limitações do editor, o VIM não faz. Para algumas dessas,
+existem plugins -- e eu vou falar de alguns interessantes mais pra frente -- e,
+infelizmente, para outras, não há nada que possa ser feito, a não ser saber que
+estas "faltas" existem e estar preparados para elas.
+
+E vejamos quantos "Cara, como é que tu fez isso?" vão aparecer até o final
+deste livro.
+
+{{ chapters(next_chapter_link="./01-modos", next_chapter_title="Modos") }}

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.
+
+<!-- more -->
+
+Uma das primeiras coisas que é preciso entender sobre VIM é que ele é um editor
+modal. Enquanto outros editores abrem os arquivos diretamente em "modo de
+edição" (para começar a usar a nomenclatura que o VIM adota) -- permitindo que
+você possa, imediatamente, editar o texto --, o VIM entra em "modo normal" (que
+não é o modo "normal" dos outros editores).
+
+![Mas o que isso quer dizer?](whatdoesitmean1.jpg)
+
+O VIM tem 5 modos:
+
+## Modo Normal
+
+O modo Normal é o modo que o VIM entra normalmente. Neste modo, as teclas são
+traduzidas para comandos de alteração do texto. Na configuração padrão, os
+comandos sequer são apresentados.
+
+## Modo de Inserção
+
+O modo de Inserção é o modo que a maior parte dos outros editores funciona.
+Qualquer coisa editada irá aparecer/alterar o texto atual.
+
+## Modo Visual
+
+O modo Visual é semelhante ao selecionar texto com "shift" em outros
+editores[^1].
+
+## Modo de Comando
+
+O modo de comando serve para ações que começam com ":" (comandos Ex), "/" e "?"
+(procura) e "|" (filtro).
+
+## Modo Ex
+
+Semelhante ao modo de comando depois de usar ":", mas permanece no modo Ex.
+
+Praticamente todos os modos são utilizados, de alguma forma ou de outra, com
+exceção do modo Ex.
+
+A pergunta que você deve estar se fazendo agora é: E daí?
+
+![Você, agora.](so-what.jpg)
+
+Existem algumas coisas interessantes que podem ser feitas com VIM que não podem
+ser facilmente replicadas em outros editores justamente pela existência destes
+modos de operação. Sim, inicialmente, o fato de não poder entrar no editor e
+sair adicionando código pode parecer frustante, mas a medida que você for
+aprendendo como utilizar cada modo, você verá que eles fazem sentido e que não
+é nenhum mistério ficar pulando de modo para modo.
+
+A verdadeira lição começa agora.
+
+{% note () %}
+Todas as imagens são copyright (C) seus respectivos donos.
+{% end %}
+
+[^1] Apenas a título de informação, praticamente tudo que pode ser feito em
+     modo visual pode ser feito em modo normal.
+
+{{ chapters(prev_chapter_link="./00-intro", prev_chapter_title="Introdução", next_chapter_link="./01-01-modo-normal", next_chapter_title="Modo Normal") }}

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.
+
+<!-- more -->
+
+A apresentação mais clássica do modo normal são todas as demais explicações que
+você vai achar por aí que dizem que é preciso usar `h`, `j`, `k` e `l` para
+mover o cursor na tela. Tirando o fato que isso é uma balela sem tamanho e que
+o VIM suporta movimentação com as teclas direcionais e que você não precisa
+ficar pensando em mnemônicos como "j tem uma perna pra baixo, k tem uma perna
+pra cima" e outras absurdices, estes são comandos normais válidos: ao
+pressionar `k`, o cursor irá mover para a linha de cima, `j` moverá o cursor
+para a linha de baixo e assim por diante.
+
+Nem todos os comandos são acionados com apenas uma tecla. Alguns iniciam um
+comando, mas ficam esperando mais informações para saber o que fazer ou onde
+fazer. Assim, temos comandos que são de movimentação e outros de ação.
+
+## Comandos de Movimentação
+
+Comandos de movimentação são comandos que movem o cursor no texto. Como já
+vimos, `h`, `j`, `k` e `l` são comandos de movimentação. Além destes temos[^1]:
+
+### f[letra]
+
+Posiciona o cursor na próxima `[letra]` na linha. Se `[letra]` não existir, não
+move o cursor. Por exemplo, `fa` irá mover o cursor para o próximo "a" na
+linha.
+
+### F[letra]
+
+O mesmo que `f[letra]`, mas voltando na linha ao invés de ir pra frente.
+
+### t[letra]
+
+Posiciona o cursor uma posição antes de `[letra]` na linha. Praticamente o mesmo
+que `f[letra]`, mas uma posição antes.
+
+### T[letra]
+
+Assim como "F" faz o mesmo que "t", mas voltando na linha.
+
+### 0
+
+Move o cursor para a coluna 0.
+
+### _
+
+Move o cursor para a primeira letra que não seja espaço ou tabulação na linha.
+
+### $
+
+Move o cursor para o final da linha.
+
+### %
+
+Move o cursor para o outro elemento do par (por exemplo, % quando cursor
+estiver sobre um "(" irá mover o cursor para o ")" correspondente).
+
+Até aqui eu acredito que você esteja pensando "nada que mude minha vida". Bom,
+então aqui vem a primeira grande dica:
+
+> Se você digitar um número antes de fazer um comando, VIM irá repetir o
+> comando quantas vezes o número indicar.
+
+![](Mind-Blown.jpg)
+
+Ok, talvez não tenha sido a revelação do século, mas isso quer dizer que se
+você digitar `3f.`, VIM irá mover o cursor para o terceiro ponto na linha atual.
+E isso também pode não parecer importante, mas daqui pra frente isso vai fazer
+sentido.
+
+{% note() %}
+Todas as imagens são copyright (C) seus respectivos donos.
+{% end %}
+
+[^1] De forma alguma, esta é uma lista completa de todos os comandos de
+     movimentação existentes, apenas os mais interessantes.
+
+{{ chapters(prev_chapter_link="./01-modos", prev_chapter_title="Modos", next_chapter_link="./01-02-entendendo-o-cursor", next_chapter_title="Entendendo o Cursor") }}

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.
+
+<!-- more -->
+
+Antes de passar para comandos do modo normal que realmente alteram o texto, é
+preciso entender como o VIM entende o cursor, porque o funcionamento pode
+parecer um pouco diferente dos demais editores.
+
+Para todos os efeitos, considere que o cursor está sempre na parte inferior
+esquerda do bloco do cursor.
+
+![](vim-cursor.png)
+
+![Mais uma foto de você, nesse exato momento.](areyoufuckingkiddingme.jpg)
+
+Porque é importante ter isso em mente?
+
+Porque a maior parte dos editores trata as coisas um pouco diferentes: Por
+exemplo, se houver uma linha inteira no clipboard, o VIM irá inserir (com o
+comando padrão de colar, que vamos ver mais adiante) a nova linha abaixo na
+linha atual -- a maior parte dos outros editores cola a nova linha no lugar da
+linha atual e move a antiga linha uma posição abaixo.
+
+Apenas tenha isso em mente agora que vamos começar a mudar de modo e alguns
+comandos consideram a posição do cursor desta forma e tem uma "contraparte"
+para ações antes do cursor -- e por isso o próximo capítulo parece ter comandos
+repetidos.
+
+{% note() %}
+Todas as imagens são copyright (C) seus respectivos donos.
+{% end %}
+
+{{ chapters(prev_chapter_link="./01-01-modo-normal", prev_chapter_title="Modo Normal", next_chapter_link="./01-03-modo-de-insercao", next_chapter_title="Modo de Inserção") }}

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.
+
+<!-- more -->
+
+Agora que você sabe que existe mais de um modo de edição e como o cursor
+funciona, podemos finalmente começar a ver como se passa de um modo para o
+outro -- e, no processo, entender como editar um texto no VIM.
+
+Primeiro, é preciso saber que o Modo Normal é o ponto central para todos os
+outros modos -- o jeito mais fácil de passar de um modo para o outro é através
+do Modo Normal. E, de qualquer modo[^1], para ir para o modo normal basta
+pressionar `Esc`.
+
+Lembre-se: `Esc` irá sempre voltar para o modo normal para que você possa passar
+para os demais modos. `Esc` em modo normal irá continuar em modo normal[^2].
+
+Para passar do modo normal para o modo de inserção, você deve usar o seguinte:
+
+## i
+
+Vai para o modo de inserção na posição do cursor (lembre-se do capítulo
+anterior: o cursor está no canto inferior esquerdo do cursor, logo qualquer
+coisa que você digitar vai aparecer antes da letra onde o cursor se encontrava
+antes de pressionar `i`).
+
+## I
+
+Move o cursor para o primeiro caracter que não seja espaço ou tabulação na
+linha e entra em modo de inserção (semelhante à `_i`).
+
+## a
+
+Move o cursor uma posição pra frente e entra em modo de inserção (ou o mesmo
+que `li`).
+
+## A
+
+Move o cursor para o fim da linha e entra em modo de inserção (Seria quase um
+`$i`, só que `$` pára no último não branco da linha -- se considerarmos o caracter
+de quebra de linha um caracter "branco" -- e `i` ficará antes desse não-branco).
+
+## o
+
+Insere uma linha em branco depois do cursor e entra em modo de inserção.
+
+## O
+
+Insere uma linha em branco acima do cursor e entra em modo de inserção.
+
+## R
+
+Entra em modo de inserção, mas substitui as letras atuais ao invés de adicionar
+mais. Sim, é um modo de substituição ("replace"), mas ainda é considerado um
+modo de inserção. 
+
+Ok, pequena pausa para acertar os ponteiros agora: Uma coisa que eu comentei
+anteriormente foi que, no modo normal é possível definir o número de vezes que
+um comando será repetido. Por mais estranho que isso possa parecer, todos os
+comandos acima também aceitam um número de repetições. Por exemplo, `20A-[Esc]`
+irá repetir o comando `A-` 20 vezes, efetivamente colocando 20 "-" na linha
+atual; `20Oolá[Esc]` irá adicionar 20 linhas de `olá` no seu texto, a partir da
+posição do cursor.
+
+![Sua vida acabou de mudar.](iStock_000014784346Small.jpg)
+
+Quem estava prestando atenção deve ter notado que eu pulei `r` como opção de
+modo de inserção e todos os demais comandos tem uma versão em minúsculas e
+maiúsculas. O motivo é que `r` tem um funcionamento, digamos, peculiar.
+
+`r`, por si só, espera por uma tecla para substituir o caracter sob o cursor.
+Seria o equivalente a fazer `R`, pressionar uma tecla e, na sequência,
+pressionar `[Esc]` para sair do modo de inserção. O estranho, no entando, é
+quando é definido um número de vezes que `r` deve ser executado: Neste caso, o
+caracter sob o cursor é alterado para o caracter indicado, o cursor é movido
+para o próximo caracter e o processo se repete até o número de vezes indicado
+(ou seja alcançado o final da linha). `20r-[Esc]` irá, efetivametne, substituir
+os 20 próximos caracteres por "-" -- que não seria o mesmo que digitar,
+manualmente, `r-` 20 vezes.
+
+Existem ainda outros dois comandos para entrar em modo de inserção: `c` e `s`.
+Existem algumas diferenças configuráveis entre ambos, mas o funcionamento é o
+mesmo: Removem os caracteres indicados pela movimentação e passam para o modo
+de inserção.
+
+![Como assim "movimentação"?!?](enhanced-buzz-5697-1327086181-19.jpg)
+
+De novo, pausa para acertar os ponteiros: no capítulo #2.2, eu falei sobre
+comandos do modo normal que movimentam o cursor. Aqui, `c` e `s` não vão entrar em
+modo de inserção até que você adicione uma sequência de movimentação. Assim: `s$`
+irá remover tudo da posição de cursor até o final da linha e entrará em modo de
+inserção, `s%` irá remover tudo da posição do cursor até o próximo elemento que
+"fecha" o elemento atual (aspas, parênteses, colchetes, etc) e entrará em modo
+de inserção, `c2f.` irá remover tudo da posição do cursor até o segundo ponto na
+linha e entrará em modo de inserção e assim por diante.
+
+![A ficha finalmetne caiu](jaw-drop.jpg)
+
+Embora `c` e `s` funcionem de forma semelhante, `C` e `S` não: `C` irá apagar
+tudo da posição do cursor até o final da linha enquanto que `S` irá remover
+todo o conteúdo da linha, não importando a posição do cursor. Logicamente,
+depois de fazerem isso, ambos entram em modo de inserção. Com um número de
+repetições, no entanto, ambos funcionam da mesma forma -- tanto `20S` quanto
+`20C` irão remover a linha atual e mais 19 e entrar em modo de edição.
+
+E, só pra lembrar: Pressionar `[Esc]` irá voltar para o modo normal.
+
+{% note() %}
+Todas as imagens são copyright (C) seus respectivos donos.
+{% end %}
+
+[^1] ... exceto o modo Ex, mas como eu falei antes, não é um modo muito útil
+     hoje em dia e, portanto, eu estou ignorando ele daqui pra frente.
+
+[^2] ... O que explica porque vários programadores experientes em VIM tem a
+	 mania de, algumas vezes, ficar pressionando `[Esc]` rapidamente quando
+	 algo sai errado.
+
+{{ chapters(prev_chapter_link="./01-02-entendendo-o-cursor", prev_chapter_title="Entendendo o Cursor", next_chapter_link="./01-04-modo-visual", next_chapter_title="Modo Visual") }}

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.
+
+<!-- more -->
+
+Na nota de rodapé do primeiro capítulo eu comentei que a maior parte dos
+comandos do modo visual podem ser feitos no modo de comando. Como já vimos o
+modo de comando, fica mais fácil entender o modo visual.
+
+Em suma, o modo visual é a versão do VIM para o "Shift+Direcionais" dos demais
+editores: Vai selecionando texto, deixando visível o que está sendo
+selecionado. A diferença é que não é preciso ficar segurando o Shift o tempo
+todo. E todos os demais comandos de movimentação ainda são válidos.
+
+Para entrar no modo visual, você usa, em modo normal, `v` -- e, de novo, você não
+precisa pressionar ou ficar segurando nenhuma tecla: o modo ficará ativo até
+que você cancele o modo visual (voltando para o modo normal com `[Esc]`) ou seja
+utilizado algum comando de alteração de texto (como `s`).
+
+Uma vez que a região fique selecionada, você pode usar qualquer comando de
+alteração de textos para executar somente naquela região. Assim, ao invés de
+ficar contando quantos pontos a linha tem para chegar no número certo de saltos
+para o commando `f`, você pode facilmente ativar o modo visual, navegar a bel
+prazer, usado qualquer combinação de comandos de movimentação (incluindo
+repetir `f` a vontade) até chegar no ponto que quiser e executar o comando
+somente naquela região.
+
+Além de `v`, existem outros dois outros comandos para entrar em modo visual:
+`[Shift]+v` e `[Ctrl]+v`.
+
+`[Shift]+v` é chamado de "modo visual de linha" porque, bem, são selecionadas
+linhas inteiras neste modo, incluíndo o caracter de nova linha de cada uma das
+linhas selecionadas. Neste modo, não é possível selecionar apenas parte de uma
+linha, somente linhas inteiras -- que é útil quando se quer remover aquela
+função inteira[^1].
+
+`[Ctrl]+v` é chamado de "modo visual de bloco" e faz algo que poucos outros
+editores conseguem: seleção de regiões retangulares. A pergunta que você deve
+estar se fazendo agora é: e como é que o VIM junta as linhas se eu apagar um
+bloco inteiro? Resposta indireta: O modo visual de bloco funciona como se
+várias seleções fossem feitas ao mesmo tempo, o que significa que cada linha é
+uma seleção diferente e que cada comando de alteração de texto é executado
+individualmente em cada linha. Assim, se você iniciar o modo visual de bloco,
+selecionar várias linhas mas apenas uma coluna, e executar o comando `c,[Esc]`, o
+que vai acontecer é que o VIM irá substituir o caracter na coluna indicada por
+vírgula em cada uma das linhas. Ou seja, respondendo a pergunta feita logo no
+começo deste parágrafo: o VIM irá juntar as linhas como se você tivesse ido na
+primeira linha, executado o comando, retornado a coluna inicial, ido para a
+linha seguinte, repetido o comando e passado para a próxima linha.
+
+[^1] Ou copiar para outro arquivo, que nós vamos ver mais pra frente.
+
+{{ chapters(prev_chapter_link="./01-03-modo-de-insercao", prev_chapter_title="Modo de Inserção", next_chapter_link="./02-outros-comandos", next_chapter_title="Outros Comandos") }}

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.
+
+<!-- more -->
+
+Existem três "iniciadores" de comandos no modo de... erm... comando:
+
+* `:`: Inicia um comando de edição.
+* `/`: Comando de pesquisa.
+* `!`: Comando de filtro externo.
+
+## Comandos de Edição
+
+Assim como os comandos do modo normal, a quantidade de comandos de edição é
+grande demais para cobrir de uma vez só. Então vamos dar uma olhada nos mais
+utilizados:
+
+## :q
+
+Sai do VIM. Esse deve ser o comando mais infame da história do editor -- pelo
+menos, para os não iniciados. E ele ainda aparece na tela inicial do VIM, se
+você prestar atenção.
+
+## :w
+
+Salva o arquivo atual em disco. Você pode passar o nome do arquivo a ser salvo
+neste ponto. `:w`, por exemplo, irá salvar o conteúdo com o nome atual; `:w
+outro-nome` irá salvar o conteúdo no arquivo "outro-nome".
+
+## :wall
+
+Salva todos os arquivos arquivos. Mais adiante veremos como ter vários arquivos
+abertos ao mesmo tempo.
+
+## :wq
+
+Salva o arquivo atual e o fecha.
+
+## :help
+
+Abre o help do VIM no tópico indicado. Por exemplo, `:help :w` irá apresentar as
+opções existentes para o comando `:w`; `:help c` irá mostrar as opções do comando `c`
+do modo normal e assim por diante.
+
+## :set
+
+Configura (ou apresenta) alguma configuração do VIM. Mais a frente veremos como
+configurar o VIM e veremos as opções este comando.
+
+## :r
+
+(Ou :read) Não é muito comum, mas permite carregar o conteúdo de outro arquivo
+para dentro do arquivo atual. sem precisar fazer todo o processo de
+copiar-e-colar (que veremos mais adiante). Um fato interessante de `:r` é que se
+o nome do arquivo a ser carregado começar com "!", o VIM irá tentar executar o
+comando ao invés de carregar o conteúdo. Por exemplo, `:r date` irá carregar o
+conteúdo do arquivo `date` para dentro do arquivo atual enquanto que `:r !date` irá
+executar o comando `date` e "colar" o resultado para dentro do arquivo atual.
+
+## :noh
+
+(Ou :nohighlight) Desliga a marcação sobre elementos de pesquisa. A seguir nós
+vamos ver sobre o comando de pesquisa; ao fazer uma, o VIM irá colocar um
+"realce" (ou "highlight") sobre as palavras encontradas. Para desligar esses
+realces no texto, você pode usar `:noh`. 
+
+Aqui eu preciso abrir três parenteses:
+
+* Quando o vim se recusar a executar um comando, você pode forçá-lo a executar
+  o mesmo de qualquer forma adicionando uma exclamação `!` no final do comando.
+  Por exemplo, se o VIM se recusar a sair porque você tem alterações em um
+  arquivo não salvo, `:q!` irá forçar o editor fechar, perdendo as alterações
+  feitas; se o arquivo não tiver permissão de escrita, `:w!` irá fazer com que o
+  VIM altere as permissão do arquivo para poder escrever (e, no final, esta
+  alteração das permissões é revertida)[^1].
+
+* Uma coisa que você vai encontrar frequentemente são referências a "buffer" e
+  "arquivo". Entenda assim: buffer é a representação do arquivo na memória
+  enquanto que o arquivo é a representação do conteúdo no disco. Ao abrir um
+  arquivo, o VIM cria um buffer com o conteúdo do arquivo e o mantém em
+  memória; se o arquivo sumir, o buffer ainda existirá e poderá ser salvo
+  ainda; vários comandos internos do VIM -- se você se aventurar a escrever um
+  plugin, por exemplo -- fazem referência ao buffer e não ao arquivo, mas
+  existem funções que retornam o buffer de um arquivo com o nome indicado. Em
+  todo esse tempo usando VIM, a distinção entre ambos nunca me pareceu
+  importante e considerar, simplesmente, que "buffer" é o arquivo em memória é
+  o suficiente.
+
+* Todos os comandos internos do VIM iniciam com uma letra minuscula e plugins,
+  quando adicionam comandos a mais, adicionam com letras maiúsculas[^2]. Ainda,
+  boa parte dos comandos não precisa ser digitada completa; quando não há mais
+  redundâncias, o comando é aceito. Por exemplo, se houverem os comandos
+  ":Gblame" e ":Gbork", ":Gb" não será aceito, mas ":Gba” será porque não há
+  mais nenhum outro comando que comece com ":Gba" (por isso que ":noh" funciona
+  como atalho para ":nohighlight": porque não há nenhum outro comando que
+  inicie com "noh").
+
+## Comando de Pesquisa
+
+O comando de pesquisa é, simplesmente, `/`. Uma vez pressionado, você verá o
+cursor indo para a última linha da tela esperando a pesquisa. Uma coisa a ter
+em mente é que o VIM utiliza expressões regulares -- então algumas coisas que
+você procurar não irão funcionar exatamente como você está esperando. ".", por
+exemplo. Eu não vou entrar em detalhes sobre expressões regulares porque há
+pilhas de informações sobre elas na internet -- e há praticamente mais sobre
+elas do que essa série tem (e terá) sobre VIM.
+
+Dois comandos do modo normal que eu não mencionei antes por estarem ligados ao
+comando de pesquisa são `n` e `N`. `n` irá mover o cursor para a próxima
+ocorrência da pesquisa, enquanto que `N` move o cursor para a anterior. Note
+que eu falei "move o cursor"; isso quer dizer que `n` e `N` são comandos de
+movimentação e, portanto, podem ser usados com outros comandos do modo normal
+que utilizam movimentação. Por exemplo, procurar por "olá" e, em modo normal,
+executar `cn` irá remover tudo da posição do cursor até a próxima ocorrência de
+"olá" (e entrará em modo de edição).
+
+## Comando de Filtro
+
+O comando de filtro pega o conteúdo no editor e passa para outro programa. Por
+exemplo, se você tiver o aplicativo "rot13", ao executar `!rot13`, todo o
+conteúdo do arquivo será convertido para ROT13. Se você digitar `!!rot13`, no
+entanto, o conteúdo ainda será passado para o filtro e o resultado irá
+substituir o conteúdo do buffer atual.
+
+Não parece ser interessante, mas um dos aplicativos que normalmente vem com o
+VIM é "xxd", que converte o conteúdo para sua representação hexadecimal. Ao
+executar "!xxd", você verá todo o conteúdo do seu arquivo com os valores
+hexadecimais de cada caracter.
+
+[^1] Não confunda "Não ter permissão de escrita" com "O arquivo pertence ao
+	 root". No primeiro caso, o usuário tem permissão de ler o arquivo e trocar
+	 as permissões enquanto que no segundo o editor teria que ter permissões
+	 especiais de execução para poder trocar as permissões. O VIM só consegue
+	 responder ao `:w!`  se ele próprio -- e, no caso, o próprio usuário -- tiver
+	 permissões suficientes sem requisitar outro aplicativo.
+
+[^2] Na verdade, o VIM vem sim com comandos que inicial com letra maíuscula: São
+	 os comandos de exploração de diretório `:Explore`, `:Rexplore`, `:Vexplore` e o
+	 famigerado `:Sexplore`, que o pessoal costuma encurtar para `:Sex`.
+
+{{ chapters(prev_chapter_link="./01-04-modo-visual", prev_chapter_title="Modo Visual", next_chapter_link="./01-05-modo-de-comando", next_chapter_title="Modo de Comando") }}

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.
+
+<!-- more -->
+
+Neste ponto você deve estar entendendo como os modos do VIM funcionam, para que
+cada um funciona e tento uma idéia básica de como editar arquivos. Como eu
+falei já duas vezes, a quantidade de comandos disponíveis é gigantesca, então
+vamos aproveitar esse pequeno momento em que as coisas começam a fazer sentido
+para ver mais alguns comandos.
+
+## [Shift]+j (Modo normal)
+
+"Junta" a linha abaixo do cursor com a atual. Pode não parecer muito, mas o VIM
+irá colocar um espaço no final da linha atual[^1] antes de juntar com a linha
+abaixo e removerá todo caractere branco da linha de baixo antes de juntar as
+duas linhas.
+
+## x (Modo normal)
+
+Apaga o caractere sob o cursor. O mesmo que `[Del]`.
+
+## gq (Modo normal)
+
+Reformata o parágrafo. Não faz muito sentido para código (com algumas
+exceções), mas se você tiver configurado a coluna máxima (vou explicar como
+fazer isso na parte de configuração do VIM), você pode selecionar um comentário
+em modo visual e usar gq para que o VIM alinhe o comentário no espaço definido.
+Também serve para quando você estiver editando arquivos de markup (MarkDown,
+reSTRUCTURED text, HTML, etc).
+
+## gg e G (Modo normal)
+
+`gg` move o cursor para o início do arquivo e `G` move o cursor para o fim do
+arquivo. Efetivamente, fazer `ggdG` (mover o cursor para o início do arquivo,
+remover tudo até o final do arquivo) irá remover todo o conteúdo do arquivo.
+
+## = (Modo normal)
+
+Reidenta o código usando a sintaxe atual.
+
+## u e [Ctrl]+r (Modo normal)
+
+Undo e redo, respectivamente.
+
+## [Ctrl]+y e [Ctrl]+e (Modo normal e Modo de inserção)
+
+Dois comandos que funcionam de forma diferente se executados em modo normal ou
+modo de inserção.
+
+No modo normal, `[Ctrl]+y` irá rolar o conteúdo do texto para baixo, mantendo o
+cursor na mesma posição enquanto que `[Ctrl]+e` irá rolar o conteúdo para cima,
+ainda mantendo o cursor na mesma posição. Se você abusar destes comandos,
+movendo a linha onde o cursor se encontra para fora da área visível, o cursor
+irá se mover.
+
+No modo de inserção, no entanto, `[Ctrl]+y` irá copiar o caractere da linha de
+cima na mesma coluna na posição atual; `[Ctrl]+e` faz o mesmo, mas com a linha de
+baixo.
+
+## . (Modo normal)
+
+Repete o último comando. Note que `.` irá repetir o último comando completo. Por
+exemplo, quando eu falei sobre `ggdG`, estamos falando, na verdade, de dois
+comandos completos: `gg` e `d{movimentação}`. `.`, neste caso, irá repetir o comando
+`dG`. Mais adiante veremos como criar "macros de teclado" e efetivamente permitir
+a execução de coleções de comandos.
+
+## :e e :files (Modo de comando)
+
+Edita um arquivo. Se não for passado o nome do arquivo depois do comando, o
+mesmo arquivo é recarregado do disco (em outras palavras, o buffer é atualizado
+com o conteúdo do arquivo). `:e#` recarrega o último arquivo aberto (por exemplo,
+se você estiver com o arquivo "arquivo" aberto e fizer `:e arquivo2`, usar `:e#`
+irá recarregar "arquivo" para o editor; usando `:e#` de novo, "arquivo2" será
+apresentado).
+
+Você pode ver os últimos arquivos abertos na sessão atual do VIM com `:files`. Se
+quiser recarregar algum destes arquivos de novo, basta usar `:e#{número}`, onde
+{número} é o número do arquivo na lista.
+
+## :sh (Modo de comando)
+
+Abre um shell dentro do VIM. Para retornar ao VIM, basta encerrar o shell.
+
+## :{número} (Modo de comando)
+
+Pula para a linha indicada. Por exemplo, `:100` irá para a centésima linha do
+arquivo.
+
+## [Ctrl]+] e [Ctrl]+t (Modo normal)
+
+`[Ctrl]+]` pula para a tag sob o cursor e `[Ctrl]+t` retorna. Mais adiante veremos
+como criar um arquivo de tags para que o VIM consiga navegar pelo código. A
+mesma idéia é usada no help do VIM: se você digitar `:help` irá ver a primeira
+página de ajuda do editor; para navegar entre os tópicos apresentados (marcados
+de forma diferente, dependendo do esquema de cor utilizado), é utilizado
+`[Ctrl]+]` para avançar e `[Ctrl]+t` para retornar para a página anterior.
+
+## ~ (Modo normal)
+
+Altera o caractere sob o cursor para maiúscula se for minúscula e vice-versa e
+move o cursor uma posição pra frente.
+
+## gu{movimentação}, gU{movimentação} e g~{movimentação} (Modo normal)
+
+`gu{movimentação}` altera todos os caracteres em {movimentação} para minúsculas.
+
+`gU{movimentação}` altera todos os caracteres em {movimentação} mara maiúsculas.
+
+`g~{movimentação}` faz `~` nos caracteres em {movimentação} (ou seja, os caracteres
+da posição do cursor até movimentação ficarão em maiúsculas se estiverem em
+minúsculas e vice-versa).
+
+## [Ctrl]+p e [Ctrl]+n (Modo de inserção)
+
+Auto-complete. `[Ctrl]+p` tenta completar a palavra antes do cursor voltando no
+texto enquanto que `[Ctrl]+n` tenta completar com palavras mais a frente no
+texto.
+
+## [Ctrl]+a e [Ctrl]+x (Modo normal)
+
+Incrementa (`[Ctrl]+a`) ou decrementa (`[Ctrl]+x`) o número sob o cursor. O VIM
+automaticamente detecta se o número está em decimal, octal ou hexa.
+
+E MAIS!
+
+## w (Modo normal)
+
+Move o cursor para o começo da próxima palavra.
+
+## e (Modo normal)
+
+Move o cursor para o fim da próxima palavra.
+
+## b (Modo normal)
+
+Move o cursor para o começo da palavra anterior.
+
+## ge (Modo normal)
+
+Move o cursor para o fim da palavra anterior.
+
+[^1] ... a não ser que o primeiro caractere (não branco) da linha de baixo seja
+     um ")"; neste caso, o VIM não adiciona o espaço.
+
+{{ chapters(prev_chapter_link="./01-05-modo-de-comando", prev_chapter_title="Modo de Comando", next_chapter_link="./03-recortar-copiar-colar", next_chapter_title="Recordar, Copiar e Colar") }}

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.
+
+<!-- more -->
+
+Assim como outros editores, o VIM tem um sistema de copiar e colar. E, como
+vimos vendo desde o começo, o VIM tem seu modo peculiar de lidar com isso.
+
+Toda a parte de copiar-e-colar do VIM é feita em modo normal. E sem que você
+soubesse, você já stava vendo a parte de recordar textos desde a parte de
+comandos do modo normal: Qualquer comando que exclua texto imediatamente
+transfere a parte excluído para a área de transferência do VIM. A única parte
+que ficou faltando foi como você “cola” estes textos de volta.
+
+E, para colar, você usa `p` (de "paste", veja só!).
+
+E, obviamente, existe o `[Shift]+p` também. E a diferença é facilmente explicada
+se voltarmos para o capítulo #2.2.
+
+Quando falamos do cursor, eu disse que o cursor encontra-se na parte inferior
+esquerda do bloco do cursor. O colar do VIM é feito depois do cursor. Assim, ao
+pressionar `p`, o texto irá aparecer depois do caractere sob o cursor; se for
+pressionado `[Shift]+p`, o texto será colado antes do caractere atual, empurrando
+o mesmo pra frente.
+
+O funcionamento muda um pouco se você recortar o texto usando o modo visual de
+linha (ou recortar usando algum movimento que desconsidere a coluna atual).
+Nestes casos, o VIM entende que você quer colar uma linha inteira e, ao invés
+de mover o conteúdo da linha atual, o texto é colado abaixo da linha atual,
+desconsiderando a posição do cursor. `[Shift]+p` irá colar o texto antes da linha
+atual.
+
+(Embora pareça complicado, a medida que você for se aclimatando com o
+copiar-e-colar do VIM, você verá que não é tão diferente dos demais editores --
+com a exceção que os outros editores tentam adivinhar quando você quer fazer
+copia de linhas inteiras ou apenas pedaços, enquanto que o VIM deixa você mesmo
+decidir quando fazer isso.)
+
+A única coisa que ficou faltando agora foi como copiar o texto sem remover o
+mesmo antes -- porque, vamos admitir, recortar e colar de novo seria muita
+burrice.
+
+O comando para copiar é `y{movimentação}`. Normalmente, ele é chamado de "yank"
+(arrancar) e por isso muitos chamam o sistema de "copy'n'paste" do VIM de
+"yank'n'paste".
+
+Para copiar a linha inteira, você pode usar `yy`. Isto copia toda a linha,
+incluindo o marcador de nova linha, e o VIM vai entender que, na hora de colar,
+você quer colar a linha inteira, seguindo as mesmas regras que eu expliquei
+acima sobre o modo visual de linha.
+
+Assim como outros editores, o VIM mantém a área de transferência entre arquivos
+(com isso, você pode abrir um arquivo, copiar um texto, abrir outro arquivo e
+colar a parte selecionada do primeiro) e, normalmente, o VIM ainda consegue
+manter a área de transferência entre execuções. Entretanto, uma coisa que você
+pode não gostar é que a área de transferência pertence e é gerenciada
+exclusivamente pelo VIM -- ou seja, ele não usa a área de transferência do
+sistema operacional[^1]. Assim, você não vai conseguir copiar do VIM e colar no
+seu browser ou vice-versa.
+
+.. a não ser que você use registradores, que nós vamos ver a seguir.
+
+[^1] E não, o "botão do meio dentro do X" não é a mesma coisa a área de
+     transferência.
+
+{{ chapters(prev_chapter_link="./02-outros-comandos", prev_chapter_title="Outros Comandos", next_chapter_link="./04-registradores", next_chapter_title="Registradores") }}

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.
+
+<!-- more -->
+
+No capítulo anterior eu mencionei que o VIM tem uma área de transferência
+própria e que ela não se comunica diretamente com a área de transferência do
+sistema operacional, apenas através de registradores.
+
+A forma mais simples de pensar em registradores é: são marcadores para áreas de
+transferência com nomes[^1].
+
+Para acessar os registradores, você deve usar `"{nome do registrador}`, onde
+{nome do registrador} é uma letra apenas. Assim, para copiar texto para um
+registrador, é utilizado `"{registrador}y{movimento}`; para retirar depois este
+texto do registrador, é utilizado `"{registrador}p`.
+
+Enquanto você estava vendo yank'n'paste do VIM, o VIM estava guardando o texto
+numa área de transferência apontanda pelo "registrador sem nome". E eu não
+estou brincando aqui: O próprio help do VIM chama este registrador de
+"registrador sem nome". A letra do registrador sem nome é `"` (ou seja, `""yy` e
+`yy` ambos irão copiar a linha atual para o registrador sem nome).
+
+Números são registradores especiais. 0 contém o último texto copiado para área
+de transferência; de 1 a 9 ficam os textos excluídos, em forma de pilha (o mais
+recente no registrador 1, o anterior a este no 2 e assim por diante; e quando
+mais texto é excluído, o conteúdo vai para o registrador 1, o conteúdo do
+registrador 1 vai para o registrador 2 e assim por diante).
+
+`-` é um registrador que guarda qualquer coisa excluída que for menor que uma
+linha inteira.
+
+Registradores com letras de "a" a "z" funcionam exatamente como esperado: `"ayy` irá
+copiar a linha atual para o registrador "a" enquanto que `"bp` irá colar o conteúdo
+do registrador b.
+
+Note que até agora eu chamei os registradores normais com minúsculas. O motivo
+é que, ao copiar algo para um registrador, o conteúdo anterior é removido, a
+não ser que você passe o nome do registrado em maiúsculas. Neste caso, o
+conteúdo movido para a área de transferência do registrador é adicionado ao
+conteúdo já existente. Assim, você pode copiar linhas não-contíguas usando `"ayy`
+para a primeira linha, `"Ayy` para as demais e depois colar com `"ap` (para o paste
+não há diferença entre maiúsculas e minúsculas).
+
+Outros registradores especiais são:
+
+## =
+
+Registrador de expressões. Você pode entrar fórmulas e depois colar o resultado
+no conteúdo com `p`. Uma coisa a cuidar aqui é que não é possível fazer `"=p`; o
+VIM irá imediatamente abrir espaço para entrar a fórmula ao digitar `"=`; ainda,
+o conteúdo é perdido se depois de digitar a fórmula você utilizar qualquer
+comando que não seja `p` (incluindo os comandos de movimentação).
+
+## _
+
+Registrador "buraco negro" (de novo, eu não estou brincando, o help do VIM
+chama esse registrador de "buraco negro"). Qualquer coisa enviada para este
+registrador é perdida; paste deste registrador retorna nada. Útil quando você
+quer excluir algum texto sem mexer no registrador sem nome.
+
+## +
+
+Registrador da área de transferência do sistema operacional. Somente disponível
+para aplicações GUI, já que estas tem acesso direto ao sistema (no caso do VIM
+console em Linux, o "sistema operacional" seria o próprio shell, que não tem
+uma área de transferência -- se você pensar nas bibliotecas envolvidas, a coisa
+faz sentido).
+
+[^1] Registradores também são usados para outras coisas, mas veremos isso mais pra frente.
+
+{{ chapters(prev_chapter_link="./03-recortar-copiar-colar", prev_chapter_title="Recortar, Copiar e Colar", next_chapter_link="./05-marcadores", next_chapter_title="Marcadores") }}

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.
+
+<!-- more -->
+
+Algumas vezes você precisa ficar pulando entre partes diferentes do seu
+arquivo. Alguns editores oferecem a funcionalidade de "bookmark" para linhas
+específicas e ficam "pulando" entre estes bookmarks. O VIM tem uma
+funcionalidade semelhante, chamada "Marcadores". A diferença é que enquanto os
+demais editores só tem um estado para marcadores (ativo ou não), o VIM permite
+que você tenha até 26 marcadores únicos -- e que podem ser acessados
+diretamente.
+
+Para marcar uma linha, você deve usar `m{nome do marcador}` em modo normal, onde
+`{nome do marcador}` é uma letra de "a" a "z". Para ir diretamente para um
+marcador, é só usar `'{nome do marcador}` para simplesmente mover o cursor para o
+primeiro caractere não branco na linha do marcador ou `\`{nome do marcador}` para
+mover o cursor exatamente para a posição do marcador (ambos também em modo
+normal).
+
+Como tudo no VIM, maiúsculas e minúsculas fazem diferença.
+
+Criar um marcador com um nome em minúsculas signifca que o marcador é valido
+somente dentro do arquivo. O marcador "a" do arquivo "arquivo1" não é o mesmo
+marcador "a" do arquivo "arquivo2". Quando um marcador é criado em maiúsculas,
+ele se torna global: Se você fizer `mA` no arquivo "arquivo1" e abrir o arquivo
+"arquivo2", `\`A` irá voltar para o arquivo "arquivo1" (na posição do marcador,
+obviamente).
+
+E como tudo no VIM, sempre existem os comandos mágicos.
+
+## \`\` ou ''
+
+Retorna para a última posição onde foi feito um "pulo". Por exemplo, se você
+está na linha 100 do arquivo atual, e fizer um pulo para o marcador "a" (com `\`a`,
+por exemplo), ``\`\`` irá retorna para a linha 100. Note que isso não gera um
+marcador per se, já que fazer ``\`\`` de novo irá retornar para a posição do
+marcador "a" (pois foi lá que aconteceu o último pulo).
+
+
+## \`. ou '.
+
+Retorna para a última posição onde houve alteração de texto. O exemplo que eu
+posso pensar neste caso é quando você está digitando um comando e não se lembra
+se fez o #include ou import necessário. Neste caso, você simplesmente termina
+de digitar o comando, usa `gg` para ir para o começo do arquivo para verificar se
+o include/import está lá e, se tiver, usa `\`.` para retornar para a posição
+original.
+
+
+## \`[ ou '[ e \`] ou ']
+
+Retorna para a posição onde o texto foi copiado ("yanked") para a área de
+transferência (qualquer área de transferência). `[` irá mover para o primeiro
+caractere copiado e `]` para o último.
+
+
+## \`" ou '"
+
+Move para a última posição do arquivo quando o arquivo foi fechado. Isto
+normalmente é controlado pelo arquivo de inicialização, que veremos mais a
+frente.
+
+E, para ver onde estão as marcas atuais, você só precisa usar `:marks` no modo de
+comando.
+
+{{ chapters(prev_chapter_link="./04-registradores", prev_chapter_title="Registradores", next_chapter_link="./06-macros-de-teclado", next_chapter_title="Macros de Teclado") }}

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.
+
+<!-- more -->
+
+No capítulo #3, eu falei rapidamente do commando `.`, que repete o último comando
+completo. Mas como repetir comandos que são, na verdade, uma composição de
+vários outros comandos?
+
+A resposta são macros de teclado.
+
+Macros de teclado permitem que você grave uma execução qualquer e depois a
+repita quantas vezes quiser.
+
+Para fazer uma macro de teclado, você deve, em modo normal, executar
+`q{registrador}`. Ao fazer isso, a última linha do VIM irá mostrar "recording",
+indicando que o editor está agora gravandos todas as teclas pressionadas no
+registrador. Para encerrar a gravação pressione `q` novamente (desta vez, sem o
+registrador). Para "tocar" a macro, é necessário usar `@{registrador}`.
+
+Quem prestou atenção no capítulo #5, deve ter notado que eu usei a palavra
+"registrador" de novo. E a base da questão é que realmente os dois são a mesma
+coisa: Se você copiar algo para o registrador `a` (`"ayy`, por exemplo) e depois
+gravar a macro "a", o conteúdo copiado para a área de transferência será perdido.
+Em compensação, se você criar a macro no registrador "a", você pode ver
+exatamente a sequência de comandos usados usando `"ap`. Ou ainda, você pode
+colocar a sequência de comandos desejada num arquivo (ou no próprio arquivo),
+copiar para o registrador necessário e depois só "tocar" o registrador.
+
+Como exemplo, imagine que você tem uma lista de constantes que você quer
+transformar em uma lista de strings. No caso, você teria que adicionar uma aspa
+no começo, uma aspa no final, uma vírgula e passar para a próxima linha. Se
+forem apenas 4 constantes, é fácil repetir os comandos em cada linha; mas se
+forem 100, a coisa fica diferente.
+
+Neste caso, você faria o seguinte: Na primeira linha, executaria
+`qaI"[Esc]A",[Esc]jq` -- ou seja, iniciaria a macro "a", entraria em modo de
+inserção no primeiro caractere não branco da linha (`I`), colocaria uma aspa,
+sairia do modo de inserção, entraria novamente no modo de inserção mas desta
+vez movendo o cursor para o último caractere antes (`A`), adicionaria a aspa que
+encerra a string e uma vírgula, moveria para a linha de baixo e encerraria a
+macro de teclado. Até aqui espero que não tenha nada de surpresas. Agora você
+pode repetir `@a` 99 vezes para as próximas linhas ou simplesmente executar `99@a`
+e deixar o VIM repetir a macro 99 vezes. No final, bastaria simplesmente
+remover a última vírgula.
+
+Uma coisa a ter em mente -- além da questão do registrador -- é que o VIM
+encerra tanto a macro quanto o número de repetições se houver qualquer
+problema. Por exemplo, se no meio da sua macro você colocar um `f.` para mover
+o cursor para o próximo ponto, mas no meio da execução não for encontrado
+nenhum ponto, a macro será interrompida e qualquer execução posterior será
+encerrada, não importando se for a 99<sup>a</sup> execução da macro ou a
+1</sup>a</sup>. Se você perceber que a execução não terminou onde deveria,
+basta executar `u` em modo de comando para desfazer a execução da macro.
+
+{{ chapters(prev_chapter_link="./05-marcadores", prev_chapter_title="Marcadores", next_chapter_link="./07-procurar-varios-arquivos", next_chapter_title="Procurar em Vários Arquivos") }}

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.
+
+<!-- more -->
+
+Já vimos o comando de pesquisa, que tem um modo inteiro só pra si[^1].
+
+Mas como fazer para encontrar ocorrências de uma palavra em mais de um arquivo?
+Para isto, existe o comando `:grep`.
+
+O grep é uma ferramente comum em Unixes (e Linux) em geral, mas o VIM tem
+scripts que fazem a mesma coisa em outros sistemas operacionais (por exemplo,
+Windows). Assim, o mesmo comando vai funcionar da mesma forma não importando
+qual sistema você esteja utilizando.
+
+Como o `:grep` usa outras funcionalidades existentes no VIM, iremos ver um pouco
+mais do que simplesmente "Procurar", mas isso é necessário.
+
+Como o modo de pesquisa, `:grep` precisa de uma expressão regular. Ao contrário
+do modo de pesquisa, o `:grep` também precisa de uma lista de arquivos a serem
+pesquisados. Por baixo dos panos, o que o VIM faz é chamar o comando "grep" (do
+Unix), verifica o resultado e permite pular facilmente entre os elementos
+encontrados (então todas as opções disponíveis para o grep podem ser passadas
+diretamente de dentro do VIM).
+
+Por exemplo, para pesquisar por arquivos que contém a palavra "void", você só
+precisa executar o comando `:grep void *` (onde `:grep` é o comando, `void` é a
+expressão a ser pesquisada e `*` é a lista de arquivos a serem pesquisados). Como
+o grep (o aplicativo do Unix) somente pesquisa arquivos no diretório
+especificado (no nosso caso anterior, como não foi passado diretório algum,
+será considerado o diretório atual), o `:grep` (o comando do VIM) também não vai
+entrar em nenhum subdiretório (de novo, porque o VIM simplesmente chama o grep
+[aplicativo do Unix] e facilita pular entre os elementos encontrados). Para
+fazer uma procura que encontre a expressão além do diretório atual, basta
+adicionar a opção "-r" para o grep (`:grep void -r *`).
+
+Ok, agora que você sabe usar o `:grep`... Como é que você vê os resultados?
+
+Primeira informação periférica: O VIM tem um tipo de "janela" especial, chamada
+"Quickfix". Essa "janela" é, na verdade, um "split" da tela (e mais a frente
+veremos como trabalhar com "splits" e abas). Para exibir o Quickfix, é usado o
+comando `:copen`; para fechar o Quickfix, basta usar `:copen` de novo. Para
+passar para o próximo elemento existente no Quickfix, use `:cnext` (ou
+simplesmente `:cn`); para passar para o elemento anterior, use `:cprevious` (ou
+simplesmente `:cp`); para mover o cursor para a posição do elemento atual do
+Quickfix, use `:cc` (que é simplesmente `:cc` mesmo).
+
+A segunda informação periférica: Como eu falei, usar `:grep {expressão} *` irá
+procurar "{expressão}" a partir do diretório atual. Para descobrir qual é o
+"diretório atual" para o VIM, use `:pwd` (de "print working directory", que
+também é um comando Unix); para mudar para outro diretório, utilize o comando
+`:cd {diretório}`, como você faria num shell normal.
+
+(E antes que alguém pergunte: Sim, você pode fazer um grep fora do diretório
+atual passando o diretório em questão no próprio comando do grep: `:grep void
+/tmp -r` irá procurar por "void" em todos os arquivos existentes no diretório
+/tmp.)
+
+[^1] Apenas para lembrar, `/` entra no modo de pesquisa, onde só é preciso entrar
+	 a expressão regular a ser encontrada; para passar para a próxima
+	 ocorrência, use `n` em modo normal; para passar para a ocorrência anterior,
+	 use `N` também em modo normal; para remover o realce das palavras
+	 encontradas, use `:noh` em modo de comando.
+
+{{ chapters(prev_chapter_link="./06-macros-de-teclado", prev_chapter_title="Macros de Teclado", next_chapter_link="./08-localizar-substituir", next_chapter_title="Localizar e Substituir") }}

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.
+
+<!-- more -->
+
+Uma coisa relativamente comum quando se está programando é substituir todas as
+ocorrências de uma palavra por outra[^1].
+
+Para fazer "localizar e substituir" ("search and replace") existe o comando
+`:substitute` em modo de comando (ou simplesmente `:s`).
+
+Até aí sem problemas, mas existe uma pequena pegadinha (na verdade, duas, mas
+uma de cada vez): `:s` é, na verdade, `:{range}s`, onde "{range}" é a parte do
+texto que o comando `:s` deve ser executado -- e sim, eu sei que não falei
+sobre este tipo de comando antes, mas essa era a melhor oportunidade.
+
+Então, {range}. {range} é opcional e, se não for passado, o comando será
+executado da linha atual. Isto, obviamente, não é muito útil. {range} é formado
+por um par[^2], separado por vírgulas, indicando o início e o fim da execução do
+comando.
+
+O uso básico de {range} é "linha inicial,linha final". Por exemplo, `:1,5s` irá
+executar o comando `:s` entre as linhas 1 (a primeira, não existe linha 0 no
+VIM) e 5.
+
+E, mais uma vez, existem indicadores especiais, inclusive para {range}.
+
+Um número indica o número da linha, como já comentei. "$" é a última linha do
+arquivo (assim, `:1,$s` irá executar `:s` em todo o arquivo); "%" é um alias
+para "1,$" (ou seja, todo o arquivo); `'{marcador}` irá, obviamente, utilizar
+os marcadores (ou seja, `:'a,'bs` irá executar `:s` entre o marcador "a" e o
+marcador "b" -- E marcadores entre arquivos [em maiúsculas] não são
+permitidos).
+
+(E existe outros dois marcadores especiais que eu não comentei antes por achar
+que não há uso fora do `:s` que são `'<` e `'>` que indicam, respectivamente, o
+início e o fim da região visual -- mas o VIM vai adicionar estes dois
+marcadores automaticamente se você tiver uma região visual selecionada e
+pressionar `:` e por isso ficaram pra trás. Então não se assuste se o VIM
+começar a colocar coisas na linha de comando sem que você tenha digitado.)
+
+Daqui pra frente, eu vou colocar o comando como `:%s`, já que esta é a execução
+mais comum do comando. Mas lembre-se que `%` = `1,$` = do começo ao fim.
+
+`:%s` funciona, assim como a pesquisa, com expressões regulares, só que ao invés
+de termos uma expressão, teremos duas: a de pesquisa e a de substituição. Em
+casos mais simples, onde você quer substituir "palavra 1" por "palavra 2", o
+comando será `:%s/palavra 1/palavra 2`. Mais uma vez, conhecer expressões
+regulares vai ajudar aqui -- e fica a dica para olhar sobre "grupos".
+
+A segunda pegadinha é que `:%s` executa o comando em cada linha do range e, como
+padrão, somente a primeira ocorrência é substituída. Assim, se "palavra 1"
+existir mais de uma vez em uma linha, somente a primeira será alterada.
+
+Para resolver isso, você deve usar o terceiro parâmetro de `:%s`, {flags}. As
+flags mais comuns são:
+
+<dl>
+	<dt>g</dt>
+	<dd>Substitui todas as ocorrências da expressão de procura na linha, não apenas
+		a primeira.</dd>
+	<dt>i</dt>
+    <dd>Ignora maiúsculas e minúsculas ("ignore case")</dd>
+	<dt>c</dt>
+    <dd>Pede confirmação em cada alteração.</dd>
+</dl>
+
+Concluindo: para substituir "void" por "int\*" em todo o arquivo mas apenas no
+começo da linha, ignorando se está em maiúsculas ou minúsculas (porque o
+estagiário pensou que estava digitando uma monografia), mas confirmando cada
+mudança, você faria `:%s/^void/int*/ic` (como é apenas no começo da linha e nós
+forçamos isso na expressão regular -- o `^` ali -- não precisamos usar a flag "g",
+já que não teria efeito nenhum).
+
+[^1] E, mas pra frente, veremos que existem plugins que deixam esta parte mais
+     fácil.
+
+[^2] Na verdade, não e um par mas, de novo, fazer substituição em apenas uma
+	 linha não é muito útil, principalmente considerando os comandos que o VIM
+	 tem para movimentação do cursor.
+
+{{ chapters(prev_chapter_link="./07-procurar-varios-arquivos", prev_chapter_title="Macros de Teclado", next_chapter_link="./09-splits", next_chapter_title="Splits") }}

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.
+
+<!-- more -->
+
+Até agora, enquanto falávamos de editar textos no VIM, vimos apenas como editar
+um arquivo por vez. Existem formas de editar mais de um arquivo (usando `:e` e
+`:e#{número}`) mas estas estão longe de serem fáceis de serem utilizadas.
+
+Existem duas formas de manter dois (ou mais) arquivos abertos ao mesmo tempo.
+Uma delas são "splits". Basicamente, splits permitem que você "reparta" a tela
+em pedaços, podendo mostrar outros arquivos (ou até mesmo outra vez o mesmo
+arquivo).
+
+Para criar splits, existem dois comandos que devem ser usados em modo de
+comando: `:sp` e `:vsp`. Ambos comandos aceitam o nome do arquivo a ser aberto no
+novo split; se não for passado o nome de um arquivo, o arquivo que já está
+aberto será carregado.
+
+A diferença entre eles é que `:sp` irá criar um split horizontal...
+
+![](horizontal-split.png)
+
+... enquanto que `:vsp` irá criar um split vertical.
+
+![](vertical-split.png)
+
+Dentro de cada split, comandos executados irão afetar apenas o buffer atual: `:w`
+irá salvar apenas o arquivo apresentar no split atual, `:e` irá abrir um arquivo
+no split atual e assim por diante.
+
+Note que eu falei "buffer atual". Como falei antes, "buffer" é o nome dado para
+a representação do arquivo em memória e que tanto `:sp` quanto `:vsp` sem
+parâmetros irão abrir um split com o arquivo atual -- que, na verdade, é o
+buffer atual. Se você fizer isso e começar a editar o texto em um dos splits, o
+conteúdo do outro também irá mudar, já que ambos estão apresentando o mesmo
+buffer.
+
+Para fechar um split, basta fechar o arquivo, tanto com `:q` quanto `:wq` ou
+qualquer outro comando que feche um arquivo. O split será removido e o cursor
+irá para o próximo split. Se não houverem mais splits, o VIM irá fechar, como
+já vinhamos vendo desde o começo.
+
+E sim, você pode fazer quantos splits e de formas diversas quantas vezes quiser
+(até que não sobre mais espaço na tela, quer dizer).
+
+![](all.png)
+
+Para "manusear" splits, você irá utilizar comandos que começam com, em modo
+normal, `[Ctrl]w`. `[Ctrl]w`, por si só, não faz nada (a não ser que você
+repita o comando, mas isso é outra coisa) e requer uma ação a ser executada no
+split (assim como alguns comandos requerem uma movimentação).
+
+## [Ctrl]wj ou [Ctrl]w[direcional para baixo]
+
+Move o cursor para o split abaixo do atual. Se não houverem outros splits
+abaixo do atual, permanece no mesmo. Aceita um número de repetiçoes, ou seja,
+`3[Ctrl]wj` irá imediatamente pular para o 3o. split abaixo do atual.
+
+## [Ctrl]wh ou [Ctrl]w[direcional para a esquerda] e [Ctrl]wk ou [Ctrl]w[direcional para cima] e [Ctrl]wl ou [Ctrl]w[direcional para a direita]
+
+O mesmo que [Ctrl]wj, mas indo para o split da esquerda, acima ou direita,
+respectivamente.
+
+## [Ctrl]w+ e [Cltr]w-
+
+Aumenta ou diminui o tamanho do split em uma linha. Se for passado um número
+antes do comando -- por exemplo `3[Ctrl]w+` -- o número de linhas afetas será o
+número indicado.
+
+## [Ctrl]w> e [Ctrl]w<
+
+O mesmo que `[Ctrl]w+` e `[Ctrl]w-`, mas altera o número de colunas ao invés do número de linhas.
+
+## [Ctrl]w\_ e [Ctrl]w|
+
+Deixa o split com o maior altura possível (ou seja, coloca o máximo de linhas
+possíveis para o split) ou com a maior largura possível (ou seja, coloca o
+máximo de colunas possíveis para o split).
+
+## [Ctrl]w=
+
+Altera o tamanho dos splits para que estes fiquem o mais equilibrados
+possíveis.
+
+## [Ctrl]wH, [Ctrl]wJ, [Ctrl]wK,/tt> e [Ctrl]wL
+
+Move o split atual para o canto mais a esquerda, abaixo, acima ou direita,
+respectivamente (note que a letra de movimentação está em maiúsculas).
+
+## [Ctrl]ww
+
+Move o cursor para o split anterior. Se você está em um split qualquer e fizer
+`3[Ctrl]wj` para ir para o 3<sup>o</sup> split abaixo do atual, `[Ctrl]ww` irá
+mover o cursor de volta para o split original (e `[Ctrl]ww` irá mover o cursor
+de volta para o 3<sup>o</sup> split abaixo do atual).
+
+## [Ctrl]wf
+
+Abre o arquivo com o nome sob o cursor em um novo split.
+
+Quando falei do grep, eu comentei que existe o comando `:cope` para abrir a
+janela do Quickfix. Bom, se você quiser ficar pulando entre a janela do
+Quickfix e o texto, os comandos `[Ctrl]w` acima irão ajudar.
+
+Existem ainda alguns outros comandos para splits, mas veremos estes mais a
+frente.
+
+{{ chapters(prev_chapter_link="./08-localizar-substituir", prev_chapter_title="Localizar e Substituir", next_chapter_link="./10-abas", next_chapter_title="Abas") }}

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.
+
+<!-- more -->
+
+Além dos splits, que vimos no capítulo anterior, VIM também tem suporte à abas.
+O mais interessante é que você pode usar abas tanto no VIM gráfico (também
+chamado de GVim) quanto no console.
+
+Para abrir um arquivo no VIM, sabemos que temos que usar o comando `:e`; para
+abrir o arquivo em uma aba, o comando é `:tabe`.
+
+Ao contrário de splits, criar uma nova aba sem passar um arquivo não cria uma
+nova aba com o buffer atual; `:tabe` sem um nome de arquivo irá criar uma nova
+aba com um buffer em branco. E sim, você pode abrir o mesmo arquivo em mais de
+uma aba e as alterações feitas em uma irão refletir na outra.
+
+Para pular entre abas, você poder usar o comando `gt` em modo normal ou `:tabn` em
+modo de comando. Se você usar um número de repetições (p.ex. `3gt` ou `:tabn 3`) o
+VIM irá pular diretamente para aquela aba (no caso, para a terceira), não
+importando a aba atual. `gT` em modo normal ou `:tabp` move o cursor para a aba
+anterior.
+
+Se quiser mover abas de posição, você deve usar `:tabm`. `:tabm` irá mover a aba
+atual para ficar depois da aba indicada (p.ex., `:tabm 3` irá mover a aba atual
+para depois da terceira aba). `:tabm` também aceita parâmetros considerando a aba
+atual: `:tabm +2` irá mover a aba atual duas abas pra frente (para a direita) e
+`:tabm -2` irá mover a aba duas abas pra trás (para a esquerda).
+
+Atalhos padrão para mover para a próxima aba do sistema operacional também são
+aceitos por padrão. `[Ctrl][PageDn]` e `[Ctrl][PageUp]` no Linux e
+`[Command][Shift]]` e `[Command][Shift][` no OS X, por exemplo. Como não existe
+nenhum padrão para consoles, não há nenhum atalho padrão e devem ser usados os
+comandos de seleção de abas que vimos antes.
+
+Mais pra frente, quando estivermos falando do arquivo de configuração, eu vou
+explicar um "truque" para pular diretamente para a aba desejada, assim como
+funciona no Firefox e no Chrome.
+
+{{ chapters(prev_chapter_link="./09-splits", prev_chapter_title="Splits", next_chapter_link="./11-config", next_chapter_title="Arquivos de Configuração") }}

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.
+
+<!-- more -->
+
+Lembram que bem no começo, quando estávamos falando dos modos de execução, eu
+comentei que o modo Ex não era usado?
+
+Bom, eu menti. MUAHAHAHAHA!
+
+![](muahaha.jpg)
+
+Na verdade, o Modo Ex não é chamado comumente, mas os arquivos de configuração
+do VIM são um grande amontoado de comandos executando em modo Ex.
+
+E o que é o modo Ex, afinal de contas? O modo Ex nada mais é que o modo de
+comando sem a necessidade de usar `:` na frente de todos os comandos. Como
+ficaria complicado para, por exemplo, entrar no modo Ex, executar e arquivo,
+sair do modo ex e entrar em modo de inserção, até o momento temos usado o modo
+de comando para isso, já que economiza um monte de tecladas. Como não iremos
+ficar indo para o modo de inserção o tempo todo, e não faz sentido fazer um
+arquivo gigantesco com várias linhas começando com `:`, também faz sentido que o
+arquivo de configuração seja executado em modo Ex.
+
+O VIM tem um arquivo de configuração global (conhecido com "vimrc") e um arquivo
+para execução em modo gráfico ("gvimrc")[^1]. Ainda, existem duas versões de cada
+um destes arquivos: uma versão global para todos os usuários e uma versão
+definida para o usuário atual. Daqui pra frente, iremos ver as configurações do
+usuário, já que estas sobrepõem as globais.
+
+"vimrc" e "gvimrc" ficam no diretório dos dados do usuário; em qualquer um dos
+sistemas operacionais hoje, você consegue descobrir o diretório destes arquivos
+com `:echo $HOME` dentro do próprio VIM. Apenas note que embora eu venho chamando
+os arquivos de vimrc e gvimrc, os nomes são, na verdade, ".vimrc" e ".gvimrc" (ou
+"\_vimrc" e "\_gvimrc" no caso do Windows).
+
+Como existem muitas opções, não vou aqui explicar cada uma delas -- mas, no
+próximo capítulo eu vou mostrar o arquivo que eu estou usando para servir de
+guia.
+
+O que você vai ver quando abrir um arquivo de configuração:
+
+## set
+
+`set` é, efetivamente, a forma de "setar" alguma configuração no VIM.
+
+Existem dois tipos de configurações: As com valores e flags.
+
+Flags é mais fácil de ser explicado: você simplesmente seta a configuração. Por
+exemplo, fazer com que o VIM mostre uma coluna com o número de cada linha,
+você pode usar `:set number` (ou simplesmente `set number` dentro do arquivo de
+configuração). Para desligar uma opção deste tipo, você só precisa adicionar
+"no" na frente (para desligar number é usado `:set nonumber`).
+
+"Valores" é exatamente o que significa: Ao invés de ser uma simples flag, a
+opção recebe uma string ou número. Por exemplo, `:set tabstop=4` irá definir que
+o tamanho da tabulação é de 4 espaços. `:set notabstop` não tem efeito aqui, já
+que não é uma flag.
+
+Para fazer com que uma configuração volte ao seu valor/estado original, use
+`:set {opção}&`; para verificar o valor de uma opção, use `:set {opção}?`.
+
+Talvez a coisa não esteja muito clara aqui, mas quando examinarmos um arquivo
+de configuração real, as coisas irão clarear.
+
+## let
+
+`let` é usado para definir o valor de uma variável. Uma variável tem sempre um
+valor -- ou seja, não existem "variáveis flags". Variáveis são normalmente
+utilizadas por plugins ou arquivos de sintaxe e, portanto, as variáveis que
+você terá que usar vão depender do que você está usando.
+
+(Obviamente, se você estiver escrevendo seu próprio plugin — que eu não vou
+abordar aqui — o uso de variáveis vai ser praticamente obrigatório.)
+
+## if
+
+`if`, como em qualquer linguagem de programação, serve para execução
+condicional. Você pode, por exemplo, verificar se alguma feature foi ativada na
+compilação do binário, se alguma opção está ligada, etc.
+
+Por exemplo, para verificar se o suporte à scripts Python foi adicionado, você
+pode fazer:
+
+```viml
+if has('python')
+   " configuração em python vai aqui
+end
+```
+
+Para verificar se alguma opção está ativa:
+
+```viml
+if &compatible
+   " configuração em modo de compatibilidade com o VI original
+end
+```
+
+ou para conferir um valor:
+
+```viml
+if &t_Co > 2
+   " configuração quando há suporte a mais de 2 cores.
+end
+```
+
+E assim por diante.
+
+## map, imap (e outros)
+
+`map` pode ser usado para mapear teclas para outras funções. Por exemplo `:map Y
+y$` irá mapear "Y" para executar `y$` (copiar da posição atual do cursor até o fim
+da linha). Com excessão de [Shift], qualquer modificador pode ser usado:
+
+* C - para `[Control]`
+* M - para `[Alt]` (que normalmente é chamado de "Meta" em sistemas Unix — e por isso "M")
+* O - para `[Command]` (somente em Macs)
+
+Por exemplo, `:map C-m yy` irá adicionar `[Ctrl]m` para copiar a linha inteira.
+
+Ainda, a diferença entre `map` e `imap` é que `map` é global enquanto que
+`imap` só irá funcionar em modo de inserção (e assim você pode imaginar o que
+`nmap` e `vmap` fazem, certo?)
+
+## au (ou autocmd)
+
+Comandos que são executados em determinadas condições. Condições podem desde
+"FileType" para ações confirme o tipo de arquivo e "BufRead", "BufWrite" e
+relacionados quando um buffer for aberto ou fechado.
+
+O que seriam os "relacionados"? Bom, alem de ser na leitura/escrita do arquivo,
+podem ser adicionados comandos antes da execução ("BufReadPre", "BufWritePre"),
+depois da execução ("BufReadPost", "BufWritePost") e durante ("BufReadCmd",
+"BufWriteCmd").
+
+(Existem ainda auto-comandos para quando o editor entrar em modo de edição,
+abrir o VIM gráfico, VIM está fechando, e assim por diante. Para ver todos os
+eventos, digite `:help autocmd-events`.)
+
+Por exemplo, `au FileType smarty set ai` para ligar a auto-identação quando VIM
+detectar que você está editando um arquivo Smarty (engine de templates para
+PHP). Ou ainda `au BufRead set nocompatible` irá configurar o editor para entrar
+em modo de não-compatibilidade com VI depois de abrir qualquer arquivo.
+
+Ainda, é possível encadear auto-comandos, por exemplo, `autocmd FileType python
+autocmd BufWritePre :%s/\s\+$//e` irá fazer com que quando o tipo de arquivo for
+"python", seja criado um auto-comando que antes de salvar o arquivo, seja
+executado um comando de substituição no buffer -- que remove espaços em branco
+no final da linha).
+
+(Se você está perdido com o que está vendo aqui, não se preocupe -- a tendência
+é que, ao ver um arquivo de configuração real, você entenda o que está
+acontecendo).
+
+[^1] Existe um terceiro, .exrc, mas honestamente, em todo esse tempo usando o
+     VIM, eu nunca tinha ouvido falar que este arquivo sequer existia.
+
+{{ chapters(prev_chapter_link="./10-abas", prev_chapter_title="Abas", next_chapter_link="./11-01-vimrc", next_chapter_title="Meu .vimrc") }}

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.
+
+<!-- more -->
+
+Como falamos sobre arquivo de configuração, eu vou mostrar o que eu tenho hoje
+configurado no meu VIM, explicando o que cada comando faz. Boa parte do que eu
+tenho veio da configuração global do VIM, que eu copiei apenas para garantir
+que não importando onde eu esteja ou qualquer alteração que seja feita neste
+arquivo, as funcionalidades que eu estou acostumado continuarão funcionando
+como esperado.
+
+```viml
+set encoding=utf-8
+```
+
+Garante que os arquivos salvos estarão em UTF-8, ao invés de tentar converter
+para o encoding do sistema operacional.
+
+```viml
+set nocompatible
+```
+
+Desativa o modo de compatilidade com o VI original. Existem algumas diferenças
+entre ambos (por exemplo, depois de um fazer um undo (`u`), no VI original fazer
+undo de novo desfazia o undo anterior (efetivamente, fazendo um "redo") e para
+continuar fazendo undo, o primeiro comando depois de undo deveria ser `.`; no
+VIM, fazer um undo depois de um undo irá continuar desfazendo o que foi entrado
+no texto, até retornar ao estado original) e a não ser que você seja fã do VI
+original, eu não recomendaria usar o modo de compatilibidade.
+
+```viml
+set backspace=indent,eol,start
+```
+
+Apenas garante que o backspace consiga remover identações, apagar o fim da
+linha e o começo de uma linha (neste último, forçando a linha atual e se juntar
+com a anterior). Esse é o funcionamento normal de qualquer editor.
+
+```viml
+" Don’t use Ex mode, use Q for formatting
+map Q gq
+
+" Map Y to do the same (well, almost) as the D command
+map Y y$
+```
+
+Estes dois mapeamentos eu peguei da configuração global, mas nunca efetivamente
+usei. Mas, por via das dúvida...
+
+Ainda, uma coisa que eu não havia comentado: Comentários. Você pode comentar
+qualquer linha começando a mesma com aspas (") sem as aspas finais (senão o VIM
+irá interpretar o conteúdo como string). Então: Uma aspa, comentário; duas
+aspas, string; mais de duas, erro.
+
+```viml
+if &t_Co > 2 ||&
+  syntax on
+  set hlsearch
+endif
+```
+
+Ah, nosso primeiro encontro com ifs. Se o terminal tiver mais de duas cores
+(`&t_Co > 2`) ou estivermos rodando em GUI (`has("gui_running")`) então o
+suporte à sintaxes deve ser ligado (`syntax on`) e pesquisas devem marcar todas
+as ocorrências encontradas no último comando de pesquisa(`set hlsearch`)[^1].
+
+```viml
+" ------------------------
+"  Those are my settings
+" ------------------------
+
+set tabstop=4           " tabs are displayed as 4 spaces
+set shiftwidth=4        " by default, when auto-identing, add 4 spaces (or 1 tabstop)
+set foldmethod=marker   " fold on markers
+set scrolloff=1         " always show one line around the cursor
+set laststatus=2        " always show the status bar (’cause I like to see the line and column, always)
+set showtabline=2       " always show the tabline
+set showmatch           " show matching bracket
+set noerrorbells        " no error bells
+set autowrite           " write the file when switching between files or something
+set nowrap              " do not wrap long lines
+set nobackup            " do not keep a backup file, use versions instead
+set history=50          " keep 50 lines of command line history
+set ruler               " show the cursor position all the time
+set showcmd             " display incomplete commands
+set incsearch           " do incremental searching
+set formatoptions=tcq   " wrap with textwidth, wrap comments, insert commend leader (twice), format comments
+set smartindent         " smart identation
+set number              " show line numbers
+set wim=longest,list    " file auto-completion
+set background=dark     " to follow most of the colorschemes I use
+set vb t_vb=            " convert bells to visual bells and do nothing as visual bell
+
+set t_Co=256            " 256 color terminals
+
+let mapleader=","     " use comma to start user-defined (in plugins) functions
+```
+
+Um grande bloco de configurações. Vamos ver um por um:
+
+* `set tabstop=4`: Define o tamanho da tabulação. Se estiver usando o caractere
+  "tab" ao invés de espaço, estes caracteres serão mostrados como 4 espaços
+  (quando o padrão são 8).
+* `set shiftwidth=4`: Quando o VIM for identar um pedaço de texto sozinho[^2]. Se
+  "shiftwidth" for igual a "tabstop" e você não tiver configurado para usar
+  espaços ao invés de tabulações (calma que eu já explico como se faz isso), o
+  VIM irá adicionar uma tabulação inteira; se "shiftwidth" for menor que
+  "tabstop", espaços serão usados; se "shiftwidth" for maior que "tabstop",
+  será usada uma mistura de tabulações e espaços até que o tamanho especificado
+  seja alcançado.
+* `set foldmethod=marker`: "Folding" foi algo que eu não comentei até agora
+  porque eu até agora não consegui me aclimatar com folding (até porque eu não
+  consegui pensar num mnemônico para lembrar dos comandos). Mas, basicamente,
+  "folding" permite que você "oculte" partes do código com alguma condição.
+  Alguns arquivos de sintaxe definem início e fim de funções e isso pode ser
+  usado para ocultar toda uma função (apenas para exibição, a função continua
+  existindo lá). "marker" define que o método de folding são marcadores e os
+  marcadores padrão são "\{\{\{" para o início e "\}\}\}" para o fim.
+* `set scrolloff=1`: Número de linhas que devem sempre ficar visíveis ao redor do
+  cursor. "1" significa que antes de chegar à primeira ou última linha da tela,
+  o VIM irá rolar o texto e apresentar a linha anterior (ou próxima) -- enquanto
+  possível.
+* `set laststatus=2`: Quando estávamos vendo splits, você deve ter notado que o
+  VIM adicionou uma barrinha indicando a posição do cursor (e talvez mais
+  algumas outras informações). Esse é o padrão para "1" (mostrar a barra de
+  status quando houver splits); "0" nunca mostra e "2" mostra sempre.
+* `set showtabline=2`: Assim como "laststatus", se você estava vendo abas em modo
+  de console, deve ter reparado que a linha com as abas aparecia apenas quando
+  haviam duas ou mais abas. "2" define que essa linha de abas deve ser sempre
+  mostrada, mesmo quando há apenas uma aba.
+* `set showmatch`: Quando estiver sobre um caractere como parênteses, colechetes
+  ou chave, faz o highlight do elemento que abre ou fecha o correspondente.
+* `set noerrorbells`: Se ocorrer um erro, não utilize erros sons para
+  notificações[^3].
+* `set autowrite`: Quando o VIM passar o controle para outro aplicativo ("grep",
+  "make" ou mesmo o "shell"), salva o arquivo atual antes de passar a execução.
+* `set nowrap`: Quando uma linha for maior que a tela, desabilita a "quebra" da
+  linha e, com isso, é necessário "rolar" o conteúdo horizontalmente para ver o
+  resto. Um aviso: se você usar "wrap" (`set wrap`) o VIM vai continuar lidando a
+  linha como uma coisa só, desconsiderando como a mesma está sendo apresentada;
+  assim, se você estiver na primeira parte de uma linha que foi quebrada por
+  wrap, usar qualquer comando que vá para a próxima linha irá ir para a próxima
+  linha, não para a parte quebrada.
+* `set nobackup`: Não grava arquivos de backup. Por padrão, antes de salvar um
+  arquivo, o VIM guarda uma cópia do original com o mesmo nome seguido de "~".
+* `set history=50`: Quando você usa um comando, o VIM pode guardar esse comando
+  para execução futura, como o prompt do shell. Aqui é definido quantos destes
+  comandos são guardados.
+* `set ruler`: Sempre que possível, mostre a posição do cursor. Se "laststatus"
+  for "0" (ou "1" e não houver nenhum split), a posição é exibida na última
+  linha da tela, no canto direito; se "laststatus" for "2" (ou "1" e houver
+  pelo menos um split), a posição é exibida dentro da barra de status[^4].
+* `set showcmd`: Você deve ter notado que comandos que esperam mais informações
+  (por exemplo, aqueles que requerem uma movimentação) não são mostrados em
+  lugar algum. "showcmd" irá mostrar o comando até que ele seja concluído.
+* `set incsearch`: Enquanto você estiver digitando uma pesquisa, já vai
+  posicionando o cursor na primeira ocorrência encontrada. "noincsearch" irá
+  manter o cursor na mesma posição até que o mesmo seja concluído.
+* `set formatoptions=tcq`: Opções de formatação de textos. Cara um dos caracteres
+  representa algo diferente: "t" indica que se "textwidth" estiver definido, o
+  editor deve quebrar as linhas[^5]; "c" significa que se o texto for quebrado
+  durante um comentário (definido pela sintaxe atual), um novo caractere de
+  comentário deve ser adicionado; "q" indica que comentários podem ser
+  quebrados por "textwidth".
+* `set smartindent`: Utiliza identação inteligente, se a sintaxe não definir
+  nenhuma. Existem quatro tipos de identação: Nenhuma ("nosmartindent")
+  indicando que ao adicionar uma nova linha, nenhuma identação é adicionada;
+  "autoindent" para que novas linhas tenham a mesma identação da linha
+  anterior; "smartindent", que tenta usar o último caractere da linha para
+  identificar se deve ser adicionada uma nova identação ou não (por exemplo,
+  parênteses e chaves adicionam identação); e "cindent" que tenta seguir o
+  padrão para C. Note que essa configuração só vale para arquivos que não
+  definem uma identação no seu arquivo de sintaxe (que são bem poucos).
+* `set number`: Adiciona uma área na esquerda da tela com o número da linha na
+  própria linha.
+* `set wim=longest,list`: Duas coisas aqui: 1) comandos de set tem um nome
+  longo e um nome curto e "wim" é o nome curto para "wildmode"; 2) "wildmode"
+  define como serão completados os nomes dos arquivos quando você usar um
+  comando para abrir arquivos e usar [Tab] para tentar completar o nome do
+  arquivo automaticamente. "longest,list" emula o padrão de shells como Bash.
+* `set background=dark`: Alguns colorschemes (temas de cor) definem dois
+  padrões de cores, um claro e um escuro. "background=dark" define que, na
+  existência de dois padrões, o padrão escuro deve ser usado.
+* `set vb t_vb=:` Mais uma coisa nova: Duas configurações em uma linha só. Na
+  verdade, todas as configurações apresentadas aqui poderiam ficar em uma linha
+  só, mas eu mantive estas duas juntas por um motivo: Como defini
+  "noerrorbell", o VIM cai para "visualbell" (nome longo de "vb"), que causa um
+  "flash" no conteúdo (as cores do tema rapidamente se invertem e voltam ao
+  normal) quando ocorre um erro; no caso, eu defini que sim, eu quero que o
+  tipo de erro visual ("`t_vb`") seja... nada. Assim, quando ocorre um erro, o VIM
+  não bipa nem faz flash.
+* `set t_Co=256`: Define que o terminal terá, por padrão, 256 cores. Algumas
+  vezes o VIM não consegue descobrir se o terminal tem suporte a mais de 16
+  cores ou não e esta configuração reafirma que sim, o terminal é capaz de usar
+  256 e, portanto, colorschemes podem ter mais cores.
+* `let mapleader=","`: Define a variável "mapleader". "mapleader" é o caractere
+  que o VIM utiliza em alguns plugins[^5], quando estes define comandos em modo
+  normal. O padrão é "/", eu mudei para vírgula.
+
+```viml
+if has("autocmd")
+```
+
+Eu falei sobre auto-commands, mas na verdade é uma feature que deve ser
+adicionada na hora de compilar o VIM. Entretanto, até agora eu não vi um pacote
+disponível que não tenha essa feature. Apenas para garantir, verificamos se a
+funcionalidade foi adicionada mesmo ou não.
+
+Boa parte do que tem daqui pra frente ou eu já falei ou veio do arquivo de
+configuração global.
+
+```viml
+  filetype plugin indent on
+```
+
+Ativa as configurações vindas do arquivo de sintaxe. Quando eu disse que as
+configurações de auto-identação vem do arquivo de sintaxe, é esta linha que
+garante que isso vai acontecer.
+
+```viml
+  autocmd FileType text setlocal textwidth=78
+```
+
+Quando o tipo de arquivo for texto ("text") define localmente para aquele
+buffer que o tamanho da linha é de 78 colunas. Como "formatoptions" tem um "t",
+o VIM irá automaticamente quebrar a linha (adicionando um [Enter] antes da
+palavra que passa do limite) na coluna 78.[^7]
+
+```viml
+  " When editing a file, always jump to the last known cursor position.
+  " Don’t do it when the position is invalid or when inside an event handler
+  " (happens when dropping a file on gvim).
+  autocmd BufReadPost *
+    \ if line("’\"") > 0 && line("’\"") <= line("$") |
+    \   exe "normal g`\"" |
+    \ endif
+```
+
+Este comando existe no arquivo de configuração global, mas é bem interessante.
+Lendo exatamente o que ele faz: Depois de carregar qualquer arquivo, se a linha
+que o marcador de saída do buffer existir e estiver entre o começo do arquivo e
+antes do fim da linha, executa, em modo normal, `g\"`, que efetivamente "pula"
+para o marcador de saída do buffer. A diferença entre `\`` e `g\``` é que `g`` não mexe
+no jumplist quando pular (logo, ```` não vai funcionar). Como não mexer no
+jumplist é algo que não se faz normalmente, nem comentei antes.
+
+```viml
+  autocmd FileType python autocmd BufWritePre <buffer> :%s/\s\+$//e
+```
+
+Eu falei deste comando antes, mas vamos de novo: Quando o tipo de arquivo for
+"python", adicione um auto-comando que antes de gravar o buffer, execute, no
+buffer, a expressão regular `/\s\+$//e`, que basicamente, serve para remover
+espaços em branco no final das linhas.
+
+```viml
+  " omni completion
+  au FileType python setlocal ofu=pythoncomplete#Complete
+  au FileType javascript setlocal ofu=javascriptcomplete#CompleteJS
+  au FileType html setlocal ofu=htmlcomplete#CompleteTags
+  au FileType css setlocal ofu=csscomplete#CompleteCSS
+  au FileType xml setlocal ofu=xmlcomplete#CompleteTags
+  au FileType php setlocal ofu=phpcomplete#CompletePHP
+
+  set completeopt-=preview
+```
+
+Eu não falei do Omni-complete antes porque até o momento o auto-complete
+(`[Ctrl]p` e `[Ctrl]n` em modo de inserção) tem resolvido todos meus problemas.
+Mas, em teoria, o omni-complete consegue detectar quais elementos fazem sentido
+no contexto atual, "encherga" coisas que estão no arquivo de tags e conhece
+toda a sintaxe da linguagem que você está usando. Mas, realmente, o simples
+auto-complete já resolve 99% dos problemas que tenho encontrado.
+
+E desliga a apresentação dos resultados do omni-complete na janela de preview,
+que é semelhante ao quickfix, mas na minha experiência, ela quebra muito o
+fluxo de edição do código.
+
+Se você quiser tentar, para usar o omni complete basta usar `[Ctrl]x` seguido de
+`[Ctrl]o`.
+
+```viml
+  " ------------------------
+  "  Auto-commands
+  " ------------------------
+
+  " default python style
+  " (use spaces instead of tabs (expandtab), uses 4 spaces for tabs (tabstop),
+  " when auto-indenting, also use 4 spaces (shiftwidth), when deleting text, 4
+  " spaces are a tab (softtabstop) and break the line at column 78 (textwidth))
+  au FileType python setlocal expandtab tabstop=4 shiftwidth=4 softtabstop=4 textwidth=78
+
+  " reStructured files follow python closely, but use 3 tab stops instead of 4
+  au FileType rst setlocal expandtab tabstop=3 sw=3 sts=3 textwidth=78
+
+  " templates (Jinja2 in this case) will use tabs instead (to reduce file size)
+  au FileType htmldjango setlocal noet tabstop=4 shiftwidth=4 softtabstop=4 textwidth=0
+  au FileType jinja setlocal noet tabstop=4 shiftwidth=4 softtabstop=4 textwidth=0
+
+  " the smarty filetypes doesn’t have any sort of indentation, so we set it to
+  " auto
+  au FileType smarty setlocal ai
+
+  " PHP break lines at column 79, like Python
+  au FileType php setlocal textwidth=79
+
+  " svn (when editing svn commit messages, break lines at
+  " column 70)
+  au FileType svn setlocal tw=70
+
+  " email (mostly mutt stuff)
+  au FileType mail setlocal spell spelllang=en
+
+  " JavaScript (who though those were "good" defaults?)
+  au FileType javascript setlocal expandtab tabstop=2 sw=2 sts=2 textwidth=0
+```
+
+Uma série de auto-comandos baseados no tipo de arquivo. Como eu falei antes
+neste capítulo, você pode botar vários "set" um atrás do outro separados por
+espaço e sets tem versões com nomes longos e nomes curtos ("sts" é um atalho
+para "softtabstop", "sw" para "shiftwidth", "noet" para "noexpandtabs", "ai"
+para "autoindent" e "tw" para "textwidth"). E sim, eu sei que não manti nenhum
+padrão no meio, mas pelo menos agora você alguns nomes curtos para algumas
+opções.
+
+```viml
+else
+  set autoindent                " always set autoindenting on
+endif " has("autocmd")
+```
+
+E, se autocmd não estiver disponível, simplesmente seta auto-indent.
+
+```viml
+" ------------------------
+" mapings
+" ------------------------
+
+" Easy switching between tabs (just use Alt+<tab number>)
+if has(‘mac’)
+    map <D-1> :tabn 1<CR>
+    map <D-2> :tabn 2<CR>
+    map <D-3> :tabn 3<CR>
+    map <D-4> :tabn 4<CR>
+    map <D-5> :tabn 5<CR>
+    map <D-6> :tabn 6<CR>
+    map <D-7> :tabn 7<CR>
+    map <D-8> :tabn 8<CR>
+    map <D-9> :tabn 9<CR>
+    map <D-0> :tabn 10<CR>
+
+    imap <D-1> <ESC>:tabn 1<CR>a
+    imap <D-2> <ESC>:tabn 2<CR>a
+    imap <D-3> <ESC>:tabn 3<CR>a
+    imap <D-4> <ESC>:tabn 4<CR>a
+    imap <D-5> <ESC>:tabn 5<CR>a
+    imap <D-6> <ESC>:tabn 6<CR>a
+    imap <D-7> <ESC>:tabn 7<CR>a
+    imap <D-8> <ESC>:tabn 8<CR>a
+    imap <D-9> <ESC>:tabn 9<CR>a
+    imap <D-0> <ESC>:tabn 10<CR>a
+else
+    map <M-1> :tabn 1<CR>
+    map <M-2> :tabn 2<CR>
+    map <M-3> :tabn 3<CR>
+    map <M-4> :tabn 4<CR>
+    map <M-5> :tabn 5<CR>
+    map <M-6> :tabn 6<CR>
+    map <M-7> :tabn 7<CR>
+    map <M-8> :tabn 8<CR>
+    map <M-9> :tabn 9<CR>
+    map <M-0> :tabn 10<CR>
+
+    imap <M-1> <ESC>:tabn 1<CR>a
+    imap <M-2> <ESC>:tabn 2<CR>a
+    imap <M-3> <ESC>:tabn 3<CR>a
+    imap <M-4> <ESC>:tabn 4<CR>a
+    imap <M-5> <ESC>:tabn 5<CR>a
+    imap <M-6> <ESC>:tabn 6<CR>a
+    imap <M-7> <ESC>:tabn 7<CR>a
+    imap <M-8> <ESC>:tabn 8<CR>a
+    imap <M-9> <ESC>:tabn 9<CR>a
+    imap <M-0> <ESC>:tabn 10<CR>a
+endif
+```
+
+Ok, este é um mapeamento que eu sempre achei interessante:
+
+1. Existe uma diferença entre OS X e outros sistemas que a tecla "Command" é
+   usada para praticamente tudo, inclusive trocar as abas nos browsers; já em
+   outros sistemas, a tecla para isto é "Alt". Um VIM compilado para OS X tem,
+   estranhamente, uma feature chamada "mac"; checando isso você consegue
+   descobrir se está rodando num OS X ou não.
+
+2. Mapeamentos diferentes para modo normal e de inserção: Se estiver no modo
+   normal, basta usar `:tabn {número}` para pular diretamente para uma aba (`:tabn
+   {número}` é a versão de modo de comando do `{número}gt` do modo normal[^8][^9]);
+   quando estiver em modo de inserção, saida do modo de inserção (simulando
+   pressionar [Esc] com <ESC>, execute o mesmo comando usado no modo normal
+   para pular para uma aba específica e volte para o modo de inserção ("a").
+
+BOOM! Você acabou de adicionar no VIM uma feature que existe nos browsers.
+
+```viml
+" custom PHP syntax file configuration
+let php_smart_members=1
+```
+
+Essa é uma das coisas que eu falei antes: "let" permite definir variáveis,
+incluindo algumas dentro do arquivo de sintaxe. No caso "php_smart_members"
+altera a forma como funções membro de uma classe em PHP seja coloridas de forma
+diferente.
+
+O resto do meu arquivo de configuração é usado para manter plugins, que eu vou
+explicar o que cada um faz mais pra frente. Se você quiser ver o arquivo
+original, ele pode ser encontrado no meu repositório de configurações (que eu
+uso para manter as configurações sincronizadas entre meu computador pessoal e o
+computador do trabalho).
+
+[^1] Apenas para fazer um gancho com o que foi falado anteriormente: No
+	 capítulo #2.5, quando estava falando de comandos do modo de comando, eu
+	 comentei sobre `:noh` para desmarcar as ocorrências encontradas no último
+	 comando de pesquisa. Bom, `hlsearch` faz com que estas ocorrências sejam
+	 marcadas e se você colocar set `nohlsearch`, nenhuma ocorrência será marcada
+	 e você nunca irá precisar usar `:noh`.
+
+[^2] ... ou quando você usar `>{movimentação}` ou `<{movimentação}` em modo normal,
+	 que eu não havia mencionado antes porque estávamos falando de edição de
+	 qualquer texto e não de código fonte. `>>` irá adicionar um "shiftwidth"
+	 para a direita e `<<` irá remover um "shiftwidth" na esquerda.
+
+[^3] Aqui acabamos de ver duas configurações de flags: Uma ativando uma
+     configuração ("showmatch") e outra desligando ("noerrorbells").
+
+[^4] Uma pequena nota sobre as posições apresentadas: algumas vezes, você verá
+	 o VIM apresentar a coluna como "{número}-{número}". Isso acontece
+	 principalmente quando se está usando tabulações ao invés de espaços e o
+	 VIM está indicando a contagem de caracteres na esquerda e a coluna de
+	 exibição na direita (ou seja, o valor da direita é {quantidade de
+	 caracteres menos tabulações} + ({quantidade de tabulações} * {"tabstop"}).
+
+[^5] E quando digo "quebrar" eu quero dizer "quebrar" mesmo: Enquanto que
+	 "wrap" irá cuidar apenas da apresentação do texto, "textwidth" com
+	 "formatoptions=t" irá inserir um caractere de nova linha quando a palavra
+	 digitada ultrapassar o limite indicado.
+
+[^6] Note que o VIM define uma variável para isso, mas nada garante que o autor
+     do plugin utilizou essa tecla. Existe um padrão em usar "mapleader" como início
+	 de comando normal de um plugin, mas nada obriga o autor do plugin à usar
+	 esta tecla.
+
+[^7] E, recapitulando, para reformatar o parágrafo caso você altere alguma
+	 coisa no texto, use gq sobre a região do mesmo. O VIM irá considerar o
+	 "textwidth" na hora de reformatar.
+
+[^8] E não, não são todos os comandos que tem versões tanto em modo normal
+     o quanto em modo de comando.
+
+[^9] E porque eu usei `:tabn {número}` ao invés de `{número}gt`? Porque quando eu
+     pesquisei como pular de abas, este foi o primeiro resultado que eu encontrei.
+
+{{ chapters(prev_chapter_link="./11-config", prev_chapter_title="Arquivos de Configuração", next_chapter_link="./11-02-gvimrc", next_chapter_title="Meu .gvimrc") }}

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.
+
+<!-- more -->
+
+Na parte de configurações, eu falei de dois arquivos, "vimrc" e "gvimrc". Vocês já
+viram o que eu fiz com meu vimrc, então acho justo que vejam também o que eu
+fiz com o meu gvimrc.
+
+Para que fique claro, vimrc sempre é lido, não importa qual executável do VIM
+você está usando. gvimrc é lido depois do vimrc somente quando você iniciar um
+VIM gráfico.
+
+Como o arquivo é bem menor (já que o grosso da configuração fica no vimrc),
+este é o arquivo inteiro que eu estou usando:
+
+```viml
+set guioptions=aegit    " basically, all options, except the scrollbar, menu and toolbar
+set columns=116         " number of columns (uses most of my screen, in this case)
+set cursorline          " highlight the line with the cursor
+set colorcolumn=+2      " put a marker at textwidth + 2
+set linespace=1         " spread the lines a bit, adding a 1px line above all
+
+if has('mac')
+    set gfn=monofur:h15     " My screen size sucks, mkay?
+    set lines=63            " number of lines, based on my screen size and font
+else
+    set gfn=monofur\ for\ Powerline\ 12
+    set lines=54
+endif
+```
+
+E explicando:
+
+* `set guioptions=aegit`: Define a aparência do editor em modo gráfico. Eu
+  prefiro um editor limpo, sem menus, toolbars ou (e isso talvez soe estranho
+  para alguns), sem barra de rolagem. Em ordem, as opções ativas são:
+
+  `a`: Quando estiver fazendo a seleção com o modo visual, já copia o selecionado
+  para a área de transferência. No caso de sistemas Unix, isso significa que
+  selecionar algo com o modo visual é o mesmo que selecionar com o botão da
+  esquerda (e que pode ser colado diretamente usando o botão do meio).
+
+  `e`: Mostra abas (se estiver configurado para mostrar abas com “showtabline” --
+  que eu configurei para mostrar sempre no meu vimrc).
+
+  `g`: Mostra opções do menu desabilitadas. O normal é que opções desabilitadas
+  sequer apareçam. Esta opção só faz sentido se o menu estiver presente (com a
+  opção m no "guioptions") que, como você pode perceber, eu não estou usando.
+  Em alguns sistemas (por exemplo, OS X) o controle do menu não faz sentido
+  porque o sistema operacional sempre tem um menu ativo. Assim, quando não há
+  necessidade de menu, esta opção é desnecessária; quando não há escapatória do
+  menu, pelo menos todas as opções serão visíveis.
+
+  `i`: VIM tem um ícone (sim você pode configurar para o que o VIM não mostre um
+  ícone em lugar algum). De novo, dependendo do sistema operacional, esta opção
+  não tem efeito algum porque o próprio sistema adiciona o ícone do launcher.
+
+  `t`: Menus podem ser arrancados (quando possível). Esta é uma funcionalidade
+  que o GTK+ até a versão 2 tinha, que permitia que os menus fosse
+  "desconectados" da área de menu, o que facilita bastante na hora de
+  selecionar colorschemes (e como você pode adicionar um menu a qualquer hora
+  com `:set guioptions+=m`, o que eu normalmente faço -- ou melhor, fazia -- era
+  adicionar um grupo de novos colorschemes, ativar o menu, "arrancar" o menu de
+  colorschemes e sair selecionando opções até achar um colorscheme
+  interessante).
+
+* `set columns=116`: Número de colunas da janela do editor. Se a sua tela não
+  tiver como apresentar 116 colunas (pelo tamanho da fonte e da tela, ou por
+  alguma restrição do gerenciador de janelas), o VIM irá reduzir a quantidade
+  de colunas até que a janela caiba completamente.
+
+* `set cursorline`: A linha onde o cursor se encontra tem highlight. E, caso
+  você esteja se perguntando, existe um `set cursorcolumn` que mostra a coluna do
+  cursor. Tanto "cursorline" quanto "cursorcolumn" funcionam em console, mas a
+  forma como a linha é apresentada no meu colorscheme é... estranha.[^1]
+
+* `set colorcolumn=+2`: Define uma coluna para ser marcada com uma cor
+  diferente. Se for usado uma opção relacional (não um valor absoluto, mas algo
+  começando com "+" ou "-"), então cursorline vai usar o "textwidth" atual.
+
+* `set linespace=1`: Define um espaçamento entre linhas, em pixeis. No caso,
+  "1" significa que as linhas terão a altura requisitada pela fonte mais um
+  pixel.
+
+* `set lines=???:` Define a quantidade de linhas do editor. Segue todas as
+  considerações feitas em “columns”. Ainda, aqui eu estou usando de novo a
+  checagem de funcionalidade (`has()`) para ter configurações diferenciadas no OS
+  X e em outros sistemas operacionais.
+
+* `set gfn=???`: Define a fonte a ser usada ("gfn" é a forma curta de "guifont").
+  Note que fontes que tem espaço no meio tem que ter os espaços "escapados"
+  (com `\` antes do espaço) ou como strings. Se você quiser selecionar alguma
+  fonte mas não faz idéia do nome da fonte, use `:set gfn=*` para que o VIM
+  mostre o seletor de fontes do sistema; depois que escolher uma fonte, se
+  quiser que o VIM descreva como usar, use `:set gfn` e cole o resultado no seu
+  arquivo de configuração.
+
+[^1] E, lembrando mais uma vez: Para desligar opções deste tipo, coloque "no" na
+	 frente. Para desligar o highlight da linha atual do cursor, use `:set
+	 nocursorline`; para desligar o highlight da coluna atual do cursor, use
+	 `:set nocursorcolumn`.
+
+{{ chapters(prev_chapter_link="./11-01-vimrc", prev_chapter_title="Meu .vimrc", next_chapter_link="./12-modelines", next_chapter_title="Modelines") }}

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.
+
+<!-- more -->
+
+Bom, agora você sabe como configurar seu VIM, mudar configurações baseadas no
+tipo de arquivo... Mas o que fazer se um arquivo tem uma configuração
+completamente diferente do resto?
+
+A solução são modelines. Modelines são linhas que você pode adicionar no seu
+arquivo e o VIM, quando carregar o arquivo, irá mudar suas configurações
+baseadas nesta linha.
+
+A sintaxe da linha é, simplesmente: `vim: set {configurações}:`.
+
+"Mas é um código fonte e se eu colocar um 'vim' no meio, o compilador vai
+reclamar!", você deve estar pensando agora. Acontece que o VIM procura uma linha
+válida em qualquer lugar, desconsiderando a sintaxe atual. Se você colocar o
+modeline dentro de um comentário, o VIM ainda vai encontrar e ainda vai
+processar o modeline e ainda vai trocar as configurações do editor (apenas para
+aquele arquivo).
+
+Por exemplo, para garantir que meus templates Jinja fiquem com a sintaxe
+correta (usando a sintaxe de templates do Django), eu tenho colocado, como
+última linha do arquivo
+
+```django
+{# vim: set ft=htmldjango: #}
+```
+
+"ft", no caso, é o nome curto para "filetype", que define o tipo de arquivo que
+está sendo usando e qual sintaxe será utilizada. E o par `{#` e `#}` são
+comentários do template e completamente ignorados no resultado final.
+
+Assim como vimos antes, várias configurações podem ser usadas no mesmo set.
+Usando o exemplo acima, se eu quisesse que meus templates usassem tabulações ao
+invés de espaços para identação mas fossem apenas 2 espaços por tabulação, eu
+poderia colocar, no final do arquivo:
+
+```django
+{# vim: set ft=htmldjango noet ts=2 sts=2 sw=2: #}
+```
+
+O VIM ainda aceita que as opções sejam separadas em vários comandos, com a
+adição de ":":
+
+```django
+{# vim: set ft=htmldjango:set noet:set ts=2:set sts=2:set sw=2: #}
+```
+
+Mas realmente não faz sentido, faz?
+
+E apenas um aviso: Algumas distribuções Linux desligam modelines no arquivo
+global (adicionando `set nomodeline` no arquivo global) e, assim, modelines são
+completamente ignorados, sob a desculpa de "segurança".  Tentando descobrir o
+porque descobri o seguinte: O único comando que pode ser usado em modelines é
+"set", ou seja, não é possível colocar um modeline que abra outro arquivo, ou
+mude o diretório atual ou qualquer outra coisa; nem todas as configurações pode
+ser alteradas (infelizmente, o help do VIM não lista quais são e quais não são
+permitidas); e, aparentemente, a pior forma de "ataque" seria alguém colocar um
+"textwidth" e seu código ficar torto na primeira edição. Se você achar que
+modelines não estão sendo executados, você pode adicionar no seu vimrc `set
+modelines` para que modelines sejam processados (ou troque por uma distribuição
+que não tenha configurações que não fazem sentido).
+
+{{ chapters(prev_chapter_link="./11-02-gvimrc", prev_chapter_title="Meu .gvimrc", next_chapter_link="./13-tags", next_chapter_title="Tags") }}

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.
+
+<!-- more -->
+
+Eu expliquei antes que haviam dois comandos para utilizar tags, `[Ctrl]]` e
+`[Ctrl]t`. Existem duas coisas que eu não expliquei: O que são tags e de onde
+elas vem.
+
+Primeiro, tags são qualquer palavra que o editor encontre no arquivo de tags. E
+o arquivo de tags pode ser definido em `:set tags`. Por padrão, são verificados
+os arquivos `./tags` ("tags" no diretório atual do editor), `./TAGS`, `tags`
+(arquivo "tags" em algum diretório de pesquisa) e `TAGS`.
+
+Acontece que não é qualquer arquivo com este nome que o torna válido. Existem
+um formato específico em que as coisas devem estar declaradas para serem
+detectadas como tags. E o formato é
+
+```
+{tagname}{tagfile}{tagaddress}
+```
+
+(onde "tagname" é a tag em si, "tagfile" é o nome do arquivo onde a tag se
+encontra e "tagaddress" é uma expressão Ex para encontrar a tag -- por exemplo,
+"89" para ir para linha 89).
+
+Sim, só isso. E eu sei que manter um arquivo assim é chato horrores, e por isto
+existem ferramentas que já fazem isso. A mais completa de todas é "Exuberant
+CTags"" e pode ser encontrada em praticamente todas as distribuições Linux
+atuais, gerenciadores de pacotes do OS X e ainda vem um pacote para Windows.
+
+A grande vantagem do Exuberant é a quantidade de linguagens suportadas. Assim,
+se você estiver num projeto em Python e depois passar para um projeto em C,
+você ainda pode usar o mesmo aplicativo.
+
+A sintaxe gerado do Exuberant é "ctags {arquivos}", onde "{arquivos}" são os
+arquivos a serem processados (expressões como "\*.py" são válidas) ou, da forma
+mais simples "ctags -R", para que todos os arquivos do diretório atual e
+subdiretórios sejam processados.
+
+Uma vez que este arquivo tenha sido criado, dentro do editor você pode usar
+`[Ctrl]]` para tentar achar a definição da tag (que, com o uso do Exuberant
+significa definição de funções ou definições de variáveis) e `[Ctrl]t` para
+retornar para a localização anterior. Se houver mais de um arquivo com uma
+definição válida, o VIM irá mostrar uma lista das localizações e você poderá
+selecionar qual deve ser acessada.
+
+A única dica que sobra aqui é cuidar com arquivos minificados. Isso porque o
+Exuberant entende arquivos CSS. Não que arquivos CSS sejam um problema, mas o
+Exuberant coloca a expressão regular da linha onde a tag se encontra e, num
+arquivo minificado, a expressão acaba sendo uma linha gigantesca, que fica se
+repetindo em vários lugares do arquivo, deixando-o gigantesco. Se você tiver
+algo desse tipo, use a opção "--exclude={expressão}", onde "{expressão}" é a
+expressão regular que define o nome dos arquivos que devem ser ignorados.
+
+{{ chapters(prev_chapter_link="./12-modelines", prev_chapter_title="Modelines", next_chapter_link="./14-01-vundle", next_chapter_title="Plugins - Vundle") }}

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.
+
+<!-- more -->
+
+Vamos começar a ver como adicionar funcionalidades no VIM com plugins. E, para
+isso, vamos ver Vundle, que é um gerenciador de plugins.
+
+A pergunta que você deveria estar se fazendo agora é "E por que usar o
+Vundle?". Na verdade, esta pergunta tem duas respostas:
+
+A primeira é: Apesar de ser extremamente fácil de adicionar um plugin no VIM --
+normalmente é uma questão de descompactar um arquivo dentro do diretório
+`$HOME/.vim` -- a parte chata é manter os scripts atualizados (e ficar preso à um
+arquivo compactado) e removê-los depois, se você encher o saco de um.
+
+A segunda é: Vundle não é o único gerenciador de plugins para VIM, mas consegue
+instalar plugins por conta própria (Pathogen requer que você baixe os plugins
+manualmente, assumindo depois o controle para manter atualizado); a desvantagem
+é que Vundle requer que os scripts tenham uma determinada estrutura de arquivos
+e diretórios, mas praticamente todos os scripts hoje utilizam esta estrutura.
+
+Então vamos lá, instalar o Vundle:
+
+Primeiro, você deve baixar o plugin em si. Para isso, você tem que ter o Git
+instalado e executar:
+
+```
+git clone https://github.com/gmarik/vundle.git ~/.vim/bundle/vundle
+```
+
+Simplesmente, você está copiando o repositório do vundle para um diretório do
+próprio VIM. Até aqui nenhuma surpresa, exceto que o diretório de plugins é
+`$HOME/.vim/plugin` (ou `~/.vim/plugin`) e o clone colocou no diretório
+`~/.vim/bundle`. Ou seja, o Vundle não está ativo como um plugin do VIM (ainda).
+O Vundle faz isso de propósito, para que os scripts instalados com o Vundle não
+se misturem com os plugins instalados manualmente.
+
+A seguir, é preciso ativar o Vundle. Para isso, nós vamos adicionar o diretório
+do Vundle no path do VIM e chamar o script de inicialização. Para isto,
+adicione as seguintes linhas no seu vimrc:
+
+```vim
+set rtp+=~/.vim/bundle/vundle/
+call vundle#rc()
+```
+
+Explicando: "rtp" é a forma curta de "runtimepath", que identifica os
+diretórios onde o VIM irá procurar scripts, se preciso. No caso, estamos
+adicionando o diretório do Vundle, que clonamos anteriormente. A seguir é
+chamado o script de inicialização do Vundle.
+
+Pronto! Agora o Vundle está instalado.
+
+A questão é: E agora que o Vundle está instalado, "faz o que?"
+
+O Vundle tem mais comandos disponíveis, entre eles `:Plugin "{bundle}"`[^1]. Este
+comando adiciona um bundle/plugin/script na lista de bundles/plugins/scripts
+gerenciados pelo Vundle. A única coisa que esse comando faz é adicionar o
+bundle na lista; ele não vai instalar o bundle ainda, ele não vai remover o
+bundle, ele não vai atualizar o bundle. Apenas adicionar na lista.
+
+O parâmetro do comando, {bundle} pode ser:
+
+* O nome de um plugin conforme listado no repositórios de scripts do VIM;
+  apenas uma string (por exemplo, `:Plugin "vundle"` para instalar este script
+  (que é a descrição do Vundle nos repositórios de script);
+
+* O nome de um plugin no Github, no formato "{usuário}/{repositório}", que você
+  pode ver na parte superior de qualquer repositório (por exemplo, `:Bundle "
+  gmarik/vundle"` para instalar o Vundle a partir do repositório -- que tende a
+  ser atualizado com maior frequência);
+
+* Uma URL, que pode ser clonada com Git (por exemplo, `:Plugin
+  "https://github.com/gmarik/vundle"` para fazer o mesmo que acima.
+
+Uma vez que você tenha a lista de plugins que você quer no sistema, você pode
+instalar todos usando `:PluginInstall`; se quiser remover um plugin, você
+simplesmente o deixa fora da lista de plugins desejados e executa `:PluginClean`;
+e, para atualizar os plugins que estão instalados, `:PluginUpdate.`
+
+Acho que você já percebeu que o problema de se manter uma lista de plugins
+manualmente é meio chato: Toda vez que você quiser verificar se há atualizações
+dos plugins, você tem que entrar a lista inteira; se você esquecer de um plugin
+e fizer `:PluginClean` irá remover esse plugin. Para evitar essa complicação,
+você pode adicionar os comandos Plugin diretamente no seu vimrc[^2]. Assim, cada
+vez que você usar qualquer comando do Vundle, você não precisa se preocupar em
+lembrar de todos os plugins instalados.
+
+E, como última dica, fica o seguinte: Logo após a linha do "call vundle#rc()",
+adicione
+
+```viml
+Plugin 'gmarik/vundle'
+```
+
+.. que nada mais é que o repositório que fizemos o clone logo no começo; desta
+forma, quando você fizer um `:PluginUpdate`, o próprio Vundle poderá ser
+atualizado com a última versão disponível.
+
+[^1] Lembram que eu falei que plugins poderiam adicionar novos comandos e que
+     estes teriam pelo menos a primeira letra em maiúsculas? Pois é...
+
+[^2] Lembre-se também que o vimrc é um arquivo executado em modo Ex e o modo Ex
+     nada mais é que o modo de comando sem precisar colocar `:` na frente de cada
+     comando.
+
+{{ chapters(prev_chapter_link="./13-tags", prev_chapter_title="Tags", next_chapter_link="./14-02-airline", next_chapter_title="Plugins - Airline") }}

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.
+
+<!-- more -->
+
+Quando estávamos falando de configurações, falamos de uma configuração chamada
+“laststatus”. Esta configuração tem 3 valores possíveis:
+
+* 0 – não apresenta a barra de status, nunca.
+* 1 – apresenta a barra de status se houver pelo menos um split.
+* 2 – sempre apresenta a barra de status.
+
+E, conforme eu mostrei no meu arquivo de configuração, eu sempre deixo com 2".
+
+Acontece que a barra de status não é tããão informativa assim.
+
+![](laststatus.png)
+
+Ela tem o básico, mas o básico não é o suficiente, sejamos honestos. É possível
+adicionar mais informações setando "statusline" (que eu não vou entrar em
+detalhes aqui, mas para configurar, você tem que usar letras únicas indicado
+para cada coisa que deseja apresentar tal como se faz com "guioptions") mas,
+mesmo assim, certas coisas tem que vir de scripts externos (por exemplo, para
+mostrar o branch atual que você está) e, como eu falei, essa parte é meio
+chata.
+
+Para aliviar essa confusão, existe um plugin chamado "Vim-Airline", que tem uma
+apresentação mais complexa e oferece mais informações, baseados plugins que
+você tem instalado.
+
+Ainda, o Airline é uma versão mais leve do Powerline, que na verdade passou de
+ser um simples plugin para VIM para ser um plugin para praticamente tudo (hoje
+eu uso o Powerline para configurar meu prompt do terminal, por exemplo) e
+algumas coisas ainda são usadas do Powerline (por exemplo, as fontes, mas
+esperem aí que eu já explico o porque o Airline usa fontes especiais.)
+
+(Conforme formos passando a lista de plugins que eu tenho, vocês vão ver o
+Airline mudando de formato com o tempo.)
+
+Como falei do Vundle como gerenciador de plugins, vamos usar o mesmo para
+instalar (e manter, no futuro) o Airline.
+
+No seu vimrc, adicione o seguinte:
+
+```viml
+Plugin "bling/vim-airline"
+```
+
+E, revisando: `:Plugin` adiciona um plugin na lista de plugins gerenciados pelo
+Vundle (e apenas isso, nada mais); por ter uma barra no meio, estamos falando
+de um repositório do Github; para instalar o plugin, você precisa ou adicionar
+o plugin na lista manualmente (com o comando `:Plugin`) ou reiniciar o VIM caso
+você queria conferir se a configuração no seu vimrc está certa e fazer
+`:PluginInstall.`
+
+Se nada apareceu, é porque o seu "laststatus" não está em "2".
+
+Se tudo deu certo, você verá o seguinte:
+
+![](airline-nofonts.png)
+
+Não que tenha melhorado muito, mas agora você tem informações sobre qual o modo
+que você está atualmente (que vai mudar de cor conforme você passa para o modo
+de inserção ou visual), o nome do arquivo, o tipo de arquivo (que define qual a
+sintaxe está sendo usada), posição do cursor em relação ao todo do arquivo (em
+percentual) e a posição absoluta do mesmo (em linhas em colunas).
+
+Ok, duas coisas: Ainda não é muito melhor (embora a parte de mostrar o modo
+ajude, acredite), mas temos alguns caracteres estranhos na barra.
+
+É aí que entra a história do Powerline de novo: Os criadores do Powerline
+usaram "posições" não usadas nas fontes unicode para adicionar outros
+caracteres que são usados para melhorar a apresentação do status. Eles mantém
+[um repositório com fontes já com os caracteres especiais](https://github.com/powerline/fonts)
+e, caso a fonte que você queria não esteja na lista deles, [eles tem um script
+para "patchear" a fonte desejada](https://github.com/powerline/powerline/tree/develop/font).
+
+Uma vez que você tenha a fonte disponível no seu sistema, você deve adicionar no seu vimrc
+
+```viml
+let g:airline_powerline_fonts = 1
+```
+
+E o seu Airline, na próxima execução, deve ficar
+
+![](airline-laststatus.png)
+
+Que é mais bonito, mas ainda continua mostrando as mesmas informações. Mais pra
+frente veremos ã integração com “Fugitive” (um plugin para VIM para Git) e o
+Syntastic (para validar o código com ferramentas externas) e como ambos são
+suportados pelo Airline, você terá todas as informações ao alcance do rodapé da
+janela.
+
+![](airline-everything.png)
+
+Uma última nota: O Airline vem com suporte a temas, que você pode trocar usando
+`:AirlineTheme` (e um duplo [Tab] depois disso irá mostrar os temas instalados).
+Depois que escolher um, você pode definir
+
+```
+let g:airline_theme = '{nome do tema}'
+```
+
+no seu vimrc.
+
+{{ chapters(prev_chapter_link="./14-01-vundle", prev_chapter_title="Plugins - Vundle", next_chapter_link="./14-03-fugitive", next_chapter_title="Plugins - Fugitive") }}

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.
+
+<!-- more -->
+
+O terceiro plugin que eu vou comentar é
+[Fugitive](https://github.com/tpope/vim-fugitive), que adiciona comandos para
+gerenciar seu repositório Git dentro do VIM.
+
+Para instalar, ou você baixa a versão do Github (no link acima) ou usa o Vundle:
+
+```viml
+Plugin "tpope/vim-fugitive"
+```
+
+(E, de novo: depois de adicionar essa linha no seu vimrc, você deve sair do VIM
+-- ou, se não quiser fazer tudo isso, basta usar o comando acima em modo de
+comando -- e usar `:PluginInstall` para instalar o plugin.)
+
+A princípio, nada de diferente deve aparecer. Mas você agora pode usar qualquer
+comando do Git com `:Git {comando}`, como faria no shell.
+
+Mas só adicionar um comando não é o que o Fugitive faz. Ele também adiciona
+outros comandos:
+
+* `:Gwrite` (ou `:Gw`): salva o arquivo atual e já adiciona no index para o
+  próximo commit.
+* `:Gblame`: Faz um split da tela, mostrando do lado direito o fonte que já
+  estava aberto e do lado esquerdo, o último commit (SHA1) e o autor do commit.
+* `:Gread`: Descarta as alterações locais e recupera o arquivo atual na sua
+  última revisão dentro do repositório do Git (ou seja, revert).
+* `:Gdiff`: Mostra um diff da versão atual com a versão no repositório, com
+  splits.
+* `:Gcommit`: Faz o commit dos arquivos que estão no index.
+* `:Gstatus`: Faz um "git status", mas deixa que você altere os arquivos no
+  index (usando "-" para adicionar ou remover o arquivo -- leia o texto com
+  atenção) e faça commit dos selecionados (usando "cc") [Note que ambos os
+  comandos devem ser usados em modo normal dentro do split aberto por
+  `:Gstatus`.]
+
+Existem outros, mas você vai usar principalmente estes. E cuide para que você
+esteja dentro de um repositório Git antes de tentar usar os comandos; se o VIM
+não estiver num diretório com um repositório válido, nenhum dos comandos do
+Fugitive ficarão disponíveis[^1].
+
+E, como última dica: Se você estiver usando o Airline (comentado no capítulo
+anterior), adicione
+
+```viml
+let g:airline_enable_branch = 1
+```
+
+... no seu vimrc e o branch atual será apresentando dentro do status do
+Airline, logo após o indicador de modo.
+
+[^1] Eu só preciso adimitir que não testei para ver o que acontece se você
+	 abrir o VIM fora de um repositório e depois usar `:cd` para mudar para um
+	 diretório que tem um repositório ou tentar abrir um arquivo que está
+	 dentro de um repositório para verificar se os comandos se tornam
+	 disponíveis.
+
+{{ chapters(prev_chapter_link="./14-02-airline", prev_chapter_title="Plugins - Airline", next_chapter_link="./14-04-commentary", next_chapter_title="Plugins - Commentary") }}

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.
+
+<!-- more -->
+
+O quarto plugin da lista de plugins é
+[Commentary](https://github.com/tpope/vim-commentary).
+
+Como de costume, para instalar, você pode baixar o conteúdo do repositório
+acima para dentro do seu ~/.vim/ (o diretório, não o arquivo de inicialização)
+ou usar o Vundle:
+
+```viml
+Plugin "tpope/vim-commentary"
+```
+
+Commentary não é um plugin visual, o que significa que, mais uma vez, depois de
+instalado você não verá nada de novo.
+
+O que o Commentary faz é adicionar um atalho para comentar linhas de código,
+baseado no tipo de arquivo atual. O atalho é \\\\{movimentação} ou \\\\\\ para
+comentar a linha atual (ou você pode entrar em modo visual para selecionar as
+linhas e fazer \\\\ e a parte selecionada vai ficar comentada); para descomentar,
+basta fazer a mesma coisa (ou seja, se o pedaço selecionado não estiver
+comentado, ele será comentado; se já estiver comentado, o comentário será
+removido.)
+
+E era isso.
+
+A única ressalva aqui fica por conta de um comportamento padrão do VIM: O VIM
+tem apenas um tipo de arquivo (definido com `:set filetype={sintaxe}`) que vale
+para todo o arquivo. Assim, se você estiver usando a sintaxe de HTML,
+Commentary provavelmente não irá comentar seu código JavaScript corretamente. A
+coisa fica pior se você estiver editando um arquivo com sintaxe de template, já
+que o tipo de arquivo é o template, não HTML ou JavaScript ou CSS.
+
+Ainda, aproveitando o gancho, existem sintaxes e sintaxes. Algumas sintaxes são
+antigas e estão definidas de uma forma que o VIM perde o contexto do código
+apresentado e apresenta com a coloração errada (andar no texto em direção ao
+começo do arquivo, com [PageUp], normalmente resolve esse problema, pois o VIM
+encontra um ponto onde a sintaxe volta a fazer sentido). Por exemplo, a sintaxe
+"htmldjango", que funciona também para arquivos Jinja2 tem a leve tendência de
+se perder em arquivos muito longos; usando uma sintaxe externa para Jinja2
+(usando `:Plugin "Glench/Vim-Jinja2-Syntax"`) esse problema não acontece.
+
+Então lembre-se: Se a sintaxe "pirar", voltar um pouco para o começo do arquivo
+deve resolver (e, depois disso, o VIM carrega o contexto a medida que você for
+voltando para o ponto original) e sempre verifique se não há um arquivo de
+sintaxe que corresponda melhor às suas necessidades.
+
+{{ chapters(prev_chapter_link="./14-03-fugitive", prev_chapter_title="Plugins - Fugitive", next_chapter_link="./14-05-tabular", next_chapter_title="Plugins - Tabular") }}

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.
+
+<!-- more -->
+
+O quinto plugin da lista de plugins é
+[Tabular](https://github.com/godlygeek/tabular), um plugin para alinhar
+elementos baseados em expressões regulares (calma, não é tão complicado quando
+parece.)
+
+Mais uma vez, para instalar pelo Vundle:
+
+```viml
+Plugin "godlygeek/tabular"
+```
+
+Assim como Fugitive e Commentary, Tabular não é um plugin visual, mas adiciona
+um novo comando `:{range}Tabularize {expressão regular}`.
+
+(Apenas lembrando de {range}: são dois indicadores separados por vírgula,
+números são linhas, "$" é a última linha do arquivo, "%" é igual à "1,$" (todo o
+arquivo), "'{marcador1},'{marcador2}" vai do marcador1 até o marcador2 e, se você
+selecionar uma região no modo visual, ao pressionar `:`, o prompt deve ficar "'<
+,'>" que são os marcadores especiais de início e fim, respectivamente, da área
+visual. Todos os exemplos que eu vou mostrar daqui pra frente vão usar o
+{range} de início e fim do bloco visual, porque faz mais sentido.)
+
+A forma mais simples de usar o Tabular é passar um único caractere, que indica
+qual o ponto onde os elementos serão alinhados. Por exemplo, com o seguinte
+trecho de código:
+
+```javascript
+var pos = 1;
+var element = $(this);
+var i = 0;
+```
+
+Se você selecionar o mesmo visualmente e fizer `:'< ,'>Tabularize /=`, o resultado será:
+
+```javascript
+var pos     = 1;
+var element = $(this);
+var i       = 0;
+```
+
+Ao contrário da pesquisa (e da substituição), Tabularize aceita um segundo
+parâmetro que indica como os elementos devem ser alinhados e qual o espaçamento
+que deve existir entre os elementos. Este parâmetro pode ser até 3 pares, no
+formato {alinhamento}{espaços depois do elemento} que, apesar da minha péssima
+descrição, não é tão complicado assim.
+
+Por exemplo, imagine que eu tenho o seguinte pedaço de código em HTML:
+
+```html
+<input class='block-size disabled'
+    id='input-box'
+    name='login'
+    value=''
+    placeholder='Enter your login'>
+```
+
+No caso, eu estou quebrando cada um dos elementos para diminuir o tamanho da
+linha, já que ainda não coloquei minhas opções de templating e cada uma destas
+linhas deve ficar bem maior. Mas, como exemplo, serve.
+
+O que eu quero é que os "=" fiquem alinhados (mais ou menos o que o Xcode faz
+com código Objective-C). Assim, eu posso fazer `:'< ,'>Tabularize /=/r0c0l0` para
+obter:
+
+```html
+   <input class='block-size disabled'
+             id='input-box'
+           name='login'
+          value=''
+    placeholder='Enter your login'>
+```
+
+A explicação está no parámetro: o primeiro par, "r0" siginfica que o elemento
+antes do alinhamento deve ser alinhado à direita ("r") com 0 espaços depois do
+elemento; "c0" significa que o elemento de alinhamento (no nosso caso, "=")
+deve ser centralizado ("c") também com 0 espaços depois; e finalmente "l0"
+significa que o elemento depois do alinhamento deve ficar à esquerda ("l") e
+nenhum espaço deve ser adicionado.
+
+Se eu quisesse que o espaço não ficasse grudado tanto na esquerda quando na
+direita, eu teria que fazer `:'< ,'>Tabularize /=/r1c1l0` para obter:
+
+```html
+   <input class = 'block-size disabled'
+             id = 'input-box'
+           name = 'login'
+          value = ''
+    placeholder = 'Enter your login'>
+```
+
+{{ chapters(prev_chapter_link="./14-04-commentary", prev_chapter_title="Plugins - Commentary", next_chapter_link="./14-06-autopairs", next_chapter_title="Plugins - Auto-pairs") }}

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ê.
+
+<!-- more -->
+
+O sexto plugin da lista de plugins que eu vou falar é
+[Auto-Pairs](https://github.com/jiangmiao/auto-pairs). Como de costume, para
+instalar o plugin pelo Vundle:
+
+```viml
+Plugin "jiangmiao/auto-pairs"
+```
+
+Uma vez instalado o plugin, você verá que cada `'`, `"`, `(`, `[` e `{` irá,
+automagicamente, gerar o seu respectivo `'`, `"`, `)`, `]` e `}`. Simples assim.
+
+Entretanto, Auto-Pairs não funciona bem com o modo visual (se você já usou
+TextMate ou Sublime Text, deve ter percebido que se você usar uma das
+combinações acima com uma área selecionada, o editor vai "circular" a área
+selecionada com o par indicado). O que existe é `[Alt]e` em modo de inserção que
+faz a troca rápida entre o caractere de fechamento de pair com a próxima
+palavra.
+
+Por exemplo, se você tiver
+
+```
+''auto
+```
+
+... com o cursor posicionado entre as duas aspas e usar `[Alt]e`, você irá ficar com
+
+```
+'auto'
+```
+
+Ainda, o Auto-pairs tem um controle para "pular" sobre os caracteres de
+fechamento já existentes. Se ele adicionar um ")" (que deve ficar antes do
+cursor), quando você pressionar ")" no seu teclado, ao invés de adicionar mais
+um ")", o cursor irá pular o ")" existente.
+
+Embora isso pareça bom, em certos casos pode ser um problema. Por exemplo, caso
+você tenha o seguinte trecho de código:
+
+```javascript
+$(function () {
+  $('#button').on('click', function () {
+
+})
+```
+
+Se você tentar fechar a função interna, o Auto-Pairs irá, na verdade, saltar
+para o fechamento da função externa, efetivamente "proibindo" que você feche as
+funções corretamente. Soluções são:
+
+* Fechar a função externa de novo, forçando o que era para encerrar a função
+  externa em encerramento da função interna (depois você pode alinhar as duas
+  novamente usando o modo visual e `=` em modo normal);
+
+* Copiar e colar o fechamento da função externa;
+
+* Desligar o "salto" de elementos de fechamento com `:let g:AutoPairsFlyMode = 0`
+  (e, se você realmente preferir que o salto nunca seja feito, pode adicionar
+  esta linha no seu vimrc);
+
+* Desligar temporariamente o Auto-Pairs com `[Alt]p` em modo de inserção (usar
+  `[Alt]p` novamente irá reativar o Auto-Pairs).
+
+{{ chapters(prev_chapter_link="./14-05-tabular", prev_chapter_title="Plugins - Tabular", next_chapter_link="./14-07-syntastic", next_chapter_title="Plugins - Syntastic") }}

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.
+
+<!-- more -->
+
+O sétimo plugin discutido é o [Syntastic](https://github.com/scrooloose/syntastic).
+Para instalar com Vundle:
+
+```viml
+Plugin "scrooloose/syntastic"
+```
+
+Inicialmente, Syntastic não faz nada. O que ele faz é, depois de salvar o
+arquivo em disco, chama a função de lint para o tipo de arquivo atual e mostra
+os problemas encontrados no canto esquerdo do código; ao passar pela linha com
+problema, o erro encontrado é reportado na linha de comando.
+
+![](syntastic.png)
+
+Para ver quais são todos os erros encontrados pelo aplicativo de lint, use
+`:Errors`, que irá abrir uma janela de quickfix com a lista de erros encontrados.
+Ações de janelas e de quickfix, que já vinhamos vendo, continuam valendo. É só
+o comando para abrir o quickfix que é diferente neste caso.
+
+Você pode selecionar quais lints serão usados adicionado com `let
+g:syntastic_{linguagem}_checkers=['']` (por exemplo, para verificar arquivos Python apenas
+com PyLint, você deve usar `let g:syntastic_python_checkers=['pylint']` mas nunca
+tive problemas com os lints atuais).
+
+Uma coisa que deve ser cuidada é que o lint deve estar disponível no momento
+que o VIM abriu o arquivo, senão ele não será usado. Por exemplo, se você tiver
+pylint disponível apenas dentro de um virtualenv, chamar o VIM antes de estar
+no virtualenv fará com que Syntastic não encontre o pylint e, com isso, nenhum
+erro será reportado.
+
+Ainda, assim como aconteceu com Commentary, Syntastic usa o tipo de arquivo
+atual, não o do bloco. Por exemplo, ao editar um arquivo de template de Django,
+que tem partes na linguagem de template do Django, HTML, CSS e JavaScript,
+mesmo que você tenha os lints para HTML, CSS e JavaScript instalados, estes não
+serão executados -- porque o VIM considera o arquivo um tipo inteiro, não um
+conjunto de pequenos blocos de tipos diferentes.
+
+E, por último, Airline tem suporte para mostrar os erros encontrados pelo
+Syntastic na barra de status. Se você adicionar
+
+```viml
+let g:airline_enable_syntastic = 1
+```
+
+... no seu vimrc, o canto direito da barra de status irá mostrar a primeira
+linha com erro e a quantidade de erros encontrados.
+
+![](syntastic-airline.png)
+
+{{ chapters(prev_chapter_link="./14-06-autopairs", prev_chapter_title="Plugins - Auto-Pairs", next_chapter_link="./14-08-snipmate", next_chapter_title="Plugins - SnipMate") }}

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.
+
+<!-- more -->
+
+Para o oitavo plugin, iremos falar sobre [SnipMate](https://github.com/msanders/snipmate.vim).
+
+Como de costume, instalando pelo Vundle:
+
+```viml
+Plugin "msanders/snipmate.vim"
+```
+
+SnipMate adiciona a funcionalidade de snippets dentro do VIM. Para quem não
+sabe, snippets são trechos de código que são adicionados automaticamente (ou
+com a ação de alguma combinação de teclas) a partir de uma simples palavra.
+
+Por exemplo, um dos snippets que já estão inclusos no pacote do SnipMate, você
+pode, num arquivo JavaScript, simplesmente digitar:
+
+```javascript
+fun
+```
+
+... e, ao pressionar [Tab], o SnipMate irá adicionar, automaticamente
+
+```javascript
+function function_name (argument) {
+  // body...
+}
+```
+
+... posicionando o cursor diretamente sobre "function_name" para que você coloque
+o nome da função; pressionando [Tab] irá posicionar o cursor sobre "argument" e
+pressionando [Tab] de novo, o cursor ficará sobre "// body..." (depois disso,
+[Tab] irá funcionar como tabulação, como normalmente é).
+
+Para criar seus próprios snippets, você tem duas opções e ambas devem ficar no
+diretório $HOME/.vim/snippets:
+
+A primeira forma é através de um único arquivo, com o nome do tipo de arquivo
+em que os snippets serão válidos (que você pode ver usando `:set ft`) com a
+extensão snippets (por exemplo, para snippets para arquivos Python, você teria
+um arquivo "$HOME/.vim/snippets/python.snippets"). Neste arquivo você deve
+iniciar os snippets com a palavra snippet, seguida da palavra que será
+utilizada para identificar o snippet, seguido pelo snippet em si, com uma
+tabulação na frente (quando não houver tabulação, SnipMate considera que o
+snippet terminou). Os pontos onde você quer que o cursor pare devem ser
+identificados por "$\{\{número}:{texto\}\}" e, se ficou confuso, é porque eu estou
+usando "coisas que você substituir" com {} e o próprio SnipMate usa {} para
+blocos, mas deve ficar mais claro com este exemplo:
+
+```viml
+snippet for
+    {% for ${1:record} in ${2:list} %}
+        ${3:content}
+    {% endfor %}
+```
+
+Este snippet, para Django e Jinja, faz um loop "for". Ao digitar "for" e
+pressionar [Tab], o conteúdo será adicionado, o cursor será posicionando onde
+`${1:record}` está permitindo a alteração do mesmo, pressionando [Tab] de novo
+irá posicionar em `${2:list}` e assim por diante.
+
+E, caso você esteja se perguntando "E o que acontece se eu colocar o mesmo
+número em dois lugares diferentes?", a resposta é: lugares com o mesmo número
+são alterados ao mesmo tempo. Por exemplo, o snippet:
+
+```viml
+snippet block
+    {% block ${1:blockname} %}
+        ${2:{% content %}}
+    {% endblock $1 %}
+```
+
+... tem o número "1" duas vezes (uma depois de "block" e outra depois de
+"endblock"). Quando você colocar o nome do bloco no primeiro (do lado de
+"block"), o outro (depois de "endblock") será preenchido automaticamente.
+
+A segunda forma de adicionar snippets é através de arquivos individuais. Ao
+invés de ter um arquivo com o tipo de arquivo com todos os snippets dentro,
+você irá criar um diretório com o tipo de arquivo e cada arquivo dentro deste
+diretório deve ser "{palavra}.snippet". Assim, como no exemplo anterior tínhamos
+um arquivo "$HOME/.vim/snippets/htmldjango.snippets", poderíamos ter, na verdade,
+um diretório "$HOME/.vim/snippets/htmldjango/" e, dentro deste diretório, um
+arquivo chamando "block.snippet" com o conteúdo do snippet, sem as tabulações (já
+que agora o SnipMate sabe exatamente onde termina o snippet: no final do
+arquivo).
+
+E quando usar um ou outro? Você deve usar arquivos individuais se o SnipMate já
+tiver um arquivo de snippets para o tipo de arquivo especificado. Assim, se
+você quiser adicionar novos snippets para Python, que já tem uma série de
+snippets prontos incluídos no pacote do próprio SnipMate, você deve usar a
+segunda forma. Caso contrário, fica por preferência pessoal.
+
+E, para concluir: Ao escrever este post, descobri que existe um fork da versão
+apresentada aqui. A versão do "msanders" não é atualizada a 4 anos -- mas
+funciona perfeitamente e tenho usado sem problemas a bastante tempo. Se você
+quiser algo mais recente (por algum motivo), o fork está em
+github.com/garbas/vim-snipmate (e requer mais dependências que a versão
+original).
+
+{{ chapters(prev_chapter_link="./14-07-syntastic", prev_chapter_title="Plugins - Syntastic", next_chapter_link="./14-09-ctrlp", next_chapter_title="Plugins - CtrlP e CtrlPFunky") }}

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.
+
+<!-- more -->
+
+O nono e penúltimo plugin (na verdade os nonos e penúltimos plugins) discutido
+é o [CtrlP](https://github.com/kien/ctrlp.vim) e seu plugin (sim, um plugin do
+plugin[^1]) [CtrlPFunky](https://github.com/tacahiroy/ctrlp-funky)
+
+Para instalar os dois, com Vundle:
+
+```viml
+Plugin "kien/ctrlp.vim"
+Plugin "tacahiroy/ctrlp-funky"
+```
+
+CtrlP é um plugin que facilita encontrar e abrir arquivos, com procura fuzzy.
+E, por procura fuzzy eu quero dizer que ele encontra qualquer arquivo que tenha
+as letras digitadas na ordem que você digitou.
+
+![](ctrlp.png)
+
+Para acionar o CtrlP, você deve digitar, logicamente, `[Ctrl]p`. Ao fazer isso,
+uma janela parecida com a Quickfix irá aparecer, mostrando alguns arquivos e um
+prompt para que você digite o que quer encontrar. No exemplo acima, como que
+digitei "vim", ele encontrou todos os arquivos a partir do diretório atual que
+começavam com "v", tinham um "i" no meio e terminavam com "m" (seria
+basicamente o mesmo que pegar a lista de arquivos a partir do diretório atual e
+seus sub-diretórios e procurar pela regex "v.\*i.\*m".)
+
+Uma vez que você encontre o arquivo desejado na lista (ela não tem rolagem,
+então se você ainda não estiver vendo o arquivo, continue adicionando
+caracteres para que o arquivo desejado apareça na lista -- uma vez lá, você pode
+selecioná-lo com as setas), você pode:
+
+* Pressionar `[Enter]` para abrir o arquivo na janela atual.
+* Pressionar `[Ctrl]t` para abrir o arquivo em outra aba.
+* Pressionar `[Ctrl]s` para fazer um split horizontal e abrir o arquivo no novo
+  split.
+* Pressionar `[Ctrl]v` para fazer um split vertical e abrir o arquivo no novo
+  split.
+
+Um problema que você talvez encontre é que o CtrlP costuma listar tudo que se
+encaixar na expressão utilizada, inclusive arquivos binário, objetos
+intermediários, etc. Para remover estes arquivos da listagem, você pode usar
+`:set wildignore`, que também afeta a lista de arquivos que o VIM mostra quando
+você estiver usando os comandos normais de abertura de arquivo (`:e`, `:tabe`,
+etc).
+
+Como a configuração do wildignore é uma lista, você pode adicionar ou remover
+usando += e -=. Por exemplo, para ignorar os arquivos de objetos compilados do
+Python e o diretório que o setup.py constuma usar para construir o pacote de
+distribuição do módulo, você teria:
+
+```viml
+set wildignore+=*.pyc
+set wildignore+=*/build/*
+```
+
+ou ainda, para economizar uma linha:
+
+```viml
+set wildignore+=*.pyc,*/build/*
+```
+
+CtrlP tem um plugin, chamado CtrlPFunky. O que ele faz é basicamente o mesmo
+que o CtrlP, mas procurando funções, não arquivos.
+
+Para ativar o CtrlPFunky, você precisa primeiro adicionar o mesmo como uma
+extensão do CtrlP (e, só pra avisar, isso é específico do CtrlP, não algo que
+funciona com todo e qualquer plugin):
+
+```viml
+let g:ctrlp_extensions = ['funky'] 
+```
+
+Uma vez instalado, você pode usar `:CtrlPFunky` para mostrar a lista de funções
+no fonte (e a procura continua igual). O problema com CtrlPFunky é que, assim
+como todas as demais coisas que vínhamos vendo, ele se basea no tipo de arquivo
+atual (`:set ft`) e para arquivos em que o conteúdo e uma mistura de várias
+linguagens (p.ex., arquivo template com a linguagem de template, HTML, CSS e
+JavaScript), a listagem de funções pode não ser o que você está esperando (ou
+sequer vai funcionar).
+
+Para facilitar a sua vida, você pode fazer um mapeamento do comando para um
+atalho de teclado. Por exemplo, eu coloquei `[Ctrl]o` para chamar o CtrlPFunky
+com
+
+```viml
+nnoremap <C-O> :CtrlPFunky<CR>
+```
+
+[^1] "Plugin-ception" har har har[^2].
+
+[^2] Eu não consigo entender porque as pessoas utilizando tanto o "ception"
+	 quando encontram um meta desta jeito. Um "inception" é a inserção de uma
+	 idéia de forma que a pessoa pense que a idéia é dela, não uma
+	 "[Matrioska](http://pt.wikipedia.org/wiki/Matrioska)".
+
+{{ chapters(prev_chapter_link="./14-08-snipmate", prev_chapter_title="Plugins - SnipMate", next_chapter_link="./14-10-multiple-cursors", next_chapter_title="Plugins - Vim-Multiple-Cursors") }}

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.
+
+<!-- more -->
+
+O último plugin da lista de plugins é o [Vim-Multiple-Cursors](https://github.com/terryma/vim-multiple-cursors).
+
+Já que sempre falamos em usar Vundle...
+
+```viml
+Plugin "terryma/vim-multiple-cursors"
+```
+
+Assim como outros plugins já comentados, Vim-Multiple-Cursors não tem nenhuma
+apresentação inicial. O que este plugin faz é permitir que você tenha várias
+cursores no texto ao mesmo tempo, aplicando a mesma transformação em todos os
+lugares.
+
+A forma mais simples de usar Vim-Multiple-Cursors é ir até a palavra que você
+quer alterar e pressionar `[Ctrl]n`. Você vai notar que o VIM irá mostrar como se
+você tivesse entrado em modo visual e selecionado apenas aquela palavra, o que
+não é nada impressionante. No entanto, se você pressionar `[Ctrl]n` de novo, você
+verá que o cursor irá para a próxima ocorrência da palavra. Na verdade, o que
+você tem agora são dois cursores e tudo que você fizer em um será repetido no
+outro. Por exemplo, se você fizer ce sobre a palavra, você verá as duas
+palavras mudando ao mesmo tempo.
+
+De certa forma, o que você está fazendo é um "search and replace" só que está
+vendo exatamente o que vai ser alterado.
+
+Teoricamente, você poderia fazer `I"[Esc]ea"` para adicionar aspas ao redor da
+palavra, mas há um pequeno inconveniente: `[Esc]`, que você precisa usar para
+retornar para o modo normal depois de entrar em modo de inserção com `I` irá
+também terminar o modo de múltiplos cursores.
+
+A segunda forma de usar Vim-Multiple-Cursors é fazer uma seleção visual e usar
+`[Ctrl]n`. Para cada linha da seleção, será adicionado um novo cursor. E,
+novamente, o que você fizer em um deles será repetido em todos.
+
+Simples assim.
+
+A única coisa que eu posso deixar de aviso é que, por algum motivo, utilizando
+uma seleção visual de várias linhas (`[Shift]v`), entrando em modo de múltiplos
+cursores (`[Ctrl]n`) e usando aspas (com o Auto-Pairs), meu undo acabou sendo
+perdido (`u` removia o texto inteiro, não a alteração feita com
+Vim-Multiple-Cursors).
+
+{{ chapters(prev_chapter_link="./14-09-ctrlp", prev_chapter_title="Plugins - CtrlP e CtrlPFunky", next_chapter_link="./15-conclusao", next_chapter_title="Conclusão") }}

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.
+
+<!-- more -->
+
+Pessoalmente, a palavra que eu usaria para descrever o VIM é extensível. Não
+apenas pela quantidade de plugins criados e aperfeiçoados nestes 20 anos de
+editor (na verdade, 22 se você considerar a [primeira versão
+disponibilizada](http://en.wikipedia.org/wiki/Vim_%28text_editor%29) em 1991 ou
+25 se você considerar quando Bram Moolenaar fez a versão 1.0 para o Amiga), mas
+pela forma como os comandos foram projetados: Você sabe que uma movimentação do
+cursor com um número da frente “pula” outras ocorrências, então qualquer
+comando que você descobre como movimentação repete esse comportamento; Você
+sabe que comandos que requerem movimentação aceitam qualquer comando de
+movimentação (incluindo a quantidade, discutido antes); e assim por diante.
+Claro que isto permite várias formas diferentes de fazer a mesma coisa, mas
+isto também garante que você vai achar uma forma que se encaixe com o seu
+workflow de desenvolvimento.
+
+E não que, como eu falei lá no começo, VIM seja o editor perfeito para todas as
+condições: Existem coisas novas surgindo a todo momento (por exemplo, a idéia
+de múltiplos cursores só foi popularizado quando o TextMate foi lançado no OS
+X) e que o editor base não consegue fazer -- mas como o editor é extensível em
+várias formas, alguém já fez um plugin para repetir o comportamento no editor.
+Existem arquivos de sintaxe que são terríveis, e mesmo assim fazem parte do
+pacote original -- e existem formas de atualizar por versões melhores. Existem
+plugins que baseiam-se unicamente no tipo de arquivo inteiro e não no bloco --
+mas não há nada que não garanta que, no futuro, alguém consiga fazer um plugin
+que troque automaticamente de modo baseado no contexto atual.
+
+Na contrapartida, existem certas coisas que o VIM consegue fazer que outros
+editores não fazem: Pular para o ponto onde o texto foi inserido da última vez
+é o que sempre me faz voltar a usar o VIM e que eu sinto uma tremenda falta nos
+outros editores -- que, diga-se de passagem, é fácil do editor controlar pela
+existência dos modos.
+
+E, como dicas de despedida: Quando alguém comentar sobre uma feature em outro
+editor, lembre-se de procurar por "vim {feature}" na internet; muito
+provavelmente a feature já existe em alguma forma para o VIM ou já tem alguém
+tentando escrever um plugin para fazer a mesma coisa. E lembre-se sempre que
+`:wq` só funciona no VIM, não nos demais editores ou no seu emulador de
+terminal[^1].
+
+[^1] Você pode perguntar para qualquer usuário de longa data quantas vezes eles
+	 tentaram fechar o terminal ou mesmo um editor de textos como Word ou
+	 LibreOffice com `:wq` e a resposta provavelmente vai ser "mais vezes que eu
+	 posso lembrar".
+
+{{ chapters(prev_chapter_link="./14-10-multiple-cursors", prev_chapter_title="Plugins - Vim-Multiple-Cursors") }}

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)

themes/nighttime

@@ -1 +1 @@
-Subproject commit 85d3db539b3e72076e4a9352ca890920996dc44e
+Subproject commit c9a6aff5b4b60f19a2b784a830d5c2eba81a20fb