diff --git a/content/books/uma-licao-de-vim/14.03-fugitive/index.md b/content/books/uma-licao-de-vim/14.03-fugitive/index.md index 8be586c..bf9cc2c 100644 --- a/content/books/uma-licao-de-vim/14.03-fugitive/index.md +++ b/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") }} diff --git a/content/books/uma-licao-de-vim/14.04-commentary/index.md b/content/books/uma-licao-de-vim/14.04-commentary/index.md new file mode 100644 index 0000000..7aa8687 --- /dev/null +++ b/content/books/uma-licao-de-vim/14.04-commentary/index.md @@ -0,0 +1,56 @@ ++++ +title = "Plugins - Commentary" +date = 2015-12-22 ++++ + +Essa é a parte em que automatizamos a técnica de sumir código sem sumir com o +código. + + + +O quarto plugin da lista de plugins é +[Commentary](https://github.com/tpope/vim-commentary). + +Como de costume, para instalar, você pode baixar o conteúdo do repositório +acima para dentro do seu ~/.vim/ (o diretório, não o arquivo de inicialização) +ou usar o Vundle: + +```viml +Plugin "tpope/vim-commentary" +``` + +Commentary não é um plugin visual, o que significa que, mais uma vez, depois de +instalado você não verá nada de novo. + +O que o Commentary faz é adicionar um atalho para comentar linhas de código, +baseado no tipo de arquivo atual. O atalho é \\\\{movimentação} ou \\\\\\ para +comentar a linha atual (ou você pode entrar em modo visual para selecionar as +linhas e fazer \\\\ e a parte selecionada vai ficar comentada); para descomentar, +basta fazer a mesma coisa (ou seja, se o pedaço selecionado não estiver +comentado, ele será comentado; se já estiver comentado, o comentário será +removido.) + +E era isso. + +A única ressalva aqui fica por conta de um comportamento padrão do VIM: O VIM +tem apenas um tipo de arquivo (definido com `:set filetype={sintaxe}`) que vale +para todo o arquivo. Assim, se você estiver usando a sintaxe de HTML, +Commentary provavelmente não irá comentar seu código JavaScript corretamente. A +coisa fica pior se você estiver editando um arquivo com sintaxe de template, já +que o tipo de arquivo é o template, não HTML ou JavaScript ou CSS. + +Ainda, aproveitando o gancho, existem sintaxes e sintaxes. Algumas sintaxes são +antigas e estão definidas de uma forma que o VIM perde o contexto do código +apresentado e apresenta com a coloração errada (andar no texto em direção ao +começo do arquivo, com [PageUp], normalmente resolve esse problema, pois o VIM +encontra um ponto onde a sintaxe volta a fazer sentido). Por exemplo, a sintaxe +"htmldjango", que funciona também para arquivos Jinja2 tem a leve tendência de +se perder em arquivos muito longos; usando uma sintaxe externa para Jinja2 +(usando `:Plugin "Glench/Vim-Jinja2-Syntax"`) esse problema não acontece. + +Então lembre-se: Se a sintaxe "pirar", voltar um pouco para o começo do arquivo +deve resolver (e, depois disso, o VIM carrega o contexto a medida que você for +voltando para o ponto original) e sempre verifique se não há um arquivo de +sintaxe que corresponda melhor às suas necessidades. + +{{ chapters(prev_chapter_link="./14-03-fugitive", prev_chapter_title="Plugins - Fugitive", next_chapter_link="./14-05-tabular", next_chapter_title="Plugins - Tabular") }} diff --git a/content/books/uma-licao-de-vim/14.05-tabular/index.md b/content/books/uma-licao-de-vim/14.05-tabular/index.md new file mode 100644 index 0000000..4339718 --- /dev/null +++ b/content/books/uma-licao-de-vim/14.05-tabular/index.md @@ -0,0 +1,100 @@ ++++ +title = "Plugins - Tabular" +date = 2015-12-22 ++++ + +Essa é a parte em que deixamos as coisas alinhadas. + + + +O quinto plugin da lista de plugins é +[Tabular](https://github.com/godlygeek/tabular), um plugin para alinhar +elementos baseados em expressões regulares (calma, não é tão complicado quando +parece.) + +Mais uma vez, para instalar pelo Vundle: + +```viml +Plugin "godlygeek/tabular" +``` + +Assim como Fugitive e Commentary, Tabular não é um plugin visual, mas adiciona +um novo comando `:{range}Tabularize {expressão regular}`. + +(Apenas lembrando de {range}: são dois indicadores separados por vírgula, +números são linhas, "$" é a última linha do arquivo, "%" é igual à "1,$" (todo o +arquivo), "'{marcador1},'{marcador2}" vai do marcador1 até o marcador2 e, se você +selecionar uma região no modo visual, ao pressionar `:`, o prompt deve ficar "'< +,'>" que são os marcadores especiais de início e fim, respectivamente, da área +visual. Todos os exemplos que eu vou mostrar daqui pra frente vão usar o +{range} de início e fim do bloco visual, porque faz mais sentido.) + +A forma mais simples de usar o Tabular é passar um único caractere, que indica +qual o ponto onde os elementos serão alinhados. Por exemplo, com o seguinte +trecho de código: + +```javascript +var pos = 1; +var element = $(this); +var i = 0; +``` + +Se você selecionar o mesmo visualmente e fizer `:'< ,'>Tabularize /=`, o resultado será: + +```javascript +var pos = 1; +var element = $(this); +var i = 0; +``` + +Ao contrário da pesquisa (e da substituição), Tabularize aceita um segundo +parâmetro que indica como os elementos devem ser alinhados e qual o espaçamento +que deve existir entre os elementos. Este parâmetro pode ser até 3 pares, no +formato {alinhamento}{espaços depois do elemento} que, apesar da minha péssima +descrição, não é tão complicado assim. + +Por exemplo, imagine que eu tenho o seguinte pedaço de código em HTML: + +```html + +``` + +No caso, eu estou quebrando cada um dos elementos para diminuir o tamanho da +linha, já que ainda não coloquei minhas opções de templating e cada uma destas +linhas deve ficar bem maior. Mas, como exemplo, serve. + +O que eu quero é que os "=" fiquem alinhados (mais ou menos o que o Xcode faz +com código Objective-C). Assim, eu posso fazer `:'< ,'>Tabularize /=/r0c0l0` para +obter: + +```html + +``` + +A explicação está no parámetro: o primeiro par, "r0" siginfica que o elemento +antes do alinhamento deve ser alinhado à direita ("r") com 0 espaços depois do +elemento; "c0" significa que o elemento de alinhamento (no nosso caso, "=") +deve ser centralizado ("c") também com 0 espaços depois; e finalmente "l0" +significa que o elemento depois do alinhamento deve ficar à esquerda ("l") e +nenhum espaço deve ser adicionado. + +Se eu quisesse que o espaço não ficasse grudado tanto na esquerda quando na +direita, eu teria que fazer `:'< ,'>Tabularize /=/r1c1l0` para obter: + +```html + +``` + +{{ chapters(prev_chapter_link="./14-04-commentary", prev_chapter_title="Plugins - Commentary", next_chapter_link="./14-06-autopairs", next_chapter_title="Plugins - Auto-pairs") }} diff --git a/content/books/uma-licao-de-vim/14.06-autopairs/index.md b/content/books/uma-licao-de-vim/14.06-autopairs/index.md new file mode 100644 index 0000000..0a0a903 --- /dev/null +++ b/content/books/uma-licao-de-vim/14.06-autopairs/index.md @@ -0,0 +1,72 @@ ++++ +title = "Plugins - Auto-Pairs" +date = 2015-12-22 ++++ + +Essa é a parte em que o VIM fecha as coisas pra você. + + + +O sexto plugin da lista de plugins que eu vou falar é +[Auto-Pairs](https://github.com/jiangmiao/auto-pairs). Como de costume, para +instalar o plugin pelo Vundle: + +```viml +Plugin "jiangmiao/auto-pairs" +``` + +Uma vez instalado o plugin, você verá que cada `'`, `"`, `(`, `[` e `{` irá, +automagicamente, gerar o seu respectivo `'`, `"`, `)`, `]` e `}`. Simples assim. + +Entretanto, Auto-Pairs não funciona bem com o modo visual (se você já usou +TextMate ou Sublime Text, deve ter percebido que se você usar uma das +combinações acima com uma área selecionada, o editor vai "circular" a área +selecionada com o par indicado). O que existe é `[Alt]e` em modo de inserção que +faz a troca rápida entre o caractere de fechamento de pair com a próxima +palavra. + +Por exemplo, se você tiver + +``` +''auto +``` + +... com o cursor posicionado entre as duas aspas e usar `[Alt]e`, você irá ficar com + +``` +'auto' +``` + +Ainda, o Auto-pairs tem um controle para "pular" sobre os caracteres de +fechamento já existentes. Se ele adicionar um ")" (que deve ficar antes do +cursor), quando você pressionar ")" no seu teclado, ao invés de adicionar mais +um ")", o cursor irá pular o ")" existente. + +Embora isso pareça bom, em certos casos pode ser um problema. Por exemplo, caso +você tenha o seguinte trecho de código: + +```javascript +$(function () { + $('#button').on('click', function () { + +}) +``` + +Se você tentar fechar a função interna, o Auto-Pairs irá, na verdade, saltar +para o fechamento da função externa, efetivamente "proibindo" que você feche as +funções corretamente. Soluções são: + +* Fechar a função externa de novo, forçando o que era para encerrar a função + externa em encerramento da função interna (depois você pode alinhar as duas + novamente usando o modo visual e `=` em modo normal); + +* Copiar e colar o fechamento da função externa; + +* Desligar o "salto" de elementos de fechamento com `:let g:AutoPairsFlyMode = 0` + (e, se você realmente preferir que o salto nunca seja feito, pode adicionar + esta linha no seu vimrc); + +* Desligar temporariamente o Auto-Pairs com `[Alt]p` em modo de inserção (usar + `[Alt]p` novamente irá reativar o Auto-Pairs). + +{{ chapters(prev_chapter_link="./14-05-tabular", prev_chapter_title="Plugins - Tabular", next_chapter_link="./14-07-syntastic", next_chapter_title="Plugins - Syntastic") }} diff --git a/content/books/uma-licao-de-vim/14.07-syntastic/index.md b/content/books/uma-licao-de-vim/14.07-syntastic/index.md new file mode 100644 index 0000000..a10fe5e --- /dev/null +++ b/content/books/uma-licao-de-vim/14.07-syntastic/index.md @@ -0,0 +1,60 @@ ++++ +title = "Plugins - Syntastic" +date = 2015-12-22 ++++ + +Essa é a parte que o VIM ajuda você a achar o que tem de errado no seu +código. + + + +O sétimo plugin discutido é o [Syntastic](https://github.com/scrooloose/syntastic). +Para instalar com Vundle: + +```viml +Plugin "scrooloose/syntastic" +``` + +Inicialmente, Syntastic não faz nada. O que ele faz é, depois de salvar o +arquivo em disco, chama a função de lint para o tipo de arquivo atual e mostra +os problemas encontrados no canto esquerdo do código; ao passar pela linha com +problema, o erro encontrado é reportado na linha de comando. + +![](syntastic.png) + +Para ver quais são todos os erros encontrados pelo aplicativo de lint, use +`:Errors`, que irá abrir uma janela de quickfix com a lista de erros encontrados. +Ações de janelas e de quickfix, que já vinhamos vendo, continuam valendo. É só +o comando para abrir o quickfix que é diferente neste caso. + +Você pode selecionar quais lints serão usados adicionado com `let +g:syntastic_{linguagem}_checkers=['']` (por exemplo, para verificar arquivos Python apenas +com PyLint, você deve usar `let g:syntastic_python_checkers=['pylint']` mas nunca +tive problemas com os lints atuais). + +Uma coisa que deve ser cuidada é que o lint deve estar disponível no momento +que o VIM abriu o arquivo, senão ele não será usado. Por exemplo, se você tiver +pylint disponível apenas dentro de um virtualenv, chamar o VIM antes de estar +no virtualenv fará com que Syntastic não encontre o pylint e, com isso, nenhum +erro será reportado. + +Ainda, assim como aconteceu com Commentary, Syntastic usa o tipo de arquivo +atual, não o do bloco. Por exemplo, ao editar um arquivo de template de Django, +que tem partes na linguagem de template do Django, HTML, CSS e JavaScript, +mesmo que você tenha os lints para HTML, CSS e JavaScript instalados, estes não +serão executados -- porque o VIM considera o arquivo um tipo inteiro, não um +conjunto de pequenos blocos de tipos diferentes. + +E, por último, Airline tem suporte para mostrar os erros encontrados pelo +Syntastic na barra de status. Se você adicionar + +```viml +let g:airline_enable_syntastic = 1 +``` + +... no seu vimrc, o canto direito da barra de status irá mostrar a primeira +linha com erro e a quantidade de erros encontrados. + +![](syntastic-airline.png) + +{{ chapters(prev_chapter_link="./14-06-autopairs", prev_chapter_title="Plugins - Auto-Pairs", next_chapter_link="./14-08-snipmate", next_chapter_title="Plugins - SnipMate") }} diff --git a/content/books/uma-licao-de-vim/14.07-syntastic/syntastic-airline.png b/content/books/uma-licao-de-vim/14.07-syntastic/syntastic-airline.png new file mode 100644 index 0000000..5c0a280 Binary files /dev/null and b/content/books/uma-licao-de-vim/14.07-syntastic/syntastic-airline.png differ diff --git a/content/books/uma-licao-de-vim/14.07-syntastic/syntastic.png b/content/books/uma-licao-de-vim/14.07-syntastic/syntastic.png new file mode 100644 index 0000000..d985ae0 Binary files /dev/null and b/content/books/uma-licao-de-vim/14.07-syntastic/syntastic.png differ diff --git a/content/books/uma-licao-de-vim/14.08-snipmate/index.md b/content/books/uma-licao-de-vim/14.08-snipmate/index.md new file mode 100644 index 0000000..64c15fa --- /dev/null +++ b/content/books/uma-licao-de-vim/14.08-snipmate/index.md @@ -0,0 +1,107 @@ ++++ +title = "Plugins - Snipmate" +date = 2015-12-22 ++++ + +Essa é a parte que automatizamos a digitação de coisas repetidas. + + + +Para o oitavo plugin, iremos falar sobre [SnipMate](https://github.com/msanders/snipmate.vim). + +Como de costume, instalando pelo Vundle: + +```viml +Plugin "msanders/snipmate.vim" +``` + +SnipMate adiciona a funcionalidade de snippets dentro do VIM. Para quem não +sabe, snippets são trechos de código que são adicionados automaticamente (ou +com a ação de alguma combinação de teclas) a partir de uma simples palavra. + +Por exemplo, um dos snippets que já estão inclusos no pacote do SnipMate, você +pode, num arquivo JavaScript, simplesmente digitar: + +```javascript +fun +``` + +... e, ao pressionar [Tab], o SnipMate irá adicionar, automaticamente + +```javascript +function function_name (argument) { + // body... +} +``` + +... posicionando o cursor diretamente sobre "function_name" para que você coloque +o nome da função; pressionando [Tab] irá posicionar o cursor sobre "argument" e +pressionando [Tab] de novo, o cursor ficará sobre "// body..." (depois disso, +[Tab] irá funcionar como tabulação, como normalmente é). + +Para criar seus próprios snippets, você tem duas opções e ambas devem ficar no +diretório $HOME/.vim/snippets: + +A primeira forma é através de um único arquivo, com o nome do tipo de arquivo +em que os snippets serão válidos (que você pode ver usando `:set ft`) com a +extensão snippets (por exemplo, para snippets para arquivos Python, você teria +um arquivo "$HOME/.vim/snippets/python.snippets"). Neste arquivo você deve +iniciar os snippets com a palavra snippet, seguida da palavra que será +utilizada para identificar o snippet, seguido pelo snippet em si, com uma +tabulação na frente (quando não houver tabulação, SnipMate considera que o +snippet terminou). Os pontos onde você quer que o cursor pare devem ser +identificados por "$\{\{número}:{texto\}\}" e, se ficou confuso, é porque eu estou +usando "coisas que você substituir" com {} e o próprio SnipMate usa {} para +blocos, mas deve ficar mais claro com este exemplo: + +```viml +snippet for + {% for ${1:record} in ${2:list} %} + ${3:content} + {% endfor %} +``` + +Este snippet, para Django e Jinja, faz um loop "for". Ao digitar "for" e +pressionar [Tab], o conteúdo será adicionado, o cursor será posicionando onde +`${1:record}` está permitindo a alteração do mesmo, pressionando [Tab] de novo +irá posicionar em `${2:list}` e assim por diante. + +E, caso você esteja se perguntando "E o que acontece se eu colocar o mesmo +número em dois lugares diferentes?", a resposta é: lugares com o mesmo número +são alterados ao mesmo tempo. Por exemplo, o snippet: + +```viml +snippet block + {% block ${1:blockname} %} + ${2:{% content %}} + {% endblock $1 %} +``` + +... tem o número "1" duas vezes (uma depois de "block" e outra depois de +"endblock"). Quando você colocar o nome do bloco no primeiro (do lado de +"block"), o outro (depois de "endblock") será preenchido automaticamente. + +A segunda forma de adicionar snippets é através de arquivos individuais. Ao +invés de ter um arquivo com o tipo de arquivo com todos os snippets dentro, +você irá criar um diretório com o tipo de arquivo e cada arquivo dentro deste +diretório deve ser "{palavra}.snippet". Assim, como no exemplo anterior tínhamos +um arquivo "$HOME/.vim/snippets/htmldjango.snippets", poderíamos ter, na verdade, +um diretório "$HOME/.vim/snippets/htmldjango/" e, dentro deste diretório, um +arquivo chamando "block.snippet" com o conteúdo do snippet, sem as tabulações (já +que agora o SnipMate sabe exatamente onde termina o snippet: no final do +arquivo). + +E quando usar um ou outro? Você deve usar arquivos individuais se o SnipMate já +tiver um arquivo de snippets para o tipo de arquivo especificado. Assim, se +você quiser adicionar novos snippets para Python, que já tem uma série de +snippets prontos incluídos no pacote do próprio SnipMate, você deve usar a +segunda forma. Caso contrário, fica por preferência pessoal. + +E, para concluir: Ao escrever este post, descobri que existe um fork da versão +apresentada aqui. A versão do "msanders" não é atualizada a 4 anos -- mas +funciona perfeitamente e tenho usado sem problemas a bastante tempo. Se você +quiser algo mais recente (por algum motivo), o fork está em +github.com/garbas/vim-snipmate (e requer mais dependências que a versão +original). + +{{ chapters(prev_chapter_link="./14-07-syntastic", prev_chapter_title="Plugins - Syntastic", next_chapter_link="./14-09-ctrlp", next_chapter_title="Plugins - CtrlP e CtrlPFunky") }} diff --git a/content/books/uma-licao-de-vim/14.09-ctrlp/ctrlp.png b/content/books/uma-licao-de-vim/14.09-ctrlp/ctrlp.png new file mode 100644 index 0000000..ac3c4c7 Binary files /dev/null and b/content/books/uma-licao-de-vim/14.09-ctrlp/ctrlp.png differ diff --git a/content/books/uma-licao-de-vim/14.09-ctrlp/index.md b/content/books/uma-licao-de-vim/14.09-ctrlp/index.md new file mode 100644 index 0000000..36bb049 --- /dev/null +++ b/content/books/uma-licao-de-vim/14.09-ctrlp/index.md @@ -0,0 +1,105 @@ ++++ +title = "Plugins - CtrlP and CtrlPFunky" +date = 2015-12-22 ++++ + +Essa é a parte em que você vai ter a impressão de estar programando em Perl, +porque qualquer caractere é válido. + + + +O nono e penúltimo plugin (na verdade os nonos e penúltimos plugins) discutido +é o [CtrlP](https://github.com/kien/ctrlp.vim) e seu plugin (sim, um plugin do +plugin[^1]) [CtrlPFunky](https://github.com/tacahiroy/ctrlp-funky) + +Para instalar os dois, com Vundle: + +```viml +Plugin "kien/ctrlp.vim" +Plugin "tacahiroy/ctrlp-funky" +``` + +CtrlP é um plugin que facilita encontrar e abrir arquivos, com procura fuzzy. +E, por procura fuzzy eu quero dizer que ele encontra qualquer arquivo que tenha +as letras digitadas na ordem que você digitou. + +![](ctrlp.png) + +Para acionar o CtrlP, você deve digitar, logicamente, `[Ctrl]p`. Ao fazer isso, +uma janela parecida com a Quickfix irá aparecer, mostrando alguns arquivos e um +prompt para que você digite o que quer encontrar. No exemplo acima, como que +digitei "vim", ele encontrou todos os arquivos a partir do diretório atual que +começavam com "v", tinham um "i" no meio e terminavam com "m" (seria +basicamente o mesmo que pegar a lista de arquivos a partir do diretório atual e +seus sub-diretórios e procurar pela regex "v.\*i.\*m".) + +Uma vez que você encontre o arquivo desejado na lista (ela não tem rolagem, +então se você ainda não estiver vendo o arquivo, continue adicionando +caracteres para que o arquivo desejado apareça na lista -- uma vez lá, você pode +selecioná-lo com as setas), você pode: + +* Pressionar `[Enter]` para abrir o arquivo na janela atual. +* Pressionar `[Ctrl]t` para abrir o arquivo em outra aba. +* Pressionar `[Ctrl]s` para fazer um split horizontal e abrir o arquivo no novo + split. +* Pressionar `[Ctrl]v` para fazer um split vertical e abrir o arquivo no novo + split. + +Um problema que você talvez encontre é que o CtrlP costuma listar tudo que se +encaixar na expressão utilizada, inclusive arquivos binário, objetos +intermediários, etc. Para remover estes arquivos da listagem, você pode usar +`:set wildignore`, que também afeta a lista de arquivos que o VIM mostra quando +você estiver usando os comandos normais de abertura de arquivo (`:e`, `:tabe`, +etc). + +Como a configuração do wildignore é uma lista, você pode adicionar ou remover +usando += e -=. Por exemplo, para ignorar os arquivos de objetos compilados do +Python e o diretório que o setup.py constuma usar para construir o pacote de +distribuição do módulo, você teria: + +```viml +set wildignore+=*.pyc +set wildignore+=*/build/* +``` + +ou ainda, para economizar uma linha: + +```viml +set wildignore+=*.pyc,*/build/* +``` + +CtrlP tem um plugin, chamado CtrlPFunky. O que ele faz é basicamente o mesmo +que o CtrlP, mas procurando funções, não arquivos. + +Para ativar o CtrlPFunky, você precisa primeiro adicionar o mesmo como uma +extensão do CtrlP (e, só pra avisar, isso é específico do CtrlP, não algo que +funciona com todo e qualquer plugin): + +```viml +let g:ctrlp_extensions = ['funky'] +``` + +Uma vez instalado, você pode usar `:CtrlPFunky` para mostrar a lista de funções +no fonte (e a procura continua igual). O problema com CtrlPFunky é que, assim +como todas as demais coisas que vínhamos vendo, ele se basea no tipo de arquivo +atual (`:set ft`) e para arquivos em que o conteúdo e uma mistura de várias +linguagens (p.ex., arquivo template com a linguagem de template, HTML, CSS e +JavaScript), a listagem de funções pode não ser o que você está esperando (ou +sequer vai funcionar). + +Para facilitar a sua vida, você pode fazer um mapeamento do comando para um +atalho de teclado. Por exemplo, eu coloquei `[Ctrl]o` para chamar o CtrlPFunky +com + +```viml +nnoremap :CtrlPFunky +``` + +[^1] "Plugin-ception" har har har[^2]. + +[^2] Eu não consigo entender porque as pessoas utilizando tanto o "ception" + quando encontram um meta desta jeito. Um "inception" é a inserção de uma + idéia de forma que a pessoa pense que a idéia é dela, não uma + "[Matrioska](http://pt.wikipedia.org/wiki/Matrioska)". + +{{ chapters(prev_chapter_link="./14-08-snipmate", prev_chapter_title="Plugins - SnipMate", next_chapter_link="./14-10-multiple-cursors", next_chapter_title="Plugins - Vim-Multiple-Cursors") }} diff --git a/content/books/uma-licao-de-vim/14.10-multiple-cursors/index.md b/content/books/uma-licao-de-vim/14.10-multiple-cursors/index.md new file mode 100644 index 0000000..5aa7f98 --- /dev/null +++ b/content/books/uma-licao-de-vim/14.10-multiple-cursors/index.md @@ -0,0 +1,52 @@ ++++ +title = "Plugins - Vim-Multiple-Cursors" +date = 2015-12-22 ++++ + +Essa é a parte em que você pode repetir várias coisas, visualmente. + + + +O último plugin da lista de plugins é o [Vim-Multiple-Cursors](https://github.com/terryma/vim-multiple-cursors). + +Já que sempre falamos em usar Vundle... + +```viml +Plugin "terryma/vim-multiple-cursors" +``` + +Assim como outros plugins já comentados, Vim-Multiple-Cursors não tem nenhuma +apresentação inicial. O que este plugin faz é permitir que você tenha várias +cursores no texto ao mesmo tempo, aplicando a mesma transformação em todos os +lugares. + +A forma mais simples de usar Vim-Multiple-Cursors é ir até a palavra que você +quer alterar e pressionar `[Ctrl]n`. Você vai notar que o VIM irá mostrar como se +você tivesse entrado em modo visual e selecionado apenas aquela palavra, o que +não é nada impressionante. No entanto, se você pressionar `[Ctrl]n` de novo, você +verá que o cursor irá para a próxima ocorrência da palavra. Na verdade, o que +você tem agora são dois cursores e tudo que você fizer em um será repetido no +outro. Por exemplo, se você fizer ce sobre a palavra, você verá as duas +palavras mudando ao mesmo tempo. + +De certa forma, o que você está fazendo é um "search and replace" só que está +vendo exatamente o que vai ser alterado. + +Teoricamente, você poderia fazer `I"[Esc]ea"` para adicionar aspas ao redor da +palavra, mas há um pequeno inconveniente: `[Esc]`, que você precisa usar para +retornar para o modo normal depois de entrar em modo de inserção com `I` irá +também terminar o modo de múltiplos cursores. + +A segunda forma de usar Vim-Multiple-Cursors é fazer uma seleção visual e usar +`[Ctrl]n`. Para cada linha da seleção, será adicionado um novo cursor. E, +novamente, o que você fizer em um deles será repetido em todos. + +Simples assim. + +A única coisa que eu posso deixar de aviso é que, por algum motivo, utilizando +uma seleção visual de várias linhas (`[Shift]v`), entrando em modo de múltiplos +cursores (`[Ctrl]n`) e usando aspas (com o Auto-Pairs), meu undo acabou sendo +perdido (`u` removia o texto inteiro, não a alteração feita com +Vim-Multiple-Cursors). + +{{ chapters(prev_chapter_link="./14-09-ctrlp", prev_chapter_title="Plugins - CtrlP e CtrlPFunky", next_chapter_link="./15-conclusao", next_chapter_title="Conclusão") }} diff --git a/content/books/uma-licao-de-vim/15-conclusao/index.md b/content/books/uma-licao-de-vim/15-conclusao/index.md new file mode 100644 index 0000000..bce12b1 --- /dev/null +++ b/content/books/uma-licao-de-vim/15-conclusao/index.md @@ -0,0 +1,53 @@ ++++ +title = "Plugins - Vim-Multiple-Cursors" +date = 2015-12-22 ++++ + +Essa é a parte em que nos despedimos. + + + +Pessoalmente, a palavra que eu usaria para descrever o VIM é extensível. Não +apenas pela quantidade de plugins criados e aperfeiçoados nestes 20 anos de +editor (na verdade, 22 se você considerar a [primeira versão +disponibilizada](http://en.wikipedia.org/wiki/Vim_%28text_editor%29) em 1991 ou +25 se você considerar quando Bram Moolenaar fez a versão 1.0 para o Amiga), mas +pela forma como os comandos foram projetados: Você sabe que uma movimentação do +cursor com um número da frente “pula” outras ocorrências, então qualquer +comando que você descobre como movimentação repete esse comportamento; Você +sabe que comandos que requerem movimentação aceitam qualquer comando de +movimentação (incluindo a quantidade, discutido antes); e assim por diante. +Claro que isto permite várias formas diferentes de fazer a mesma coisa, mas +isto também garante que você vai achar uma forma que se encaixe com o seu +workflow de desenvolvimento. + +E não que, como eu falei lá no começo, VIM seja o editor perfeito para todas as +condições: Existem coisas novas surgindo a todo momento (por exemplo, a idéia +de múltiplos cursores só foi popularizado quando o TextMate foi lançado no OS +X) e que o editor base não consegue fazer -- mas como o editor é extensível em +várias formas, alguém já fez um plugin para repetir o comportamento no editor. +Existem arquivos de sintaxe que são terríveis, e mesmo assim fazem parte do +pacote original -- e existem formas de atualizar por versões melhores. Existem +plugins que baseiam-se unicamente no tipo de arquivo inteiro e não no bloco -- +mas não há nada que não garanta que, no futuro, alguém consiga fazer um plugin +que troque automaticamente de modo baseado no contexto atual. + +Na contrapartida, existem certas coisas que o VIM consegue fazer que outros +editores não fazem: Pular para o ponto onde o texto foi inserido da última vez +é o que sempre me faz voltar a usar o VIM e que eu sinto uma tremenda falta nos +outros editores -- que, diga-se de passagem, é fácil do editor controlar pela +existência dos modos. + +E, como dicas de despedida: Quando alguém comentar sobre uma feature em outro +editor, lembre-se de procurar por "vim {feature}" na internet; muito +provavelmente a feature já existe em alguma forma para o VIM ou já tem alguém +tentando escrever um plugin para fazer a mesma coisa. E lembre-se sempre que +`:wq` só funciona no VIM, não nos demais editores ou no seu emulador de +terminal[^1]. + +[^1] Você pode perguntar para qualquer usuário de longa data quantas vezes eles + tentaram fechar o terminal ou mesmo um editor de textos como Word ou + LibreOffice com `:wq` e a resposta provavelmente vai ser "mais vezes que eu + posso lembrar". + +{{ chapters(prev_chapter_link="./14-10-multiple-cursors", prev_chapter_title="Plugins - Vim-Multiple-Cursors") }} diff --git a/content/books/uma-licao-de-vim/_index.md b/content/books/uma-licao-de-vim/_index.md index 877d7e7..087e5dd 100644 --- a/content/books/uma-licao-de-vim/_index.md +++ b/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)