Simples casa com simples
Há algum tempo (desde o fim do ano passado) resolvi fazer um experimento: trocar o editor vim pelo vi (mais especificamente a implementação nvi), como editor para uso no dia a dia, inclusive para programar em Lua.
Não entrarei no mérito do porquê dessa decisão, mas falarei um pouco sobre a experiência que esse editor me proporcionou, e sobre o quanto ele me surpreendeu na sua versatilidade, embora eu já o usasse há bastante tempo para operações mais simplórias.
Após ler e reler o manual do vi algumas vezes, percebi que ele já possui todos os recursos que preciso. Notadamente, ele permite:
- Definir atalhos para sequências de ações;
- Criar abreviações para termos usados com frequência;
- Abrir um shell como subprocesso;
- Mostrar/ocultar números das linhas;
- Mostrar mais de um arquivo (ou o mesmo) em telas divididas;
- Ler/escrever em buffers;
- Desfazer e refazer ações múltiplas vezes (embora a forma de fazer isso seja um pouco diferente de como é feito no vim);
- Gerenciar e navegar por tags;
- Salvar preferências do editor em arquivo (geralmente no
.exrc
); - Alternar entre preferências diferentes (carregando arquivos de preferências diferentes);
- Salvar e reutilizar histórico de comandos;
- Modo
ex
(edição não visual, por linha de comando); - Dentre outros (que podem ser encontrados no manual do vi).
O que são tags no vi?
Todo esse conjunto de ferramentas permite que se crie uma infinidade de
usos para o vi, combinando atalhos, comandos, macros em registradores, troca
de preferências, troca de modo (vi
/ ex
),
execução de comandos externos, etc.
Talvez você esteja se perguntando se não está faltando nada. Quase consigo te imaginar dizendo algo como “mas e destaque de sintaxe, não tem?”
Pois bem, aí você me pegou. Não tem. No entanto, eu pude perceber que isso na verdade não é um problema. Pelo contrário, é quase um livramento. Imagine, por exemplo, se para ler um texto (em português ou qualquer idioma que conheça) as palavras fossem destacadas em cores diferentes (verbos em uma cor, substantivos em outra, etc.).
Você acha que isso ajudaria ou atrapalharia na leitura? Pois bem, no código é a mesma coisa. Destacar a sintaxe faz com que você preste mais atenção à sintaxe e menos atenção à semântica (significado) do código, que é o que efetivamente importa.
Pode até ser que esse recurso possua alguma relevância ainda durante os primeiros passos com uma nova linguagem, quando ainda não se está muito familiarizado. Porém eu ainda assim suspeito que não, pois lembro-me que na faculdade eu tive o desprazer de escrever meus primeiros programas usando papel e caneta, sem poder testá-los num primeiro momento.
Por mais que tenha sido um desprazer, acredito que em nada me prejudicou no entendimento da sintaxe. E como você pode imaginar, papel e caneta não são exatamente o ambiente ideal para destaque de sintaxe.
Ok, mas e Lua?
Afinal, estamos aqui para falar sobre Lua, não é mesmo? Pois bem, o que ocorre é que o editor vi tem muito a ver com Lua. Ele é simples e versátil, e possui uma documentação que cabe na cabeça do programador.
Programar em Lua não requer nenhuma ferramenta ultra sofisticada. Não requer nada especializado. E você pode adaptar o vi para definir preferências, atalhos e abreviações que auxiliem na escrita de código Lua.
Vou demonstrar alguns exemplos de adaptação aqui.
Vamos começar criando um arquivo de preferências específico para Lua, ou seja, um conjunto de preferências para o vi que deverá permanecer ativo quando estiver editando um arquivo-fonte Lua.
Por convenção, uso o diretório ~/.config/vi
para
salvar arquivos desse tipo, e também por convenção, uso a extensão
.ex
no nome do arquivo, já que são basicamente comandos do modo
ex
do editor. Portanto nesse caso o arquivo será
~/.config/vi/lua.ex
(mas você pode usar as
convenções que considerar apropriadas para o seu caso).
Para começar, vamos usar uma abreviação. Embora seja incomum que haja
longas sequências de palavras repetidas em Lua, existem algumas situações em
que abreviações podem ajudar. Por exemplo, no uso de funções locais. No lugar
de digitar local function
, poderíamos digitar apenas
lof
seguido de um espaço, de modo que será substituído por
local function
.
Então para isso, adicionamos ao arquivo lua.ex
a seguinte
linha:
abbrev lof local function
Sinta-se a vontade para incluir outras abreviações que julgar úteis. Agora vamos criar alguns atalhos. Digamos que você queira executar um arquivo-fonte Lua ao pressionar F5 (lembre-se de salvar o arquivo antes). E que ao pressionar F6 você valida que não haja erros de sintaxe.
Para isto, inclua as seguintes linhas (não copie e cole, em seguida explico o porquê):
map ^[[15~ :!lua %^M
map ^[[17~ :!luac -p %^M
Não se engane pela aparência dessas linhas, existem alguns caracteres
especiais nelas (formados por uma combinação entre ^
e o
caractere logo em seguida). Mantive essa representação (que também é usada no
vi) porque na realidade são caracteres não imprimíveis.
O caractere ^[
na verdade é um “Escape” (0x1b na
tabela ASCII), e o caractere ^M
representa uma combinação de
retorno (0x0d) seguido de nova linha (0x0a). Não se preocupe em decorar os
detalhes, explicarei como inserir esses caracteres especiais usando o próprio
vi.
Para inserir o caractere referente ao F5 no vi, primeiro digite a
combinação Ctrl+v
, seguida da tecla F5, e o resultado será
^[[15~
. O mesmo procedimento pode ser feito para F6 e/ou
para quaisquer outras teclas de função. Para o retorno, seguido da nova
linha, digite Ctrl+v
, dessa vez seguido de
Enter
.
E agora explicando o significado dessas linhas, o comando map
recebe dois argumentos, sendo o primeiro a tecla ou combinação de teclas de
atalho, e o segundo é a sequência de caracteres que digitaria no vi. Neste
caso, usamos dois-pontos (:
) para anunciar que um comando
ex
será executado, depois exclamação (!
) para
anunciar que um comando externo será executado. Na primeira linha, por
exemplo, chamamos o interpretador lua
, seguido do sinal de
porcentagem (%
), que é substituído pelo nome do arquivo.
Muito bem, atalhos criados, acho que agora já podemos testar, certo?
Errado. Ao abrir o editor vi, você ainda precisará importar as preferências,
para que elas façam efeito. A importação de arquivos de comandos
ex
no vi pode ser feita com o comando source
.
Porém, se não quiser digitar esse comando a cada vez que abrir um
arquivo-fonte Lua, pode definir um atalho para importação.
Para isto, vamos editar então o arquivo ~/.exrc
, que
contempla as preferências globais do vi. Nele, adicionamos a seguinte
linha:
map gl :source ~/.config/vi/lua.ex^M
Pronto! Agora, quando abrir um arquivo Lua, basta digitar g
seguido de l
, que a importação será feita. Isto habilitará todos
os atalhos e abreviações que tiver definido para trabalhar com Lua.
Isto é apenas uma demonstração de algumas possibilidades, porém com a devida familiaridade com o editor vi e um pouco de imaginação, certamente você encontrará inúmeras outras combinações que sejam do seu interesse, tanto para editar arquivos-fonte Lua como para outros tipos de arquivo.
Referências externas
Os textos a seguir tem relação com o artigo, e também podem ser do seu interesse:
- Troquei o vim pelo vi: breve relato pessoal que publiquei em lista de e-mail, no qual comento essa decisão de trocar o vim pelo vi;
- why vi rocks (em inglês): uma lista de truques que podem ser aplicados usando o vi;
- Edit text with vi(1) (em inglês): outra lista de truques, que inclusive foi a primeira a despertar o meu interesse novamente pelo vi;
- How I program without syntax highlighting (em inglês): texto que chama a atenção para a viabilidade (e as vantagens) de programar sem o uso de destaque de sintaxe;
- A case against syntax highlighting (em inglês): outro texto que também fala sobre destaque de sintaxe, em que fala sobre o quanto a percepção de que esse recurso ajuda pode ser uma percepção equivocada.