Desfazendo no VIm

O que fazemos quando erramos, desfazemos o erro. Para isso serve a ferramenta undo, tão popular nos mais diversos tipos de editores. Hoje veremos o que o Vim nos oferece para desfazer e refazer a edições.

Desfazendo e refazendo

Desfazer uma ação é extremamente simples, mas pode haver algumas particularidades.

O comando u desfaz a última edição, enquanto o comando CTRL-R refaz a última edição desfeita.

    iFoo
    iBar
    iFooBar
    u            <- Desfazendo iFooBar
    CTRL-R       <- Refazendo iFooBar

Os comandos u e CTRL-R aceitam um count como argumento, portanto, podemos fazer 2u ou 4CTRL-R para desfazer 2 edições ou refazer a últimas 4 edições desfeitas.

Nota: CTRL-R difere de . pois o primeiro refaz a última edição desfeita, enquanto o segundo reexecuta o último comando de edição.

Listas

Listas são estruturas recorrentes em programação. Uma lista é um conjunto de elementos dispostos em um seqüência, aonde um elemento tem um elemento anterior e posterior associado a ele, exceto o primeiro elemento, que não possui o anterior e o último elemento, que não possui um posterior.

Um apontador nada mais faz do que apontar para um determinado elemento de uma lista.

Lista de edição

Uma lista de edição, é uma estrutura que contém as edições realizadas em ordem seqüencial. Os comandos u e CTRL-R simplesmente manipulam está lista para desfazer ou refazer as edições.

     Conteúdo -  Lista de edição
     |        - Alteração feita: iFoo
     Foo
     |        - Alteração feita: iBar
     Foo
     Bar
     |        - Alteração feita: iFooBar <-- Apontador
     Foo
     Bar
     FooBar

Utilizando o comando u:

     Vazio
     |      Alteração feita: iFoo
     Foo
     |      Alteração feita: iBar        <-- Apontador
     Foo
     Bar
            Alteração desfeita: iFooBar

Utilizando o comando u novamente:

     Vazio
     |      Alteração feita: iFoo        <-- Apontador
     Foo
            Alteração feita: iBar
            Alteração desfeita: iFooBar

Utilizando o comando CTRL-R:

     Vazio
     |      Alteração feita: iFoo
     Foo
     |      Alteração feita: iBar        <-- Apontador
     Foo
     Bar
            Alteração desfeita: iFooBar

Quero mais!

Depois que você pega o jeito, editar no VIm é uma delícia. Desfazer uma ação é extremamente freqüente e a tecla u em teclados QWERTY é facilmente acessada.

Undo é um assunto extenso dentro do VIm pois ele envolve a função básica de editação. Outros tópicos interessantes são: bloco de edição, arvore de edição e timeline de edição. Estes dois últimos serão abordados futuramente, pois são de ampla utilidade.

Para os mais impacientes ou curiosos, vocês podem obter TUDO sobre undo no help, pesquisando sobre undo ou no capítulo 32.

  :help undo
  :help 32

Shell no VIm com agilidade

Muitas vezes você está editando no VIm e precisa executar algo no shell, pegar algum output ou simplesmente ir embora para casa. Hoje vamos ver algumas soluções que o VIm nos oferece para essas situações, mostrando porque ele é O editor.

Suspendendo o VIm

Para mim essa é a solução mais elegante que existe, porém ela é baseado no uso do Bash como shell e para mim a beleza consiste nessa junção Bash + VIm. Não sei como funciona e se funciona em outros shells.

Quando o Bash está com o Job Control ligado, ao inicializarmos um processo, ele ‘herda’ do Bash o tratamento de alguns sinais, um deles é o SIGTSTP. O tratamento do SIGTSTP suspende o processo, retornando o controle do terminal ao Bash. A maioria dos terminais mapeia o SIGTSTP para as teclas Ctrl-Z, mas isso é uma configuração do terminal, não do Bash. Você pode verificar a configuração do seu terminal utilizando:

$ stty -a

A beleza disto, é que o VIm não sobrescreve o tratamento do SIGTSTP herdado do Bash, portanto, você podê suspender o seu VIm! Com isso, você retornará o controle do terminal ao processo Bash pai do VIm. Você pode executar quantos comandos forem necessários e depois retornar o controle do terminal ao VIm utilizando o fg.

$ vim foo

Edição, edição, edição
Voltando para o Bash
Ctrl-Z

Tarefas que queremos executar no Bash...
$ rake db:migrate

Voltando para o VIm
$ fg
De volta ao VIm

Outro modo de obter um shell é através do comando :sh ou :shell.

:sh

Para retornar ao shell, Ctrl-D (EOF) ou exit.

O shell criado depende do valor da variável ‘shell’ do VIm.

:set shell

Executando dentro do VIm

Para executar um comando simples, como remover um arquivo, obter uma listagem de diretório, executar uma migration, basta utilizar :!.

:!ls

Você pode especificar um ponto para o qual deseja enviar a saída do comando.

:.!ls
:0!ls
:$!ls

Um atalho para :.! é !!.

Nota: !! é diferente de :!!, o segundo re-executa no shell o último comando executado anteriormente.

Criando uma sessão

Você está no meio de um trabalho pesado: 4 arquivos em edição, outros 10 na buffer list, um monte de marcadores, alguns lugares na stack.

Porém chegou a hora do seu merecido descanso, mas não quer perder o ambiente da edição. Deixar o computador ligado é uma solução, mas a energia pode acabar, sem contar o desperdício.

O segredo é salvar uma sessão do VIm e carrega-la posteriormente. Pode parecer complicado, mas é extremamente simples: :mks ou :mksession, você pode passar como argumento o nome da sessão, do contrário, o arquivo padrão é Session.vim.

:mks

O arquivo gerado nada mais é quem um aglomerado de opções e comandos do VIm. Portanto, para carregar de volta uma sessão, basta ‘executar’ o script com o comando :source ou :so.

:so Session.vim

O mais provável é que você vá carregar uma sessão a partir do terminal.

$ vim -S Session.vim

Por padrão, a opção -S carrega o arquivo Session.vim, portanto o comando abaixo tem o mesmo efeito.

$ vim -S

Conclusão

Parece que perdemos um pouco da cultura de ferramentas especializadas do UNIX. Hoje é normal quererem fazer tudo no seu editor preferido, na sua linguagem preferida etc. Eu acho isso uma bobagem que, em minha opinião, é fomentada por grandes empresas que espalham a todos que sua solução é completa: o desenvolvedor que sabe XYZ não precisa saber mais nada.

A relação disto com as dicas é indireta mas muito importante.

Perdemos um tempo considerável para achar uma solução pura no VIm, Ruby, o que for, mesmo existindo ferramentas UNIX próprias para a função. Hoje aprendemos como trocar agilmente do shell para o VIm e vice-versa, mostrando que faz parte do VIm colaborar com essas outras ferramentas.

Obtendo código fonte dos pacotes da sua distro

Por que não baixar direto do site oficial?

O código do projeto pode diferir da sua distribuição. Isso pode acontecer por diversos motivos:

1. A distro pode não adotar a última release.

   No Ubuntu, por exemplo, os pacotes são 'freezados' depois de uma release de uma versão e as atualizações geralmente são apenas para corrigir falhas de segurança e estabilidade. Apenas na próxima versão do Ubuntu você terá pacotes atualizados.

2. A distro pode alterar o código fonte para adequar aos seus propósitos.

   De um modo geral, cada distribuição tem um foco específico, por exemplo, facilidade. É comum distribuições com ênfase em segurança aplicarem 'patches' próprios ou de terceiros.

3. A distro pode 'quebrar' um projeto em diversos pacotes.

   Alguns módulos do Apache, por exemplo, que são distribuídos no código fonte oficial, estão espalhados em diversos pacotes no Ubuntu.

Através de arquivos .deb

Por padrão os arquivos deb ficam cacheados, basta copia-los para o local desejado e 'abri-los'. O local padrão de cache é /var/cache/apt/archives/. O aplicativo ar serve para abrir os arquivos .deb.

$ cp /var/cache/apt/archives/nome-do-pacote
$ ar x nome-do-pacote

Utilizando o APT para obter os pacotes

Para obter o código fonte do pacote não é necessário qualquer permissão, visto que nada será alterado no sistema, apenas iremos baixar o pacote. Este pacote pode diferir do que foi instalado, pois o código fonte é baixado de outro repositório assinalado por deb-src. Isto explica os diversos deb-src que podem haver na sua source list.

$ apt-get source nome-do-pacote

Com isso, obteremos 3 arquivos:

• .orig.tar.gz: arquivo original;
• .diff.gz: arquivo com as diferenças entre o original e a distribuição;
• .dsc: arquivo que descreve o pacote do código fonte;

Sem parâmetros adicionais, apt-get source irá efetuar o download, descompactar os arquivos .gz e aplicar o diff. No final teremos um diretório com o código fonte que obteríamos caso fizéssemos um apt-get install ou um apt-get update (Isto partindo do pressuposto que os repositórios deb e deb-src estejam condizentes, o que acontece numa condição normal).

Por que utilizar o código fonte de um projeto?

Para a coisa mais preciosa que existe: estudar.