diff --git a/content/books/uma-licao-de-vim/05-marcadores/index.md b/content/books/uma-licao-de-vim/05-marcadores/index.md index 104ece4..c06bcbb 100644 --- a/content/books/uma-licao-de-vim/05-marcadores/index.md +++ b/content/books/uma-licao-de-vim/05-marcadores/index.md @@ -69,4 +69,4 @@ 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="./04-registradores", next_chapter_title="Registradores") }} +{{ chapters(prev_chapter_link="./04-registradores", prev_chapter_title="Registradores", next_chapter_link="./06-macros-de-teclado", next_chapter_title="Macros de Teclado") }} diff --git a/content/books/uma-licao-de-vim/06-marcros-de-teclado/index.md b/content/books/uma-licao-de-vim/06-marcros-de-teclado/index.md new file mode 100644 index 0000000..49f4164 --- /dev/null +++ b/content/books/uma-licao-de-vim/06-marcros-de-teclado/index.md @@ -0,0 +1,60 @@ ++++ +title = "Macros de Teclado" +date = 2015-12-22 ++++ + +Essa é a parte em que você repete várias coisas sem repetir várias coisas. + + + +No capítulo #3, eu falei rapidamente do commando `.`, que repete o último comando +completo. Mas como repetir comandos que são, na verdade, uma composição de +vários outros comandos? + +A resposta são macros de teclado. + +Macros de teclado permitem que você grave uma execução qualquer e depois a +repita quantas vezes quiser. + +Para fazer uma macro de teclado, você deve, em modo normal, executar +`q{registrador}`. Ao fazer isso, a última linha do VIM irá mostrar "recording", +indicando que o editor está agora gravandos todas as teclas pressionadas no +registrador. Para encerrar a gravação pressione `q` novamente (desta vez, sem o +registrador). Para "tocar" a macro, é necessário usar `@{registrador}`. + +Quem prestou atenção no capítulo #5, deve ter notado que eu usei a palavra +"registrador" de novo. E a base da questão é que realmente os dois são a mesma +coisa: Se você copiar algo para o registrador `a` (`"ayy`, por exemplo) e depois +gravar a macro "a", o conteúdo copiado para a área de transferência será perdido. +Em compensação, se você criar a macro no registrador "a", você pode ver +exatamente a sequência de comandos usados usando `"ap`. Ou ainda, você pode +colocar a sequência de comandos desejada num arquivo (ou no próprio arquivo), +copiar para o registrador necessário e depois só "tocar" o registrador. + +Como exemplo, imagine que você tem uma lista de constantes que você quer +transformar em uma lista de strings. No caso, você teria que adicionar uma aspa +no começo, uma aspa no final, uma vírgula e passar para a próxima linha. Se +forem apenas 4 constantes, é fácil repetir os comandos em cada linha; mas se +forem 100, a coisa fica diferente. + +Neste caso, você faria o seguinte: Na primeira linha, executaria +`qaI"[Esc]A",[Esc]jq` -- ou seja, iniciaria a macro "a", entraria em modo de +inserção no primeiro caractere não branco da linha (`I`), colocaria uma aspa, +sairia do modo de inserção, entraria novamente no modo de inserção mas desta +vez movendo o cursor para o último caractere antes (`A`), adicionaria a aspa que +encerra a string e uma vírgula, moveria para a linha de baixo e encerraria a +macro de teclado. Até aqui espero que não tenha nada de surpresas. Agora você +pode repetir `@a` 99 vezes para as próximas linhas ou simplesmente executar `99@a` +e deixar o VIM repetir a macro 99 vezes. No final, bastaria simplesmente +remover a última vírgula. + +Uma coisa a ter em mente -- além da questão do registrador -- é que o VIM +encerra tanto a macro quanto o número de repetições se houver qualquer +problema. Por exemplo, se no meio da sua macro você colocar um `f.` para mover +o cursor para o próximo ponto, mas no meio da execução não for encontrado +nenhum ponto, a macro será interrompida e qualquer execução posterior será +encerrada, não importando se for a 99a execução da macro ou a +1a. Se você perceber que a execução não terminou onde deveria, +basta executar `u` em modo de comando para desfazer a execução da macro. + +{{ chapters(prev_chapter_link="./05-marcadores", prev_chapter_title="Marcadores", next_chapter_link="./07-procurar-varios-arquivos", next_chapter_title="Procurar em Vários Arquivos") }} diff --git a/content/books/uma-licao-de-vim/07-procurar-varios-arquivos/index.md b/content/books/uma-licao-de-vim/07-procurar-varios-arquivos/index.md new file mode 100644 index 0000000..89ec6fe --- /dev/null +++ b/content/books/uma-licao-de-vim/07-procurar-varios-arquivos/index.md @@ -0,0 +1,70 @@ ++++ +title = "Procurar em Vários Arquivos" +date = 2015-12-22 ++++ + +Essa é a parte em que mais uma vez você vai ter que pesquisar sobre +expressões regulares. + + + +Já vimos o comando de pesquisa, que tem um modo inteiro só pra si[^1]. + +Mas como fazer para encontrar ocorrências de uma palavra em mais de um arquivo? +Para isto, existe o comando `:grep`. + +O grep é uma ferramente comum em Unixes (e Linux) em geral, mas o VIM tem +scripts que fazem a mesma coisa em outros sistemas operacionais (por exemplo, +Windows). Assim, o mesmo comando vai funcionar da mesma forma não importando +qual sistema você esteja utilizando. + +Como o `:grep` usa outras funcionalidades existentes no VIM, iremos ver um pouco +mais do que simplesmente "Procurar", mas isso é necessário. + +Como o modo de pesquisa, `:grep` precisa de uma expressão regular. Ao contrário +do modo de pesquisa, o `:grep` também precisa de uma lista de arquivos a serem +pesquisados. Por baixo dos panos, o que o VIM faz é chamar o comando "grep" (do +Unix), verifica o resultado e permite pular facilmente entre os elementos +encontrados (então todas as opções disponíveis para o grep podem ser passadas +diretamente de dentro do VIM). + +Por exemplo, para pesquisar por arquivos que contém a palavra "void", você só +precisa executar o comando `:grep void *` (onde `:grep` é o comando, `void` é a +expressão a ser pesquisada e `*` é a lista de arquivos a serem pesquisados). Como +o grep (o aplicativo do Unix) somente pesquisa arquivos no diretório +especificado (no nosso caso anterior, como não foi passado diretório algum, +será considerado o diretório atual), o `:grep` (o comando do VIM) também não vai +entrar em nenhum subdiretório (de novo, porque o VIM simplesmente chama o grep +[aplicativo do Unix] e facilita pular entre os elementos encontrados). Para +fazer uma procura que encontre a expressão além do diretório atual, basta +adicionar a opção "-r" para o grep (`:grep void -r *`). + +Ok, agora que você sabe usar o `:grep`... Como é que você vê os resultados? + +Primeira informação periférica: O VIM tem um tipo de "janela" especial, chamada +"Quickfix". Essa "janela" é, na verdade, um "split" da tela (e mais a frente +veremos como trabalhar com "splits" e abas). Para exibir o Quickfix, é usado o +comando `:copen`; para fechar o Quickfix, basta usar `:copen` de novo. Para +passar para o próximo elemento existente no Quickfix, use `:cnext` (ou +simplesmente `:cn`); para passar para o elemento anterior, use `:cprevious` (ou +simplesmente `:cp`); para mover o cursor para a posição do elemento atual do +Quickfix, use `:cc` (que é simplesmente `:cc` mesmo). + +A segunda informação periférica: Como eu falei, usar `:grep {expressão} *` irá +procurar "{expressão}" a partir do diretório atual. Para descobrir qual é o +"diretório atual" para o VIM, use `:pwd` (de "print working directory", que +também é um comando Unix); para mudar para outro diretório, utilize o comando +`:cd {diretório}`, como você faria num shell normal. + +(E antes que alguém pergunte: Sim, você pode fazer um grep fora do diretório +atual passando o diretório em questão no próprio comando do grep: `:grep void +/tmp -r` irá procurar por "void" em todos os arquivos existentes no diretório +/tmp.) + +[^1] Apenas para lembrar, `/` entra no modo de pesquisa, onde só é preciso entrar + a expressão regular a ser encontrada; para passar para a próxima + ocorrência, use `n` em modo normal; para passar para a ocorrência anterior, + use `N` também em modo normal; para remover o realce das palavras + encontradas, use `:noh` em modo de comando. + +{{ chapters(prev_chapter_link="./06-macros-de-teclado", prev_chapter_title="Macros de Teclado", next_chapter_link="./07-procurar-varios-arquivos", next_chapter_title="Procurar em Vários Arquivos") }} diff --git a/content/books/uma-licao-de-vim/08-localizar-substituir/index.md b/content/books/uma-licao-de-vim/08-localizar-substituir/index.md new file mode 100644 index 0000000..c8c556e --- /dev/null +++ b/content/books/uma-licao-de-vim/08-localizar-substituir/index.md @@ -0,0 +1,87 @@ ++++ +title = "Localizar e Substituir" +date = 2015-12-22 ++++ + +Essa é a parte em que você vai precisar aprender expressões regulares — mais +uma vez. + + + +Uma coisa relativamente comum quando se está programando é substituir todas as +ocorrências de uma palavra por outra[^1]. + +Para fazer "localizar e substituir" ("search and replace") existe o comando +`:substitute` em modo de comando (ou simplesmente `:s`). + +Até aí sem problemas, mas existe uma pequena pegadinha (na verdade, duas, mas +uma de cada vez): `:s` é, na verdade, `:{range}s`, onde "{range}" é a parte do +texto que o comando `:s` deve ser executado -- e sim, eu sei que não falei +sobre este tipo de comando antes, mas essa era a melhor oportunidade. + +Então, {range}. {range} é opcional e, se não for passado, o comando será +executado da linha atual. Isto, obviamente, não é muito útil. {range} é formado +por um par[^2], separado por vírgulas, indicando o início e o fim da execução do +comando. + +O uso básico de {range} é "linha inicial,linha final". Por exemplo, `:1,5s` irá +executar o comando `:s` entre as linhas 1 (a primeira, não existe linha 0 no +VIM) e 5. + +E, mais uma vez, existem indicadores especiais, inclusive para {range}. + +Um número indica o número da linha, como já comentei. "$" é a última linha do +arquivo (assim, `:1,$s` irá executar `:s` em todo o arquivo); "%" é um alias +para "1,$" (ou seja, todo o arquivo); `'{marcador}` irá, obviamente, utilizar +os marcadores (ou seja, `:'a,'bs` irá executar `:s` entre o marcador "a" e o +marcador "b" -- E marcadores entre arquivos [em maiúsculas] não são +permitidos). + +(E existe outros dois marcadores especiais que eu não comentei antes por achar +que não há uso fora do `:s` que são `'<` e `'>` que indicam, respectivamente, o +início e o fim da região visual -- mas o VIM vai adicionar estes dois +marcadores automaticamente se você tiver uma região visual selecionada e +pressionar `:` e por isso ficaram pra trás. Então não se assuste se o VIM +começar a colocar coisas na linha de comando sem que você tenha digitado.) + +Daqui pra frente, eu vou colocar o comando como `:%s`, já que esta é a execução +mais comum do comando. Mas lembre-se que `%` = `1,$` = do começo ao fim. + +`:%s` funciona, assim como a pesquisa, com expressões regulares, só que ao invés +de termos uma expressão, teremos duas: a de pesquisa e a de substituição. Em +casos mais simples, onde você quer substituir "palavra 1" por "palavra 2", o +comando será `:%s/palavra 1/palavra 2`. Mais uma vez, conhecer expressões +regulares vai ajudar aqui -- e fica a dica para olhar sobre "grupos". + +A segunda pegadinha é que `:%s` executa o comando em cada linha do range e, como +padrão, somente a primeira ocorrência é substituída. Assim, se "palavra 1" +existir mais de uma vez em uma linha, somente a primeira será alterada. + +Para resolver isso, você deve usar o terceiro parâmetro de `:%s`, {flags}. As +flags mais comuns são: + +
+
g
+
Substitui todas as ocorrências da expressão de procura na linha, não apenas + a primeira.
+
i
+
Ignora maiúsculas e minúsculas ("ignore case")
+
c
+
Pede confirmação em cada alteração.
+
+ +Concluindo: para substituir "void" por "int\*" em todo o arquivo mas apenas no +começo da linha, ignorando se está em maiúsculas ou minúsculas (porque o +estagiário pensou que estava digitando uma monografia), mas confirmando cada +mudança, você faria `:%s/^void/int*/ic` (como é apenas no começo da linha e nós +forçamos isso na expressão regular -- o `^` ali -- não precisamos usar a flag "g", +já que não teria efeito nenhum). + +[^1] E, mas pra frente, veremos que existem plugins que deixam esta parte mais + fácil. + +[^2] Na verdade, não e um par mas, de novo, fazer substituição em apenas uma + linha não é muito útil, principalmente considerando os comandos que o VIM + tem para movimentação do cursor. + +{{ chapters(prev_chapter_link="./07-procurar-varios-arquivos", prev_chapter_title="Macros de Teclado", next_chapter_link="./09-splits", next_chapter_title="Splits") }} diff --git a/content/books/uma-licao-de-vim/09-splits/all.png b/content/books/uma-licao-de-vim/09-splits/all.png new file mode 100644 index 0000000..e96f78d Binary files /dev/null and b/content/books/uma-licao-de-vim/09-splits/all.png differ diff --git a/content/books/uma-licao-de-vim/09-splits/horizontal-split.png b/content/books/uma-licao-de-vim/09-splits/horizontal-split.png new file mode 100644 index 0000000..4f417c7 Binary files /dev/null and b/content/books/uma-licao-de-vim/09-splits/horizontal-split.png differ diff --git a/content/books/uma-licao-de-vim/09-splits/index.md b/content/books/uma-licao-de-vim/09-splits/index.md new file mode 100644 index 0000000..0dbdf9e --- /dev/null +++ b/content/books/uma-licao-de-vim/09-splits/index.md @@ -0,0 +1,114 @@ ++++ +title = "Splits" +date = 2015-12-22 ++++ + +Essa é a parte em que você vai passar uma hora dividindo a tela em pedacinhos +cada vez mais pequenos. + + + +Até agora, enquanto falávamos de editar textos no VIM, vimos apenas como editar +um arquivo por vez. Existem formas de editar mais de um arquivo (usando `:e` e +`:e#{número}`) mas estas estão longe de serem fáceis de serem utilizadas. + +Existem duas formas de manter dois (ou mais) arquivos abertos ao mesmo tempo. +Uma delas são "splits". Basicamente, splits permitem que você "reparta" a tela +em pedaços, podendo mostrar outros arquivos (ou até mesmo outra vez o mesmo +arquivo). + +Para criar splits, existem dois comandos que devem ser usados em modo de +comando: `:sp` e `:vsp`. Ambos comandos aceitam o nome do arquivo a ser aberto no +novo split; se não for passado o nome de um arquivo, o arquivo que já está +aberto será carregado. + +A diferença entre eles é que `:sp` irá criar um split horizontal... + +![](horizontal-split.png) + +... enquanto que `:vsp` irá criar um split vertical. + +![](vertical-split.png) + +Dentro de cada split, comandos executados irão afetar apenas o buffer atual: `:w` +irá salvar apenas o arquivo apresentar no split atual, `:e` irá abrir um arquivo +no split atual e assim por diante. + +Note que eu falei "buffer atual". Como falei antes, "buffer" é o nome dado para +a representação do arquivo em memória e que tanto `:sp` quanto `:vsp` sem +parâmetros irão abrir um split com o arquivo atual -- que, na verdade, é o +buffer atual. Se você fizer isso e começar a editar o texto em um dos splits, o +conteúdo do outro também irá mudar, já que ambos estão apresentando o mesmo +buffer. + +Para fechar um split, basta fechar o arquivo, tanto com `:q` quanto `:wq` ou +qualquer outro comando que feche um arquivo. O split será removido e o cursor +irá para o próximo split. Se não houverem mais splits, o VIM irá fechar, como +já vinhamos vendo desde o começo. + +E sim, você pode fazer quantos splits e de formas diversas quantas vezes quiser +(até que não sobre mais espaço na tela, quer dizer). + +![](all.png) + +Para "manusear" splits, você irá utilizar comandos que começam com, em modo +normal, `[Ctrl]w`. `[Ctrl]w`, por si só, não faz nada (a não ser que você +repita o comando, mas isso é outra coisa) e requer uma ação a ser executada no +split (assim como alguns comandos requerem uma movimentação). + +## [Ctrl]wj ou [Ctrl]w[direcional para baixo] + +Move o cursor para o split abaixo do atual. Se não houverem outros splits +abaixo do atual, permanece no mesmo. Aceita um número de repetiçoes, ou seja, +`3[Ctrl]wj` irá imediatamente pular para o 3o. split abaixo do atual. + +## [Ctrl]wh ou [Ctrl]w[direcional para a esquerda] e [Ctrl]wk ou [Ctrl]w[direcional para cima] e [Ctrl]wl ou [Ctrl]w[direcional para a direita] + +O mesmo que [Ctrl]wj, mas indo para o split da esquerda, acima ou direita, +respectivamente. + +## [Ctrl]w+ e [Cltr]w- + +Aumenta ou diminui o tamanho do split em uma linha. Se for passado um número +antes do comando -- por exemplo `3[Ctrl]w+` -- o número de linhas afetas será o +número indicado. + +## [Ctrl]w> e [Ctrl]w< + +O mesmo que `[Ctrl]w+` e `[Ctrl]w-`, mas altera o número de colunas ao invés do número de linhas. + +## [Ctrl]w\_ e [Ctrl]w| + +Deixa o split com o maior altura possível (ou seja, coloca o máximo de linhas +possíveis para o split) ou com a maior largura possível (ou seja, coloca o +máximo de colunas possíveis para o split). + +## [Ctrl]w= + +Altera o tamanho dos splits para que estes fiquem o mais equilibrados +possíveis. + +## [Ctrl]wH, [Ctrl]wJ, [Ctrl]wK,/tt> e [Ctrl]wL + +Move o split atual para o canto mais a esquerda, abaixo, acima ou direita, +respectivamente (note que a letra de movimentação está em maiúsculas). + +## [Ctrl]ww + +Move o cursor para o split anterior. Se você está em um split qualquer e fizer +`3[Ctrl]wj` para ir para o 3o split abaixo do atual, `[Ctrl]ww` irá +mover o cursor de volta para o split original (e `[Ctrl]ww` irá mover o cursor +de volta para o 3o split abaixo do atual). + +## [Ctrl]wf + +Abre o arquivo com o nome sob o cursor em um novo split. + +Quando falei do grep, eu comentei que existe o comando `:cope` para abrir a +janela do Quickfix. Bom, se você quiser ficar pulando entre a janela do +Quickfix e o texto, os comandos `[Ctrl]w` acima irão ajudar. + +Existem ainda alguns outros comandos para splits, mas veremos estes mais a +frente. + +{{ chapters(prev_chapter_link="./08-localizar-substituir", prev_chapter_title="Localizar e Substituir", next_chapter_link="./10-abas", next_chapter_title="Abas") }} diff --git a/content/books/uma-licao-de-vim/09-splits/vertical-split.png b/content/books/uma-licao-de-vim/09-splits/vertical-split.png new file mode 100644 index 0000000..ca26dba Binary files /dev/null and b/content/books/uma-licao-de-vim/09-splits/vertical-split.png differ diff --git a/content/books/uma-licao-de-vim/10-abas/index.md b/content/books/uma-licao-de-vim/10-abas/index.md new file mode 100644 index 0000000..db26f91 --- /dev/null +++ b/content/books/uma-licao-de-vim/10-abas/index.md @@ -0,0 +1,44 @@ ++++ +title = "Abas" +date = 2015-12-22 ++++ + +Essa é a parte me que você acha coisas que já fazia antes. + + + +Além dos splits, que vimos no capítulo anterior, VIM também tem suporte à abas. +O mais interessante é que você pode usar abas tanto no VIM gráfico (também +chamado de GVim) quanto no console. + +Para abrir um arquivo no VIM, sabemos que temos que usar o comando `:e`; para +abrir o arquivo em uma aba, o comando é `:tabe`. + +Ao contrário de splits, criar uma nova aba sem passar um arquivo não cria uma +nova aba com o buffer atual; `:tabe` sem um nome de arquivo irá criar uma nova +aba com um buffer em branco. E sim, você pode abrir o mesmo arquivo em mais de +uma aba e as alterações feitas em uma irão refletir na outra. + +Para pular entre abas, você poder usar o comando `gt` em modo normal ou `:tabn` em +modo de comando. Se você usar um número de repetições (p.ex. `3gt` ou `:tabn 3`) o +VIM irá pular diretamente para aquela aba (no caso, para a terceira), não +importando a aba atual. `gT` em modo normal ou `:tabp` move o cursor para a aba +anterior. + +Se quiser mover abas de posição, você deve usar `:tabm`. `:tabm` irá mover a aba +atual para ficar depois da aba indicada (p.ex., `:tabm 3` irá mover a aba atual +para depois da terceira aba). `:tabm` também aceita parâmetros considerando a aba +atual: `:tabm +2` irá mover a aba atual duas abas pra frente (para a direita) e +`:tabm -2` irá mover a aba duas abas pra trás (para a esquerda). + +Atalhos padrão para mover para a próxima aba do sistema operacional também são +aceitos por padrão. `[Ctrl][PageDn]` e `[Ctrl][PageUp]` no Linux e +`[Command][Shift]]` e `[Command][Shift][` no OS X, por exemplo. Como não existe +nenhum padrão para consoles, não há nenhum atalho padrão e devem ser usados os +comandos de seleção de abas que vimos antes. + +Mais pra frente, quando estivermos falando do arquivo de configuração, eu vou +explicar um "truque" para pular diretamente para a aba desejada, assim como +funciona no Firefox e no Chrome. + +{{ chapters(prev_chapter_link="./09-splits", prev_chapter_title="Splits", next_chapter_link="./11-config", next_chapter_title="Arquivos de Configuração") }} diff --git a/content/books/uma-licao-de-vim/11-config/index.md b/content/books/uma-licao-de-vim/11-config/index.md new file mode 100644 index 0000000..505f140 --- /dev/null +++ b/content/books/uma-licao-de-vim/11-config/index.md @@ -0,0 +1,162 @@ ++++ +title = "Arquivos de Configuração" +date = 2015-12-22 ++++ + +Essa é a parte em que eu menti. + + + +Lembram que bem no começo, quando estávamos falando dos modos de execução, eu +comentei que o modo Ex não era usado? + +Bom, eu menti. MUAHAHAHAHA! + +![](muahaha.jpg) + +Na verdade, o Modo Ex não é chamado comumente, mas os arquivos de configuração +do VIM são um grande amontoado de comandos executando em modo Ex. + +E o que é o modo Ex, afinal de contas? O modo Ex nada mais é que o modo de +comando sem a necessidade de usar `:` na frente de todos os comandos. Como +ficaria complicado para, por exemplo, entrar no modo Ex, executar e arquivo, +sair do modo ex e entrar em modo de inserção, até o momento temos usado o modo +de comando para isso, já que economiza um monte de tecladas. Como não iremos +ficar indo para o modo de inserção o tempo todo, e não faz sentido fazer um +arquivo gigantesco com várias linhas começando com `:`, também faz sentido que o +arquivo de configuração seja executado em modo Ex. + +O VIM tem um arquivo de configuração global (conhecido com "vimrc") e um arquivo +para execução em modo gráfico ("gvimrc")[^1]. Ainda, existem duas versões de cada +um destes arquivos: uma versão global para todos os usuários e uma versão +definida para o usuário atual. Daqui pra frente, iremos ver as configurações do +usuário, já que estas sobrepõem as globais. + +"vimrc" e "gvimrc" ficam no diretório dos dados do usuário; em qualquer um dos +sistemas operacionais hoje, você consegue descobrir o diretório destes arquivos +com `:echo $HOME` dentro do próprio VIM. Apenas note que embora eu venho chamando +os arquivos de vimrc e gvimrc, os nomes são, na verdade, ".vimrc" e ".gvimrc" (ou +"\_vimrc" e "\_gvimrc" no caso do Windows). + +Como existem muitas opções, não vou aqui explicar cada uma delas -- mas, no +próximo capítulo eu vou mostrar o arquivo que eu estou usando para servir de +guia. + +O que você vai ver quando abrir um arquivo de configuração: + +## set + +`set` é, efetivamente, a forma de "setar" alguma configuração no VIM. + +Existem dois tipos de configurações: As com valores e flags. + +Flags é mais fácil de ser explicado: você simplesmente seta a configuração. Por +exemplo, fazer com que o VIM mostre uma coluna com o número de cada linha, +você pode usar `:set number` (ou simplesmente `set number` dentro do arquivo de +configuração). Para desligar uma opção deste tipo, você só precisa adicionar +"no" na frente (para desligar number é usado `:set nonumber`). + +"Valores" é exatamente o que significa: Ao invés de ser uma simples flag, a +opção recebe uma string ou número. Por exemplo, `:set tabstop=4` irá definir que +o tamanho da tabulação é de 4 espaços. `:set notabstop` não tem efeito aqui, já +que não é uma flag. + +Para fazer com que uma configuração volte ao seu valor/estado original, use +`:set {opção}&`; para verificar o valor de uma opção, use `:set {opção}?`. + +Talvez a coisa não esteja muito clara aqui, mas quando examinarmos um arquivo +de configuração real, as coisas irão clarear. + +## let + +`let` é usado para definir o valor de uma variável. Uma variável tem sempre um +valor -- ou seja, não existem "variáveis flags". Variáveis são normalmente +utilizadas por plugins ou arquivos de sintaxe e, portanto, as variáveis que +você terá que usar vão depender do que você está usando. + +(Obviamente, se você estiver escrevendo seu próprio plugin — que eu não vou +abordar aqui — o uso de variáveis vai ser praticamente obrigatório.) + +## if + +`if`, como em qualquer linguagem de programação, serve para execução +condicional. Você pode, por exemplo, verificar se alguma feature foi ativada na +compilação do binário, se alguma opção está ligada, etc. + +Por exemplo, para verificar se o suporte à scripts Python foi adicionado, você +pode fazer: + +```viml +if has('python') + " configuração em python vai aqui +end +``` + +Para verificar se alguma opção está ativa: + +```viml +if &compatible + " configuração em modo de compatibilidade com o VI original +end +``` + +ou para conferir um valor: + +```viml +if &t_Co > 2 + " configuração quando há suporte a mais de 2 cores. +end +``` + +E assim por diante. + +## map, imap (e outros) + +`map` pode ser usado para mapear teclas para outras funções. Por exemplo `:map Y +y$` irá mapear "Y" para executar `y$` (copiar da posição atual do cursor até o fim +da linha). Com excessão de [Shift], qualquer modificador pode ser usado: + +* C - para `[Control]` +* M - para `[Alt]` (que normalmente é chamado de "Meta" em sistemas Unix — e por isso "M") +* O - para `[Command]` (somente em Macs) + +Por exemplo, `:map C-m yy` irá adicionar `[Ctrl]m` para copiar a linha inteira. + +Ainda, a diferença entre `map` e `imap` é que `map` é global enquanto que +`imap` só irá funcionar em modo de inserção (e assim você pode imaginar o que +`nmap` e `vmap` fazem, certo?) + +## au (ou autocmd) + +Comandos que são executados em determinadas condições. Condições podem desde +"FileType" para ações confirme o tipo de arquivo e "BufRead", "BufWrite" e +relacionados quando um buffer for aberto ou fechado. + +O que seriam os "relacionados"? Bom, alem de ser na leitura/escrita do arquivo, +podem ser adicionados comandos antes da execução ("BufReadPre", "BufWritePre"), +depois da execução ("BufReadPost", "BufWritePost") e durante ("BufReadCmd", +"BufWriteCmd"). + +(Existem ainda auto-comandos para quando o editor entrar em modo de edição, +abrir o VIM gráfico, VIM está fechando, e assim por diante. Para ver todos os +eventos, digite `:help autocmd-events`.) + +Por exemplo, `au FileType smarty set ai` para ligar a auto-identação quando VIM +detectar que você está editando um arquivo Smarty (engine de templates para +PHP). Ou ainda `au BufRead set nocompatible` irá configurar o editor para entrar +em modo de não-compatibilidade com VI depois de abrir qualquer arquivo. + +Ainda, é possível encadear auto-comandos, por exemplo, `autocmd FileType python +autocmd BufWritePre :%s/\s\+$//e` irá fazer com que quando o tipo de arquivo for +"python", seja criado um auto-comando que antes de salvar o arquivo, seja +executado um comando de substituição no buffer -- que remove espaços em branco +no final da linha). + +(Se você está perdido com o que está vendo aqui, não se preocupe -- a tendência +é que, ao ver um arquivo de configuração real, você entenda o que está +acontecendo). + +[^1] Existe um terceiro, .exrc, mas honestamente, em todo esse tempo usando o + VIM, eu nunca tinha ouvido falar que este arquivo sequer existia. + +{{ chapters(prev_chapter_link="./10-abas", prev_chapter_title="Abas", next_chapter_link="./11-config", next_chapter_title="Arquivos de Configuração") }} diff --git a/content/books/uma-licao-de-vim/11-config/muahaha.jpg b/content/books/uma-licao-de-vim/11-config/muahaha.jpg new file mode 100644 index 0000000..1621b2c Binary files /dev/null and b/content/books/uma-licao-de-vim/11-config/muahaha.jpg differ diff --git a/content/books/uma-licao-de-vim/_index.md b/content/books/uma-licao-de-vim/_index.md index 398edd3..d64b4c6 100644 --- a/content/books/uma-licao-de-vim/_index.md +++ b/content/books/uma-licao-de-vim/_index.md @@ -1,4 +1,38 @@ +++ -transparent = true +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](121.md) + * [Meu .gvimrc](122.md) +* [Modelines](13.md) +* [Tags](14.md) +* [Plugins - Vundle](1501.md) +* [Plugins - Airline](1502.md) +* [Plugins - Fugitive](1503.md) +* [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)