And that is it

content/books/uma-licao-de-vim/14.03-fugitive/index.md

@@ -63,4 +63,4 @@ Airline, logo após o indicador de modo.
 	 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="./11-config", next_chapter_title="Arquivos de Configuração") }}
+{{ 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

@@ -28,11 +28,11 @@ template = "section-contentless.html"
 * [Plugins - Vundle](14-01-vundle)
 * [Plugins - Airline](14-02-airline)
 * [Plugins - Fugitive](14-03-fugitive)
-* [Plugins - Commentary](1504.md)
+* [Plugins - Commentary](14-04-commentary)
-* [Plugins - Tabular](1505.md)
+* [Plugins - Tabular](14-05-tabular)
-* [Plugins - Auto-pairs](1506.md)
+* [Plugins - Auto-pairs](14-06-autopairs)
-* [Plugins - Syntastic](1507.md)
+* [Plugins - Syntastic](14-07-syntastic)
-* [Plugins - Snipmate](1508.md)
+* [Plugins - Snipmate](14-08-snipmate)
-* [Plugins - CtrlP e CtrlPFunky](1509.md)
+* [Plugins - CtrlP e CtrlPFunky](14-09-ctrlp)
-* [Plugins - Vim-Multiple-Cursors](1510.md)
+* [Plugins - Vim-Multiple-Cursors](14-10-multiple-cursors)
-* [Conclusão](16.md)
+* [Conclusão](15-conclusao)