Dofiles. Todos nós que usamos sistemas operacionais baseados em Unix convivemos com eles. Digamos que eles são um mal necessário. "Um mal?" você pergunta. Sim, um mal com um propósito que, a depender do caso, pode ou não servir para o bem de um ou muitos.

O fato é que a origem dos dofiles (.bashrc, .profile, .vimrc, .xispito, .coco, .filhodumaputa e por aí vai) é fruto de uma decisão arbitrária, empírica e sem qualquer origem projetada. Em condições normais de temperatura e pressão eu nomeio isso de bug, ou baca (de bacalhau). Só que esse baca tá aí fedendo há mais de 40 anos e tornou-se uma convenção. E como tal, só nos resta lidar com ela. Tem gente que quer atacar o problema na raiz, mas eu sou menos radical.

Já que livrar-se completamente dos dotfiles requer um trabalho de corno e que não resulta em algo satisfatório por completo (porque tá cheio de programador preguiçoso por aí), e pra quem tá no inferno é melhor abraçar e dormir de conchinha com o capeta, a minha abordagem para o tema é fazer a coisa toda de modo elegante, padronizado e facilmente reutilizável por mim ou por qualquer um (aliás, esses são os meus princípios básicos de vida).

Para implementar essas premissas, imponho os seguintes parâmetros técnicos:

  1. Manutenção da localização e comportamento original do aplicativo que cria e consome os dotfiles;
  2. Armazenamento dos dotfiles em locais remotos;
  3. Versionamento dos dotfiles;
  4. Acesso e sincronismo dos dotfiles em outros lugares (outras contas de usuário, outros servidores);
  5. SCRUD (search, create, read, update, delete) dos dotfiles sob demanda.

Depois de fuçar bastante na rede em busca de uma solução que implemente esses requisitos, o escolhido foi o homeshick.

Meu shell é o bash. Sempre foi, mesmo na época do OS X. O homeshick cuida bem do bash. Eu gostar do homeshick. Ele é feito em bash, mas pode cuidar de dotfiles (ou dotless) de tudo quanto é coisa.

Instalá-lo é tão simples quanto:

$ git clone git://github.com/andsens/homeshick.git $HOME/.homesick/repos/homeshick

Feito isto, adicione um alias conforme sugere a instalação (sugiro você colocar o alias no .bash_aliases), reinicie sua sessão de terminal e você estará pronto para tornar-se um guru dos dotfiles distribuídos.

Se você quiser ir um pouco além e adicionar complementação automática de linha de comando (code completion), adicione isso ao seu .bashrc:

# Homeshick completion
#-------------------------------------------------------------------------------
if [ -f ~/.homesick/repos/homeshick/completions/homeshick-completion.bash ]; then
  source ~/.homesick/repos/homeshick/completions/homeshick-completion.bash
fi

Criando castelos

Para prosseguir, faz-se necessário entender um conceito básico do homeshick: castle. Um 'castle' é um repositório versionado que guarda os seus arquivos. Cacete! Porque não chamar simplesmente de repositório, né?

Enfim, vá no GitHub e crie um repositório novo para os seus dofiles. Eu chamei o meu de algo ultra original: dotfiles.

Com o repositório criado no GitHub, crie o seu castle local:

$ homeshick generate dotfiles

Vamos adicionar o .bashrc ao castle. Mas antes, vamos ver uma coisa:

$ ls -lah .bashrc
-rw-r--r-- 1 user users 2,5K Out 10 07:23 .bashrc

Note que o .bashrc atual é um arquivo de verdade. Agora adicione-o ao castle, executando:

$ homeshick track dotfiles .bashrc

Veja a diferença:

$ ls -lah .bashrc
lrwxrwxrwx 1 user users 48 Out  1 03:57 .bashrc -> /home/user/.homesick/repos/dotfiles/home/.bashrc

Sacou, brother? O homeshick faz a mágica transformando tudo que você adicionar a ele em um link simbólico (symlink).

A partir de agora, sua vida é quase igual ao trabalho cotidiano com o git. Para enviar o seu castle para o GitHub:

$ homeshick cd dotfiles
$ git commit -m "Initial commit, add .bashrc."
$ git remote add origin git@github.com/username/dotfiles
$ git push -u origin master
$ cd -

Vamos adicionar mais um dotfile? Dessa vez o .bash_aliases:

$ homeshick track dotfiles .bash_aliases
$ homeshick cd dotfiles
$ git commit -m "Add .bash_aliases."
$ git push
$ cd -

Note que quando você roda o track, o homeshick já faz o git add por você. O mesmo não é verdade se você modifica um arquivo já rastreado. Por exemplo, edite o seu .bashrc e depois:

$ homeshick cd dotfiles
$ git add .bashrc
$ git commit -m "Update .bashrc."
$ git push
$ cd -

Nice and easy. Adicione quantos dotfiles você desejar ao homeshick. Todos, se quiser.

Todo mundo junto

A principal vantagem desde esquema com o homeshick é fazer com que suas tão queridas e familiares configurações estejam prontamente disponíveis em outros usuários e/ou servidores que você utilize mundo afora. Fazendo isso, você se sentirá sempre em casa quando acessar um servidor remoto.

Para replicar suas configurações por aí, basta fazer isso no servidor remoto ou outro usuário:

$ git clone git://github.com/andsens/homeshick.git $HOME/.homesick/repos/homeshick
$ $HOME/.homesick/repos/homeshick/bin/homeshick clone username/dotfiles

O homeshick vai te perguntar se você quer criar os links simbólicos para os arquivos armazenados em seu castle. Obviamente, concorde com ele, deixe-o fazer o que é necessário e depois rode:

$ source $HOME/.bashrc

Feito isso, seu alias e completion para o homeshick já estarão funcionando, pois você já tinha feito isso lá no começo e o homeshick pôs tudo no lugar para você. Cabra bom!

Mais uma vantagem: se você alterar algo nas configurações de seus dotfiles em seu servidor remoto, basta adicionar ao git, commitar e empurrar para o GitHub igualzinho já fizemos acima. Depois, nos outros lugares que você quer atualizar seus dotfiles com as novas configurações, basta fazer isso:

$ homeshick pull dotfiles

Fácil, néam?

Gostou? Conhece jeito melhor de fazer a mesma coisa? É só comentar.