Como usar o git merge --squash?

Eu tenho um servidor Git remoto, aqui está o cenário que eu quero executar:

• Para cada bug / recurso, crio um ramo Git diferente

• Continuo confirmando meu código nesse ramo do Git com mensagens não oficiais do Git

• No repositório superior, precisamos fazer um commit para um bug com a mensagem oficial do Git

Então, como posso mesclar minha ramificação para ramificação remota para que eles obtenham apenas uma confirmação para todos os meus check-ins (eu quero fornecer uma mensagem de confirmação para isso)?

Digamos que seu ramo de correção de bugs seja chamado bugfixe você deseja mesclá-lo em master:

git checkout master
git merge --squash bugfix
git commit

Isso pegará todos os commits do bugfixbranch, esmagará-os em 1 commit e os mesclará com o masterbranch.

Explicação :

git checkout master

Muda para o seu masterramo.

git merge --squash bugfix

Retira todas as confirmações da bugfixramificação e a mescla com sua ramificação atual.

git commit

Cria um único commit a partir das alterações mescladas.

Omitir o -mparâmetro permite modificar uma mensagem de confirmação de rascunho que contém todas as mensagens de suas confirmações esmagadas antes de finalizar sua confirmação.

O que finalmente esclareceu isso para mim foi um comentário mostrando que:

git checkout main
git merge --squash feature

é o equivalente a fazer:

git checkout feature
git diff main > feature.patch
git checkout main
patch -p1 < feature.patch
git add .

Quando eu quero mesclar um ramo de recurso com confirmações 105 (!!) e colocá-los todos compactados em um, não quero git rebase -i origin/master porque preciso resolver separadamente conflitos de mesclagem para cada confirmação intermediária (ou pelo menos as que o git não consegue descobrir por si mesmo). Usar git merge --squashme dá o resultado que eu quero de um único commit para mesclar um ramo de recurso inteiro. E, eu só preciso fazer no máximo uma resolução manual de conflitos.

Você deseja mesclar com a opção squash. Ou seja, se você quiser fazer um ramo por vez.

git merge --squash feature1

Se você deseja mesclar todas as ramificações ao mesmo tempo que as confirmações únicas, primeiro rebase de forma interativa e esmague cada recurso e, em seguida, junte polvo:

git checkout feature1
git rebase -i master

Squash em um commit e repita para os outros recursos.

git checkout master
git merge feature1 feature2 feature3 ...

Essa última mesclagem é uma "mesclagem de polvo" porque está mesclando muitos ramos ao mesmo tempo.

Espero que isto ajude

Se você já tem git merge bugfixem main, você pode esmagar sua mala comprometer em um com:

git reset --soft HEAD^1
git commit

Mesclar newFeatureramificação mastercom uma confirmação personalizada:

git merge --squash newFeature && git commit -m 'Your custom commit message';

Se sim, você faz

git merge --squash newFeature && git commit

você receberá uma mensagem de confirmação que incluirá todas as newFeatureconfirmações de ramificação, que você pode personalizar.

Explico-o aqui: https://youtu.be/FQNAIacelT4

Sei que esta pergunta não é especificamente sobre o Github, mas como o Github é tão amplamente usado e esta é a resposta que eu estava procurando, vou compartilhá-la aqui.

O Github tem a capacidade de realizar mesclagens de squash, dependendo das opções de mesclagem ativadas para o repositório.

Se a mesclagem de squash estiver ativada, a opção "Squash e mesclagem" deve aparecer no menu suspenso no botão "Mesclar".

Suponha que você trabalhou no recurso / tarefa1 com várias confirmações.

1. Vá para o ramo do seu projeto (projeto / meu_projeto)

   git checkout project/my_project
   

2. Crie uma nova ramificação (feature / task1_bugfix)

   git checkout -b feature/task1_bugfix
   

3. Marge com a --squashopção

   git merge --squash feature/task1
   

4. Crie uma única confirmação

   git commit -am "add single comments"
   

5. Empurre seu ramo

   git push --set-upstream origin feature/task1_bugfix
   

Para Git

Crie um novo recurso

via Terminal / Shell:

git checkout origin/feature/<featurename>
git merge --squash origin/feature/<featurename>

Isso não confirma, permite que você revise primeiro.

Em seguida, confirme e finalize o recurso desse novo ramo e exclua / ignore o antigo (o que você fez no desenvolvimento).

se você receber um erro: Não é possível confirmar porque você possui arquivos não mesclados.

git checkout master
git merge --squash bugfix
git add .
git commit -m "Message"

corrigido todos os arquivos de conflito

git add . 

você também pode usar

git add [filename]

Para esmagar sua filial local antes de pressioná-la:

1. faça o check-out da filial em questão para trabalhar, se ainda não estiver em check-out.

2. Encontre o sha do commit mais antigo que você deseja manter.

3. Crie / efetue o check-out de uma nova ramificação (tmp1) a partir dessa confirmação.

   git checkout -b tmp1 <sha1-of-commit>

4. Mesclar o ramo original no novo esmagamento.

   git merge --squash <original branch>

5. Confirme as alterações que foram criadas pela mesclagem, com uma mensagem de confirmação resumida.

   git commit -m <msg>

6. Faça o checkout do ramo original que você deseja esmagar.

   git checkout <branch>

7. Redefina para o commit original que você deseja manter.

   git reset --soft <sha1>

8. Rebase esse ramo com base no novo ramo tmp1.

   git rebase tmp1

9. É isso aí - agora exclua o ramo tmp1 temporário quando tiver certeza de que está tudo bem.

Você pode usar a ferramenta que eu criei para facilitar esse processo: git-squash . Por exemplo, para esmagar todas as confirmações na ramificação de recurso ramificada da ramificação principal, escreva:

git squash master
git push --force