Como posso indolor série divergente recurso de ramos?

0

Pergunta

Eu tenho um abrir PR em um branch chamado feature-b que em breve será intercalado main. No entanto, eu escrevi para meu apoio feature-a branch, que está em curso. Eu quero continuar a trabalhar feature-a e aproveitar o trabalho que eu fiz na feature-b antes de ter sido intercalado main.

Qual é a melhor forma de fazer isso? A nossa mescla de main são exterminados, para todos os compromete-se em feature-b vai ser reescrito como um único commit quando ele é mesclado para main. Portanto, a alteração da base feature-a no feature-b agora resultará em um conflito futuro dor quando eu direta feature-a para main porque mesmo que as mudanças tenham sido feitas em diferentes compromete-se.

Qual é a melhor maneira para mim, para incluir as alterações feitas em feature-b no meu feature-a ramo enquanto minimiza o futuro de dor, quando eu finalmente série feature-a para main?

ATUALIZAÇÃO

Eu fui em frente e:

  1. Realocado feature-a no feature-b
  2. Fez mais mudanças (apenas 1 commit) para feature-a enquanto feature-b foi revisto
  3. Squash-mesclado feature-b uma vez que ela foi aprovada (sem outras alterações necessárias, de modo a feature-a já tem o código exato que foi intercalado)
  4. Puxou mais recente main e realocados feature-a em cima dela

Como se temia, o git reclama que vários arquivos são "tanto modificado" ou "ambos adicionados". Isso só seria um pouco chato, mas simples para corrigir. O que o torna incrivelmente confuso - especialmente se a qualquer passagem do tempo passou - o intercalar comentários nos arquivos.

Apesar de ambos os main e feature-a ramos tem o exato mesmo código em todos os arquivos, eu fico super chato comportamento:

  1. Para o "tanto adicionado" arquivos, mesclar os comentários são adicionados para a "CABEÇA" (Actual)" e "pai da #HASH (mensagem de commit)". Eu sou forçado a escolher um ou outro, mesmo que eles são exatamente o mesmo!
  2. Para o "tanto modificado" de arquivos, é ainda pior. A "CABEÇA" (Actual)" mostra o código correto. No entanto, o "pai da #HASH (mensagem de commit)" seção mostra metade do código. Novamente, apesar de ambos os ramos têm todo o código!! Eu não te miúdo, aceitando a "alteração de entrada" (como identificado pelo VS Código) irá remover o código que está em ambos os ramos.

Se eu não tivesse feito essas alterações em rápida sucessão, eu estaria irremediavelmente perdido e confuso sobre o que o git está me mostrando. O que de fato aconteceu várias vezes no passado, mas eu não poderia colocar um dedo sobre o que estava acontecendo de errado. Agora que eu tenha reproduzido esta e verificado o comportamento, eu sou completamente aturdidos, como o que o git está fazendo e como as pessoas estão lidando com este cenário.

ATUALIZAÇÃO 2

OK, eu gosto de ver porque ele estava indo para remover o código de agora. É porque as alterações que fiz no feature-b foram em vários compromete-se, e aqueles que se compromete acabou sendo esmagado quando a série para main ocorreu. Este é, sem dúvida, a origem da dor e por isso que eu estou tentando descobrir uma mais sã de fluxo de trabalho.

git
2021-11-23 23:26:24
1

Melhor resposta

0

Eu não estou convencido de que o final de intercalação/squash vai ser complicado. Se a mesma alteração está sendo feita em diferentes compromete-se, talvez, o Git pode detectar isso e ser feliz com ele.

Se você acha que vai ser complicado, porém, o que você pode fazer é:

  1. Alterar a base de sua feature-a ramo com feature-b agora, para que sua feature-a ramo agora inclui concluído recurso B e o em curso Um recurso, que é o que você precisa para fazer seu trabalho.
  2. Depois de feature-b é intercalado no main ramo, rebase feature-a para confirmar imediatamente antes de o esmagado cometer o que eles fizeram para a característica de B. Este deve passar sem problemas.
  3. No seu feature-a ramo de uso git reset --soft X onde X é a confirmação de hash para o esmagado cometer o que eles fizeram para recurso B. em Seguida, utilize git commit para fazer um commit. Agora você tem uma esmagado cometer cujo conteúdo é igual ao estado atual de seu trabalho, no recurso de A. Mas isto cometer principal é confirmar que adicionou o recurso de B para o ramo principal, de modo que este comprometer a comparação com o pai, apenas contêm funcionalidade de A. é bom para continuar trabalhando em Um recurso neste ponto, ou simplesmente pedir uma série.

A propósito, eu estou muito confiante de que as coisas não precisam ser esta confuso se a sua organização se funde em vez de realoca para adicionar coisas ao ramo principal. E, em seguida, haveria a vantagem de preservar a história real de o código que você estava trabalhando, em vez de apenas a preservação artificial da história.

2021-11-23 23:52:54

Para ser claro, não usamos realoca - usamos compromete-se esmagado. E eu tenho 99% de certeza de que as coisas vão ser confuso como eu tentei isso no passado. Git fica terrivelmente confuso por distintos compromete-se a fazer as mesmas alterações. Eu estou disposto a tentar de novo embora e relatar de volta :)
me--

@eu-- eu tenho certeza esmagado compromete-se é um rebase
evolutionxbox

A realocação significa mover o ramo assim, começa de um ponto diferente, que reescreve a história de como ele foi desenvolvido. Esmagar significa mudar o ramo inteiro em apenas um commit, descartando a história de como ele foi desenvolvido, exceto para o resultado final.
David Grayson

@DavidGrayson por Favor, veja o meu atualizada pergunta para uma explicação do comportamento de eu ver a partir do git.
me--

OK. O seu passo 4 ("Puxado mais recente principal e realocados recurso-um em cima dela"), é o que fez você toda a dor não é algo que eu recomendaria fazer. Em vez de fazer isso passo 4 na sua pergunta, tente os passos 2 e 3 da minha resposta.
David Grayson

Obrigado @DavidGrayson. Parece que sim . . . trabalhoso
me--

Como eu disse na minha resposta, o problema é causado pela pessoa fazendo tudo isso de leitura e de esmagar, em vez de simplesmente fundir.
David Grayson

Em outros idiomas

Esta página está em outros idiomas

Русский
..................................................................................................................
Italiano
..................................................................................................................
Polski
..................................................................................................................
Română
..................................................................................................................
한국어
..................................................................................................................
हिन्दी
..................................................................................................................
Français
..................................................................................................................
Türk
..................................................................................................................
Česk
..................................................................................................................
ไทย
..................................................................................................................
中文
..................................................................................................................
Español
..................................................................................................................
Slovenský
..................................................................................................................