Como você compacta todo o seu repositório até o primeiro commit?

Posso mudar para o primeiro commit, mas isso me deixaria com 2 commits. Existe uma maneira de referenciar o commit antes do primeiro?

Talvez a maneira mais fácil seja apenas criar um novo repositório com o estado atual da cópia de trabalho. Se você deseja manter todas as mensagens de confirmação, você pode primeiro fazer git log > original.loge editar isso para sua mensagem de confirmação inicial no novo repositório:

rm -rf .git
git init
git add .
git commit

ou

git log > original.log
# edit original.log as desired
rm -rf .git
git init
git add .
git commit -F original.log

A partir do git 1.6.2 , você pode usar git rebase --root -i.

Para cada confirmação, exceto a primeira, altere pickpara squash.

Atualizar

Eu fiz um pseudônimo git squash-all.
Exemplo de utilização : git squash-all "a brand new start".

[alias]
  squash-all = "!f(){ git reset $(git commit-tree HEAD^{tree} -m \"${1:-A new start}\");};f"

Embargo : lembre-se de fornecer um comentário, caso contrário, a mensagem de confirmação padrão "Um novo começo" seria usada.

Ou você pode criar o alias com o seguinte comando:

git config --global alias.squash-all '!f(){ git reset $(git commit-tree HEAD^{tree} -m "${1:-A new start}");};f'

One Liner

git reset $(git commit-tree HEAD^{tree} -m "A new start")

Nota : aqui "A new start " é apenas um exemplo, fique à vontade para usar seu próprio idioma.

TL; DR

Não há necessidade de esmagar, use git commit-tree para criar um commit órfão e siga em frente.

Explicar

1. crie uma única confirmação via git commit-tree

   O que git commit-tree HEAD^{tree} -m "A new start"faz é:

   Cria um novo objeto de confirmação com base no objeto em árvore fornecido e emite o novo ID do objeto de confirmação no stdout. A mensagem de log é lida a partir da entrada padrão, a menos que sejam fornecidas as opções -m ou -F.

   A expressão HEAD^{tree}significa o objeto de árvore correspondente a HEAD, ou seja, a ponta do seu ramo atual. veja Árvore-objetos e commit-Objects .

2. redefinir a ramificação atual para o novo commit

   Em seguida, git resetbasta redefinir a ramificação atual para o objeto de confirmação recém-criado.

Dessa forma, nada no espaço de trabalho é tocado, nem há necessidade de rebase / squash, o que o torna muito rápido. E o tempo necessário é irrelevante para o tamanho do repositório ou a profundidade do histórico.

Variação: novo repositório a partir de um modelo de projeto

Isso é útil para criar o "commit inicial" em um novo projeto usando outro repositório como modelo / arquétipo / semente / esqueleto. Por exemplo:

cd my-new-project
git init
git fetch --depth=1 -n https://github.com/toolbear/panda.git
git reset --hard $(git commit-tree FETCH_HEAD^{tree} -m "initial commit")

Isso evita adicionar o repositório de modelo como um controle remoto ( originou não) e recolhe o histórico do repositório de modelo no seu commit inicial.

Se tudo o que você deseja fazer é compactar todos os seus commit até o commit raiz, então enquanto

git rebase --interactive --root

pode funcionar, é impraticável para um grande número de confirmações (por exemplo, centenas de confirmações), porque a operação de rebase provavelmente será executada muito lentamente para gerar a lista de confirmação do editor de rebase interativo, bem como executar a rebase.

Aqui estão duas soluções mais rápidas e eficientes quando você está esmagando um grande número de confirmações:

Solução alternativa nº 1: filiais órfãs

Você pode simplesmente criar um novo ramo órfão na ponta (ou seja, o commit mais recente) do seu ramo atual. Esse ramo órfão forma o commit raiz inicial de uma árvore de histórico de commit totalmente nova e separada, que é efetivamente equivalente a esmagar todos os seus commit:

git checkout --orphan new-master master
git commit -m "Enter commit message for your new initial commit"

# Overwrite the old master branch reference with the new one
git branch -M new-master master

Documentação:

• Página de manual do git-checkout (1) .

Solução alternativa nº 2: redefinição suave

Outra solução eficiente é simplesmente usar uma redefinição mista ou suave para o commit raiz <root>:

git branch beforeReset

git reset --soft <root>
git commit --amend

# Verify that the new amended root is no different
# from the previous branch state
git diff beforeReset

Documentação:

• Manual do git-reset (1) .

echo "message" | git commit-tree HEAD^{tree}

Isso criará um commit órfão com a árvore do HEAD e produzirá seu nome (SHA-1) no stdout. Em seguida, basta redefinir sua filial lá.

git reset SHA-1

Eis como acabei fazendo isso, caso funcione para outra pessoa:

Lembre-se de que sempre existe o risco de fazer coisas assim, e nunca é uma má idéia criar uma ramificação salva antes de iniciar.

Comece registrando

git log --oneline

Role para confirmar primeiro, copie SHA

git reset --soft <#sha#>

Substitua <#sha#>com o SHA copiado do log

git status

Verifique se tudo está verde, caso contrário, execute git add -A

git commit --amend

Alterar todas as alterações atuais no primeiro commit atual

Agora force o push deste ramo e ele substituirá o que está lá.

Eu li algo sobre o uso de enxertos, mas nunca investiguei muito.

De qualquer forma, você pode esmagar os últimos 2 commits manualmente com algo como isto:

git reset HEAD~1
git add -A
git commit --amend

A maneira mais fácil é usar o comando 'encanamento' update-ref para excluir a ramificação atual.

Você não pode usar git branch -D , pois possui uma válvula de segurança para impedir a exclusão da ramificação atual.

Isso coloca você de volta ao estado 'commit inicial', onde você pode começar com um commit inicial novo.

git update-ref -d refs/heads/master
git commit -m "New initial commit"

Primeiro, junte todos os seus commits em um único commit usando git rebase --interactive. Agora você tem dois commits para esmagar. Para fazer isso, leia qualquer um dos

• Como combinar os dois primeiros commits de um repositório Git?
• git: como esmagar os dois primeiros commits?

Em uma linha de 6 palavras

git checkout --orphan new_root_branch  &&  git commit

criar um backup

git branch backup

redefinir para confirmação especificada

git reset --soft <#root>

depois adicione todos os arquivos ao teste

git add .

confirmar sem atualizar a mensagem

git commit --amend --no-edit

empurrar novo ramo com squashed compromete-se a repo

git push -f

Para esmagar usando enxertos

Adicione um arquivo .git/info/grafts, coloque lá o hash de confirmação que você deseja que seja seu root

git log agora começará a partir desse commit

Para torná-lo 'real' executado git filter-branch

Esta resposta é aprimorada em algumas das opções acima (vote-as), assumindo que, além de criar o único commit (sem pais sem histórico), você também deseja manter todos os dados de commit desse commit:

• Autor (nome e email)
• Data de criação
• Commiter (nome e email)
• Data de confirmação
• Confirmar mensagem de log

É claro que o commit-SHA do novo / único commit será alterado, pois representa um novo (não) histórico, tornando-se um commit sem pai / root.

Isso pode ser feito lendo git loge configurando algumas variáveis ​​para git commit-tree. Supondo que você deseja criar uma única confirmação masterem uma nova ramificação one-commit, mantendo os dados de confirmação acima:

git checkout -b one-commit master ## create new branch to reset
git reset --hard \
$(eval "$(git log master -n1 --format='\
COMMIT_MESSAGE="%B" \
GIT_AUTHOR_NAME="%an" \
GIT_AUTHOR_EMAIL="%ae" \
GIT_AUTHOR_DATE="%ad" \
GIT_COMMITTER_NAME="%cn" \
GIT_COMMITTER_EMAIL="%ce" \
GIT_COMMITTER_DATE="%cd"')" 'git commit-tree master^{tree} <<COMMITMESSAGE
$COMMIT_MESSAGE
COMMITMESSAGE
')

Para fazer isso, você pode redefinir seu repositório git local para a primeira hashtag de confirmação, para que todas as suas alterações após essa confirmação sejam desassistidas, e você pode confirmar com a opção --amend.

git reset your-first-commit-hashtag
git add .
git commit --amend

E edite o primeiro nome de confirmação, se necessário, e salve o arquivo.

Para mim, funcionou assim: eu tinha 4 confirmações no total e usei o rebase interativo:

git rebase -i HEAD~3

O primeiro commit permanece e eu fiz 3 commit mais recentes.

Caso você esteja preso no editor que aparece a seguir, verá algo como:

pick fda59df commit 1
pick x536897 commit 2
pick c01a668 commit 3

Você precisa primeiro confirmar e esmagar os outros. O que você deve ter é:

pick fda59df commit 1
squash x536897 commit 2
squash c01a668 commit 3

Para isso, use a tecla INSERT para alterar o modo 'inserir' e 'editar'.

Para salvar e sair do editor, use :wq. Se o cursor estiver entre essas linhas de confirmação ou em outro lugar, pressione ESC e tente novamente.

Como resultado, tive dois commits: o primeiro que permaneceu e o segundo com a mensagem "Esta é uma combinação de 3 commits".

Verifique os detalhes aqui: https://makandracards.com/makandra/527-squash-several-git-commits-into-a-single-commit

Eu costumo fazer assim:

• Verifique se tudo está confirmado e anote o último ID de confirmação, caso algo dê errado, ou crie uma ramificação separada como backup.

• Execute git reset --soft `git rev-list --max-parents=0 --abbrev-commit HEAD`para redefinir sua cabeça para o primeiro commit, mas deixe seu índice inalterado. Todas as alterações desde o primeiro commit agora parecerão prontas para serem confirmadas.

• Execute git commit --amend -m "initial commit"para alterar seu commit no primeiro commit e altere a mensagem de commit ou, se desejar manter a mensagem de commit existente, você poderá executargit commit --amend --no-edit

• Corra git push -fpara forçar a pressionar suas alterações