O post de hoje é do nosso amigo Lucas Cavalcanti, desenvolvedor da Caelum.

Usando git, sempre é bom trabalhar em branches, nunca commitar diretamente na branch master.

Acontece que às vezes você simplesmente esquece de criar uma branch antes de começar a trabalhar
e commita várias coisas no master. O problema disso é que se você der um git pull origin master
e acontecer um conflito de merge, você vai ter que resolver todos os conflitos de uma vez só,
e ganhar um commit “Merge branch blablablah” que some com algumas informações de commit…

O que fazer então?

Um jeito legal de prevenir isso é digitando os comandos:


(master) $ git branch temp
# cria uma branch pra guardar o estado atual


(master) $ git reset --hard HEAD@{1}
# volta o estado do branch master para a última
# ação perigosa que você fez, geralmente
# o último push que vc fez no servidor


(master) $ git pull origin master
# agora sim fazendo um pull seguro


(master) $ git checkout temp
(temp) $ git rebase master
# e corrige os eventuais conflitos do jeito certo


(temp) $ git checkout master
(master) $ git merge temp
(master) $ git push origin master
(master) $ git branch -d temp


Assim você corrige a cagada de trabalhar no master sem querer e continua a trabalhar com o git
do jeito certo.

Posts Relacionados:

Acompanhe-nos por RSS, por Email ou via Twitter.
Veja como ter um desconto no Dreamhost: um excelente servidor web.

A versão 1.5 do Mirror acaba de ser lançada.

Alguns problemas com performance foram corrigidos.

Também foi criada uma forma de evitar um padrão que etava se tornando muito comum. Filtrar a lista de elementos logo após refletí-los:

List originalMethods = new Mirror().on(clazz)
                              .reflectAll().methods();
List methods = new ArrayList();
for (Method m : originalMethods) {
    if (wantThisMethod(m)) {
        methods.add(m);
    }
}

Agora você pode fazer apenas:

List methods = new Mirror().on(clazz).reflectAll()
                         .methodsMatching(new SeuMatcher());

Release notes completo pode ser encontrado aqui.

Posts Relacionados:

Acompanhe-nos por RSS, por Email ou via Twitter.
Veja como ter um desconto no Dreamhost: um excelente servidor web.

Umas das coisas legais que bash tem é uma variável que define como deve ser o prompt da linha de comando. Essa variavel de ambiente se chama PS1. Um dos usos mais incríveis que já vi dela foi o de mostrar em qual branch do git você está (e não mostrar nada quando você não está em um repositório).

Isso é a diferença entre

e isso

Não sei quanto a vocês, mas eu realmente fico mais feliz com a segunda forma.

A minha variável PS1 é configurada da seguinte forma (mac - ~/.bash_profile - linux - ~/.bashrc):

export PS1="\[\033[38m\]\u\[\033[32m\] \w \[\033[31m\]\`git \\
branch 2>/dev/null | grep \"^\*\" | \\
sed -r \"s/\*\ (.*)/ \(\1\)/\"\`\[\033[37m\]$\[\033[00m\] "

Impossível de ler, correto? Vou quebrar em mais linhas para facilitar a vida.

PS1="\[\033[38m\]\u";
PS1="$PS1\[\033[32m\] \w";
PS1="$PS1\[\033[31m\]";
PS1="$PS1\`git branch 2>/dev/null | grep \"^\*\" | \\
                           sed -r \"s/\*\ (.*)/ \(\1\)/\"\`";
export PS1="$PS1\[\033[37m\]$\[\033[00m\]";

Não testei, mas deve ter o mesmo efeito. Explicando um pouco da mágica:

1. Essa sequência bizarra de caracteres (\[\033[38m\]) é a forma de definir que o que virá depois será impresso em branco, num terminal que permite coloração (o que realmente define a cor é o 38m. O resto é apenas a forma de indicar a mudança de cor). “\u”, na PS1, significa o usuário atual.
2. A próxima sequência de caracteres bizarros troca a cor para verde. “\w”, na PS1, é o seu path atual.
3. Troca a cor para vermelho.
4. Extrai o nome do branch (sendo executado em uma subshell. Para isso que servem os \`).
   1. git branch 2>/dev/null: Imprime todos os branches do repositório onde você se encontra. Caso ocorra algum erro, a mensagem de erro será enviada para /dev/null, vulgo limbo (por isso nada será impresso nos outros diretórios).
   2. grep “^\*”: Me dá todas as linhas começadas por * .
   3. sed -r \”s/\*\ (.*)/ \(\1\)/\”: Novamente o grande monstro sed salva o dia. A regex que está ali pega o que vêm depois do espaço que está depois do * e imprime com parenteses em volta.
5. Muda a cor para branco, imprime $ (apenas para marcar o fim do prompt) e para de brincar com as cores do terminal, devolvendo o controle à shell.

A versão anterior que eu usava da PS1 usava ruby pra fazer essa mágica toda, mas dessa forma não depende mais do ruby instalado na máquina.

Posts Relacionados:

Acompanhe-nos por RSS, por Email ou via Twitter.
Veja como ter um desconto no Dreamhost: um excelente servidor web.

Não sei se muitas pessoas tem esse problema, mas eu tenho mais de um par de chaves (no caso, tenho a minha para a conta jonasabreu do github e a da conta vidageek, também no github). Como era muito chato troca-las manualmente, fiz um pequeno script em bash para fazer isso para mim.
O script assume que as chaves atuais tem o nome de “id_rsa” e “id_rsa.pub” e as outras estão com um sufixo qualquer, como “id_rsa.vidageek” e “id_rsa.pub.vidageek”. O script deve estar na pasta .ssh .

#! /bin/bash

OLD_KEY=$1;
NEW_KEY=$2;

if [[ ! -f "id_rsa.$NEW_KEY" ]]; then
	echo "could not find id_rsa.$NEW_KEY";
	exit 1;
fi;

if [[ -f "id_rsa.$OLD_KEY" ]]; then
	echo "$OLD_KEY already exists";
	exit 2;
fi;

if [[ -f "id_rsa.pub.$OLD_KEY" ]]; then
	echo "$OLD_KEY already exists";
	exit 3;
fi;

mv id_rsa id_rsa.$OLD_KEY;
mv id_rsa.pub id_rsa.pub.$OLD_KEY;

mv id_rsa.$NEW_KEY id_rsa;
mv id_rsa.pub.$NEW_KEY id_rsa.pub;

Como chaves rsa são algo meio ruim de se perder, o script faz algumas checagens básicas, mas use-o por sua conta e risco :D

Usage:

./switch_keys.sh nome_das_atuais nome_da_que_vai_ser_ativada

Exemplo:

./switch_keys.sh jonas vidageek

Troca as chaves atuais jonas pelas que estão com a terminação vidageek .

Posts Relacionados:

Acompanhe-nos por RSS, por Email ou via Twitter.
Veja como ter um desconto no Dreamhost: um excelente servidor web.