Browse Source

And that is it

master
Julio Biason 6 years ago
parent
commit
1aff578669
  1. 2
      content/books/uma-licao-de-vim/14.03-fugitive/index.md
  2. 56
      content/books/uma-licao-de-vim/14.04-commentary/index.md
  3. 100
      content/books/uma-licao-de-vim/14.05-tabular/index.md
  4. 72
      content/books/uma-licao-de-vim/14.06-autopairs/index.md
  5. 60
      content/books/uma-licao-de-vim/14.07-syntastic/index.md
  6. BIN
      content/books/uma-licao-de-vim/14.07-syntastic/syntastic-airline.png
  7. BIN
      content/books/uma-licao-de-vim/14.07-syntastic/syntastic.png
  8. 107
      content/books/uma-licao-de-vim/14.08-snipmate/index.md
  9. BIN
      content/books/uma-licao-de-vim/14.09-ctrlp/ctrlp.png
  10. 105
      content/books/uma-licao-de-vim/14.09-ctrlp/index.md
  11. 52
      content/books/uma-licao-de-vim/14.10-multiple-cursors/index.md
  12. 53
      content/books/uma-licao-de-vim/15-conclusao/index.md
  13. 16
      content/books/uma-licao-de-vim/_index.md

2
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") }}

56
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") }}

100
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") }}

72
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") }}

60
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") }}

BIN
content/books/uma-licao-de-vim/14.07-syntastic/syntastic-airline.png

Binary file not shown.

After

Width:  |  Height:  |  Size: 13 KiB

BIN
content/books/uma-licao-de-vim/14.07-syntastic/syntastic.png

Binary file not shown.

After

Width:  |  Height:  |  Size: 5.4 KiB

107
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") }}

BIN
content/books/uma-licao-de-vim/14.09-ctrlp/ctrlp.png

Binary file not shown.

After

Width:  |  Height:  |  Size: 40 KiB

105
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") }}

52
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") }}

53
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") }}

16
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 - Tabular](1505.md)
* [Plugins - Auto-pairs](1506.md)
* [Plugins - Syntastic](1507.md)
* [Plugins - Snipmate](1508.md)
* [Plugins - CtrlP e CtrlPFunky](1509.md)
* [Plugins - Vim-Multiple-Cursors](1510.md)
* [Conclusão](16.md)
* [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)

Loading…
Cancel
Save