Processo de revisão de código ao usar o GIT como repositório?

Qual é o melhor processo para revisão de código ao usar o GIT? Temos um provedor GIT externo (Unfuddle) e limites para o uso de recursos - portanto, não podemos ter repositórios remotos dedicados para todos os desenvolvedores.

Processo atual:

• Temos um servidor GIT com uma masterfilial na qual todos comprometem
• Os desenvolvedores trabalham fora do masterespelho local ou de um ramo de recurso local
• Devs enviar para a masterfilial do servidor
• Devs solicitam revisão de código na última confirmação

Problema:

• Qualquer bug na revisão de código já está no mestre quando é detectado.
• Pior, geralmente alguém queimou algumas horas tentando descobrir o que aconteceu ...

Então gostaríamos

• Para revisar o código ANTES da entrega no 'mestre'.
• Tenha um processo que funcione com uma equipe global (sem avaliações exageradas !)
• algo que não exija que um desenvolvedor individual esteja em sua mesa / máquina para ser ligado para que outra pessoa possa entrar remotamente (remova a dependência humana, os desenvolvedores vão para casa em fusos horários diferentes)

Usamos o TortoiseGIT para uma representação visual de uma lista de arquivos alterados, diferenciando arquivos etc. Alguns de nós entram no shell do GIT quando a GUI não é suficiente, mas o ideal é que o fluxo de trabalho seja simples e com base na GUI. (Quero que a ferramenta eleve qualquer ônus, não meus desenvolvedores).

Um modelo simples, mas eficaz, é o modelo de solicitação de recebimento do GitHub , onde os contribuidores arquivam solicitações de "por favor, mesclem no meu código". Um mantenedor revisa os conjuntos de alterações e decide se eles precisam de mais trabalho ou se são adequados para mesclagem. Ele então pode se fundir no ramo mestre. Os promotores geralmente não têm permissão para enviar diretamente para o ramo principal (isso pode ser personalizado de acordo com o seu gosto, permitimos que compromissos "menores" entrem diretamente).

Git é um sistema de controle de versão distribuído: não tenha apenas um repositório com uma ramificação!

Você pode configurar vários repositórios - um para cada desenvolvedor - e outro que é o repositório principal. Quando uma das ramificações está pronta para ser mesclada, o desenvolvedor solicita uma mesclagem e as alterações são puxadas da ramificação / repositório para o mestre.

Antes que essa mescla realmente ocorra, o revisor pode inserir as alterações em seu ambiente e analisá-las antes de enviá-las para o mestre.

As vantagens adicionais são que, dessa maneira, um desenvolvedor pode ter quantas ramificações quiser, com o nome que desejar, sem interferir uma na outra ou mesmo tendo que ver a roupa suja uma da outra.

Além disso, aprenda a linguagem: por "Devs comprometem-se com o ramo principal do servidor", você quer dizer que eles enviam suas alterações para o mestre?