No fluxo do GitHub, é correto basear a ramificação de recurso em outra ramificação de recurso?

22

Usamos o GitHub Flow em nosso projeto e, na maioria das vezes, abrimos uma nova ramificação de recursos do master , fazemos alguns trabalhos lá, abrimos um PR, revisamos o código e voltamos ao master .

No entanto, meu trabalho atual depende de outro problema que está sendo trabalhado feature-branch-A. É kosher criar minha ramificação a partir dessa outra ramificação ou é contra o espírito do GitHub Flow?

A alternativa seria basear minha ramificação no mestre e mesclar as alterações de feature-branch-A(frequentemente).

Qual opção é preferida no fluxo do GitHub?

git github gitflow Borek Bernard
fonte

Respostas:

24

Aqui está o fluxo de trabalho que sigo quando ramifico de um ramo de recurso:

  1. Criar a feature-branch-Bpartir defeature-branch-A
  2. Trabalho em feature-branch-B
  3. Se mais confirmações forem adicionadas feature-branch-Aapós a ramificação, refaça feature-branch-Bafeature-branch-A
  4. Conclua o trabalho feature-branch-Be aguarde até que ele feature-branch-Aseja mesclado master.
  5. Depois de feature-branch-Amesclado master, faça o rebase feature-branch-Bparamaster
  6. Mesclar feature-branch-Bemmaster

Seguindo o fluxo de trabalho acima, parece que você ramificou masterapós a feature-branch-Amesclagem. Você não precisa esperar até que feature-branch-Aseja mesclado para começar a trabalhar feature-branch-B. No entanto, você terá uma história limpa sem árvores complicadas.

geoji
fonte
Essa era exatamente a resposta que eu estava procurando! Você me salvou a dor de cabeça de resolver isso, obrigado!
Vance Palacio
Não rebase commits já publicados ... daolf.com/posts/git-series-part-2
Sebi2020
8

Eu acho que isso é completamente ok se você criar o recurso em outro recurso.

Mas não faça isso com bastante frequência. Vejo um desenvolvedor que fez isso e, uma ou duas semanas, jogou 10 RP por fusão. Isso foi completamente exaustivo para outros membros para revisão e difícil para mesclar também. Tente não fazer árvores no git. Isso ajuda na divisão para encontrar erros.

Ladislav Prskavec
fonte
7

Uma coisa importante que o git-flow pretendia abordar foi a capacidade de raciocinar sobre o papel de um determinado ramo e o que ele ramifica e se funde.

Idealmente, todas as ramificações retornam à linha de código da qual foram mescladas. Isso normalmente é uma mesclagem da linha principal (no fluxo git, isso é dev). O recurso ramifica ramificação e mesclagem do dev, libera ramificação ramificação e mesclagem do dev (com uma mesclagem adicional para master). Hot fixes ramificam e mesclam do master (com essa mesclagem adicional de volta ao dev).

Cada linha de código se ramifica e se funde de volta ao pai. Uma linha de código pode extrair código de outras linhas de código a qualquer momento, se necessário.

Se o ramo de um ramo de recurso é um "Quero explorar essa maneira de corrigir um problema nesse ramo de recurso" - perfeitamente bem. Ramifica a partir da ramificação do recurso, confirma um pouco de código e mescla de volta à ramificação do recurso (ou é descartada).

  1. ramificar do recurso
  2. explorar a ideia
  3. mesclar para destacar

O que você deseja evitar, no entanto, é algo parecido com:

  1. ramificação do recurso necessário
  2. trabalhar no código
  3. mesclar do dev quando o recurso necessário estiver concluído
  4. verificar a funcionalidade (e confirmações adicionais) na ramificação do recurso
  5. mesclar para dev

A razão é que o começo e o fim não coincidem - torna um pouco mais difícil entender o que é e o que foi. Não é impossível, mas apenas leva um pouco mais de tempo para alguém entender seu papel.

No entanto, se esse é um novo recurso que depende do código que ainda não foi encontrado no dev, o fluxo deve ser:

  1. ramo do dev
  2. mesclar a partir do recurso necessário
  3. trabalhar no código
  4. mesclar do dev quando o recurso necessário estiver concluído
  5. verificar a funcionalidade (e confirmações adicionais) na ramificação do recurso
  6. mesclar para dev

Observe que isso começa com um ramo do dev e termina com uma mesclagem para o dev.

Tudo isso dito, provavelmente a melhor coisa a fazer é evitar a mesclagem de um recurso para outro. Ramifique o recurso, faça as preliminares necessárias ... e aguarde.

  1. ramo do dev
  2. trabalhar no código
  3. mesclar do dev quando o recurso necessário estiver concluído
  4. verificar a funcionalidade (e confirmações adicionais) na ramificação do recurso
  5. mesclar para dev

Isso fornece o conjunto mais estável de ramificações e código.

Algo a considerar em trabalhos futuros seria ter um recurso para publicar as interfaces necessárias para interoperabilidade com outros recursos - mesmo que o código de implementação não esteja completo. Isso seria mesclado ao dev, e o recurso necessário poderia funcionar com essas interfaces, assim como o recurso futuro. Isso provavelmente permitiria que o recurso futuro progredisse mais (codificando contra as interfaces, testando contra stubbs que implementam as interfaces) do que faria se tivesse que esperar pelo recurso necessário mesclar para dev.


fonte
No seu terceiro conjunto de etapas, a desvantagem é que a etapa 1 precisa conter algum "commit fictício". Na minha situação, eu não tenho nada de útil para cometer até que required-featureestá imerso em.
Borek Bernard
Ainda aponto como um dos meus artigos favoritos sobre ramificação: Estratégias avançadas de ramificação do SCM . Embora ele se concentre em um sistema centralizado de controle de versão, as idéias dos papéis que ele apresenta são exatamente mapeadas para o git-flow.
E quanto ao commit dummy, é por isso que esse último parágrafo está lá. O que teria sido útil é um recurso executado e concluído como "fornecer interfaces para fazer coisas". Então, o recurso necessário e o recurso futuro podem funcionar com essas interfaces. Enquanto o recurso necessário trabalhava na implementação das interfaces, o recurso futuro seria capaz de eliminá-los e fazer testes contra eles - aguardando que o recurso necessário fosse mesclado ao dev.
Pensando em quão ruim é o seu segundo conjunto de etapas. Na prática, é um problema que um ramo não tenha um "mesmo" começo e fim? Eu não acho que isso me incomodaria muito, mas talvez seja um grande fator de confusão?
Borek Bernard
É uma questão de descrever claramente através do ramo, confirmar e mesclar o histórico de qual ramo é o ramo pai. No git-flow, você deve seguir o sistema descrito nas ramificações do recurso git flow . A ramificação do recurso ramifica a partir da ramificação de desenvolvimento e volta a se desenvolver novamente. Quando você inicia a ramificação de outras ramificações de recursos, fica menos claro qual é o papel dessa ramificação. Recomendamos que você espere até que o recurso necessário seja concluído se você não puder progredir no código sem ele agora.
1

Uma ramificação de recurso é normalmente considerada menos estável que o tronco (desenvolvimento / mestre), portanto você pode se sujeitar a mais alterações subjacentes do que o normal se basear seu trabalho em uma.

Além disso, embora normalmente desaprovado se a ramificação foi empurrada, não é incomum refazer ramificações de recurso na ramificação pai, para obter um histórico melhor, mas isso seria mais complicado se houvesse ramificações adicionais pendentes, então você está essencialmente criando uma nova restrição para o proprietário da filial pai, além de possíveis dores de cabeça para você.

Dito isto, não há uma regra estrita contra isso. Afinal, são apenas padrões e práticas recomendadas.

Editar: perdeu parte da sua pergunta. A fusão do ramo de recursos com o seu, que é baseado no mestre, não evita realmente nenhum dos problemas mencionados acima e pode realmente criar uma história ainda mais complicada.

Portanto, se eu estivesse no seu lugar e pudesse adiar o trabalho até que o recurso a estivesse pronto, ou fazer outra coisa primeiro, eu faria isso.

axl
fonte