Recentemente, bifurquei um projeto e apliquei várias correções. Em seguida, criei uma solicitação de recebimento que foi aceita.

Alguns dias depois, outra alteração foi feita por outro colaborador. Portanto, meu garfo não contém essa alteração.

Como posso colocar essa alteração no meu garfo? Preciso excluir e recriar meu fork quando tiver mais alterações para contribuir? Ou existe um botão de atualização?

No seu clone local do seu repositório bifurcado, você pode adicionar o repositório original do GitHub como um "remoto". ("Remotes" são como apelidos para os URLs dos repositórios - originé um, por exemplo.) Em seguida, você pode buscar todas as ramificações desse repositório upstream e refazer o trabalho para continuar trabalhando na versão upstream. Em termos de comandos que podem se parecer com:

# Add the remote, call it "upstream":

git remote add upstream https://github.com/whoever/whatever.git

# Fetch all the branches of that remote into remote-tracking branches,
# such as upstream/master:

git fetch upstream

# Make sure that you're on your master branch:

git checkout master

# Rewrite your master branch so that any commits of yours that
# aren't already in upstream/master are replayed on top of that
# other branch:

git rebase upstream/master

Se você não deseja reescrever o histórico de sua ramificação principal (por exemplo, porque outras pessoas podem ter clonado), substitua o último comando por git merge upstream/master. No entanto, para fazer solicitações de recebimento mais limpas possível, provavelmente é melhor refazer a recuperação.

Se você reformulou sua ramificação, upstream/masterpode ser necessário forçar o envio para enviá-lo para o seu próprio repositório bifurcado no GitHub. Você faria isso com:

git push -f origin master

Você só precisa usar -fa primeira vez depois de ter refeito.

A partir de maio de 2014, é possível atualizar um fork diretamente do GitHub. Isso ainda funciona em setembro de 2017, mas levará a um histórico de confirmação sujo.

1. Abra seu garfo no GitHub.
2. Clique em Pull Requests.
3. Clique em New Pull Request. Por padrão, o GitHub irá comparar o original com o seu fork, e não deve haver nada para comparar se você não tiver feito alterações.
4. Clique switching the basese você vir esse link. Caso contrário, defina manualmente a caixa base forksuspensa para o garfo e head forkpara a montante. Agora o GitHub irá comparar seu fork com o original, e você deverá ver todas as alterações mais recentes.
5. Create pull requeste atribua um nome previsível à sua solicitação de recebimento (por exemplo, Update from original).
6. Role para baixo até Merge pull request, mas não clique em nada ainda.

Agora você tem três opções, mas cada uma delas levará a um histórico de confirmação menos que limpo.

1. O padrão criará uma confirmação de mesclagem feia.
2. Se você clicar no menu suspenso e escolher "Squash e mesclagem", todas as confirmações intermediárias serão compactadas em uma. Isso geralmente é algo que você não deseja.
3. Se você clicar em Rebase and merge, todas as confirmações serão feitas "com" você, os PRs originais serão vinculados ao seu PR e o GitHub será exibido This branch is X commits ahead, Y commits behind <original fork>.

Portanto, sim, você pode manter seu repo atualizado com o upstream usando a interface da web do GitHub, mas isso prejudicará seu histórico de consolidação. Atenha-se à linha de comando - é fácil.

Aqui está o documento oficial do GitHub sobre Sincronizando um fork :

Sincronizando um garfo

A configuração

Antes de sincronizar, você precisa adicionar um controle remoto que aponte para o repositório upstream. Você pode ter feito isso quando originalmente bifurcou.

Dica: Sincronizar seu fork apenas atualiza sua cópia local do repositório; ele não atualiza seu repositório no GitHub.

$ git remote -v
# List the current remotes
origin  https://github.com/user/repo.git (fetch)
origin  https://github.com/user/repo.git (push)

$ git remote add upstream https://github.com/otheruser/repo.git
# Set a new remote

$ git remote -v
# Verify new remote
origin    https://github.com/user/repo.git (fetch)
origin    https://github.com/user/repo.git (push)
upstream  https://github.com/otheruser/repo.git (fetch)
upstream  https://github.com/otheruser/repo.git (push)

A sincronizar

Há duas etapas necessárias para sincronizar seu repositório com o upstream: primeiro você deve buscar no controle remoto e depois mesclar o ramo desejado no ramo local.

Buscando

A busca no repositório remoto trará suas ramificações e seus respectivos commits. Eles são armazenados no seu repositório local em ramificações especiais.

$ git fetch upstream
# Grab the upstream remote's branches
remote: Counting objects: 75, done.
remote: Compressing objects: 100% (53/53), done.
remote: Total 62 (delta 27), reused 44 (delta 9)
Unpacking objects: 100% (62/62), done.
From https://github.com/otheruser/repo
 * [new branch]      master     -> upstream/master

Agora temos a ramificação principal do upstream armazenada em uma ramificação local, upstream / master

$ git branch -va
# List all local and remote-tracking branches
* master                  a422352 My local commit
  remotes/origin/HEAD     -> origin/master
  remotes/origin/master   a422352 My local commit
  remotes/upstream/master 5fdff0f Some upstream commit

Mesclando

Agora que buscamos o repositório upstream, queremos mesclar suas alterações em nossa filial local. Isso sincronizará esse ramo com o upstream, sem perder nossas alterações locais.

$ git checkout master
# Check out our local master branch
Switched to branch 'master'

$ git merge upstream/master
# Merge upstream's master into our own
Updating a422352..5fdff0f
Fast-forward
 README                    |    9 -------
 README.md                 |    7 ++++++
 2 files changed, 7 insertions(+), 9 deletions(-)
 delete mode 100644 README
 create mode 100644 README.md

Se sua ramificação local não tiver nenhum commit exclusivo, o git executará um "avanço rápido":

$ git merge upstream/master
Updating 34e91da..16c56ad
Fast-forward
 README.md                 |    5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

Dica: Se você deseja atualizar seu repositório no GitHub, siga as instruções aqui

Muitas respostas acabam movendo seu fork um commit à frente do repositório pai. Esta resposta resume as etapas encontradas aqui, que moverão seu fork para o mesmo commit que o pai .

1. Mude o diretório para o seu repositório local.

   • Mude para o ramo principal se não estiver git checkout master

2. Adicione o pai como um repositório remoto, git remote add upstream <repo-location>

3. Questão git fetch upstream

4. Questão git rebase upstream/master

   • Nesta fase, você verifica se confirma o que será mesclado digitando git status

5. Questão git push origin master

Para mais informações sobre estes comandos, consulte o passo 3 .

Se, como eu, você nunca comprometer nada diretamente com o mestre , o que realmente deveria, pode fazer o seguinte.

No clone local do seu fork, crie seu controle remoto upstream. Você só precisa fazer isso uma vez:

git remote add upstream https://github.com/whoever/whatever.git

Então, sempre que você quiser acompanhar a ramificação principal do repositório upstream, precisará:

git checkout master
git pull upstream master

Supondo que você nunca tenha cometido nada a seu respeito, você já deve ter feito isso. Agora você pode enviar seu mestre local para o seu fork remoto do GitHub de origem. Você também pode refazer sua ramificação de desenvolvimento em seu mestre local agora atualizado.

Após a configuração inicial do upstream e a verificação do master, tudo o que você precisa fazer é executar o seguinte comando para sincronizar seu master com o upstream: git pull upstream master .

Prefácio: sua bifurcação é a "origem" e o repositório de onde você partiu é o "upstream".

Vamos supor que você já clonou seu fork no computador com um comando como este:

git clone git@github.com:your_name/project_name.git
cd project_name

Se isso for fornecido, você precisará continuar nesta ordem:

1. Adicione o "upstream" ao seu repositório clonado ("origem"):

   git remote add upstream git@github.com:original_author/project_name.git
   

2. Busque as confirmações (e ramificações) no "upstream":

   git fetch upstream
   

3. Mude para o ramo "principal" do seu fork ("origem"):

   git checkout master
   

4. Esconda as alterações do seu ramo "mestre":

   git stash
   

5. Mesclar as alterações do ramo "mestre" do "upstream" no ramo "mestre" da sua "origem":

   git merge upstream/master
   

6. Resolver conflitos de mesclagem, se houver, e confirmar sua mesclagem

   git commit -am "Merged from upstream"
   

7. Coloque as alterações no garfo

   git push
   

8. Volte suas alterações ocultas (se houver)

   git stash pop
   

9. Você Terminou! Parabéns!

O GitHub também fornece instruções para este tópico: Sincronizando um fork

Desde novembro de 2013, foi aberto um pedido não oficial de recursos com o GitHub para solicitar que eles adicionassem um método muito simples e intuitivo para manter uma bifurcação local sincronizada com o upstream:

https://github.com/isaacs/github/issues/121

Nota: Como a solicitação de recurso não é oficial, também é recomendável entrar support@github.comem contato para adicionar seu suporte para que um recurso como esse seja implementado. A solicitação não oficial de recurso acima pode ser usada como evidência da quantidade de interesse nisso sendo implementada.

Na data desta resposta, o GitHub não possui ( ou devo dizer não? ) Esse recurso na interface da web. Você pode, no entanto, pedir support@github.compara adicionar seu voto para isso.

Enquanto isso, o usuário do GitHub bardiharborow criou uma ferramenta para fazer exatamente isso: https://upriver.github.io/

A fonte está aqui: https://github.com/upriver/upriver.github.io

Se você estiver usando o GitHub para Windows ou Mac, agora eles têm um recurso de um clique para atualizar os garfos:

1. Selecione o repositório na interface do usuário.
2. Clique no botão "Atualizar do usuário / filial" na parte superior.

Na verdade, é possível criar uma ramificação no seu fork a partir de qualquer confirmação do upstream no navegador:

• Abra https://github.com/<repo>/commits/<hash>, em que o repositório é sua bifurcação e o hash é um hash de confirmação completo, que você pode encontrar na interface da Web upstream. Por exemplo, eu posso abrir https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 , que aponta linux mastercomo hora da escrita.
• Clique no botão "Árvore: ....".
• Digite o nome da nova ramificação e pressione Enter

Você pode buscar esse ramo no seu clone local e não precisará enviar todos esses dados de volta ao GitHub quando enviar edições por cima desse commit. Ou use a interface da web para alterar algo nesse ramo.

Como funciona (é um palpite, não sei exatamente como o GitHub faz isso): os garfos compartilham o armazenamento de objetos e usam espaços de nome para separar as referências dos usuários. Assim, você pode acessar todos os commits através do seu fork, mesmo que eles não existissem no momento da bifurcação.

Siga os passos abaixo. Eu tentei e isso me ajudou.

Finalizar compra na sua filial

Sintaxe: git branch yourDevelopmentBranch
Exemplo: git checkout master

Puxe a ramificação do repositório de origem para obter o código mais recente

Sintaxe: git pull https://github.com/tastejs/awesome-app-ideas master
Exemplo: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME

Eu atualizo meus repositórios bifurcados com esta linha:

git pull https://github.com/forkuser/forkedrepo.git branch

Use isso se não desejar adicionar outro ponto de extremidade remoto ao seu projeto, como outras soluções postadas aqui.

Como complemento para esta resposta, eu estava procurando uma maneira de atualizar todos os ramos remotos do meu repositório clonado ( origem ) a partir dos ramos upstream de uma só vez. Foi assim que eu fiz.

Isso pressupõe que você já configurou um apontador remoto upstream no repositório de origem (de onde a origem foi bifurcada) e o sincronizou git fetch upstream.

Então corra:

for branch in $(git ls-remote --heads upstream|sed 's#^.*refs/heads/##'); do git push origin refs/remotes/upstream/$branch:refs/heads/$branch; done

A primeira parte deste comando lista todas as cabeças no repositório remoto upstream e remove o SHA-1 seguido pelo refs/heads/prefixo do nome da ramificação.

Em seguida, para cada uma dessas ramificações, ele envia a cópia local da ramificação de rastreamento remoto upstream ( refs/remotes/upstream/<branch>no lado local) diretamente para a ramificação remota na origem ( refs/heads/<branch>no lado remoto).

Qualquer um desses comandos de sincronização de ramificação pode falhar por um de dois motivos: a ramificação upstream foi reescrita ou você enviou as confirmações nessa ramificação para o seu fork. No primeiro caso em que você não comprometeu nada com o ramo no garfo, é seguro pressionar com força (adicione a opção -f ; ou seja, git push -fno comando acima). No outro caso, isso é normal, pois sua ramificação de bifurcação divergiu e você não pode esperar que o comando sync funcione até que suas confirmações tenham sido mescladas novamente no upstream .

O aplicativo "Pull" é uma solução de configuração e esquecimento automática. Ele sincronizará a ramificação padrão do seu fork com o repositório upstream.

Visite o URL, clique no botão verde "Instalar" e selecione os repositórios em que deseja ativar a sincronização automática.

A ramificação é atualizada uma vez por hora diretamente no GitHub, na sua máquina local, você precisa puxar a ramificação principal para garantir que sua cópia local esteja sincronizada.

O Android Studio agora aprendeu a trabalhar com os repositórios de bifurcações do GitHub (você nem precisa adicionar repositório remoto "upstream" pelo comando do console).

Abrir menu VCS → Git

E preste atenção nos dois últimos itens do menu pop-up:

• Rebase my fork GitHub

• Criar solicitação de recebimento

Tente eles. Eu uso o primeiro para sincronizar meu repositório local. De qualquer forma, as ramificações do repositório remoto pai ("upstream") ficarão acessíveis no Android Studio depois que você clicar em "Rebase my fork do GitHub" e poderá operar com elas facilmente.

(Eu uso o Android Studio 3.0 com os plugins "integração Git" e "GitHub".)

Quando você clonou seu repositório bifurcado, vá para o caminho do diretório em que seu clone reside e as poucas linhas no seu Git Bash Terminal.

$ cd project-name

$ git remote add upstream https://github.com/user-name/project-name.git
 # Adding the upstream -> the main repo with which you wanna sync

$ git remote -v # you will see the upstream here 

$ git checkout master # see if you are already on master branch

$ git fetch upstream

E aí você está pronto para ir. Todas as alterações atualizadas no repositório principal serão enviadas para o repositório do fork.

O comando "buscar" é indispensável para manter-se atualizado em um projeto: somente ao executar uma "busca por git" você será informado sobre as alterações que seus colegas fizeram no servidor remoto.

Você ainda pode visitar aqui para mais consultas

Se você configurar seu upstream. Verifique com git remote -v, então isso será suficiente.

git fetch upstream
git checkout master
git merge --no-edit upstream/master
git push

Isso depende do tamanho do seu repositório e de como você o bifurcou.

Se é um repositório bastante grande, você pode querer gerenciá-lo de uma maneira especial (por exemplo, histórico de descargas). Basicamente, você pode obter diferenças entre as versões atual e upstream, enviá-las e depois voltar ao master.

Tente ler este . Ele descreve como lidar com grandes repositórios Git e como atualizá-los com as alterações mais recentes.

Gostaria de adicionar uma resposta à @ krlmlr .

Inicialmente, o repositório bifurcada tem uma filial chamada: master. Se você estiver trabalhando em um novo recurso ou correção, geralmente criará uma nova ramificação featuree fará as alterações.

Se você deseja que o repositório bifurcado esteja sincronizado com o repositório pai, você pode configurar um arquivo de configuração ( pull.yml) para o aplicativo Pull ( na ramificação do recurso ), assim:

version: "1"
rules:
  - base: feature
    upstream: master
    mergeMethod: merge
  - base: master
    upstream: parent_repo:master
    mergeMethod: hardreset

Isso mantém a masterramificação do repositório bifurcado atualizada com o repositório pai. Ele mantém a featureramificação do repositório bifurcado atualizada por meio da masterramificação do repositório bifurcado, mesclando o mesmo. Isso pressupõe que a featureramificação é a ramificação padrão que contém o arquivo de configuração.

Aqui mergemethodsestão dois em jogo, um é o hardresetque ajuda a forçar alterações de sincronização na masterramificação do repositório bifurcado com o repositório pai e o outro método merge. Este método é usado para mesclar as alterações feitas por você na featureramificação e as alterações causadas pela força da sincronização na masterramificação. Em caso de conflito de mesclagem, o aplicativo pull permitirá que você escolha o próximo curso de ação durante a solicitação de pull.

Você pode ler sobre configurações básicas e avançadas e várias mergemethods aqui .

Atualmente, estou usando essa configuração no meu repositório bifurcado aqui para garantir que um aprimoramento solicitado aqui permaneça atualizado.

Há duas coisas principais em manter um repositório bifurcado sempre atualizado para sempre.

1. Crie as ramificações a partir do mestre da forquilha e faça as alterações lá .

Portanto, quando sua solicitação de recebimento for aceita, você poderá excluir com segurança a ramificação, pois seu código contribuído ficará no mestre de seu repositório bifurcado quando você a atualizar com o upstream. Por isso, seu mestre estará sempre em boas condições para criar uma nova ramificação para fazer outra alteração.

2. Crie um trabalho agendado para o mestre da bifurcação atualizar automaticamente .

Isso pode ser feito com o cron . Aqui está um exemplo de código, se você o faz no linux.

$ crontab -e

coloque esse código em crontab filepara executar o trabalho a cada hora.

0 * * * * sh ~/cron.sh

crie o cron.sharquivo de script e uma interação git com o ssh-agent e / ou espere como abaixo

#!/bin/sh
WORKDIR=/path/to/your/dir   
REPOSITORY=<name of your repo>
MASTER="git@github.com:<username>/$REPOSITORY.git"   
UPSTREAM=git@github.com:<upstream>/<name of the repo>.git  

cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent` && expect ~/.ssh/agent && ssh-add -l
git clone $MASTER && cd $REPOSITORY && git checkout master
git remote add upstream $UPSTREAM && git fetch --prune upstream
if [ `git rev-list HEAD...upstream/master --count` -eq 0 ]
then
    echo "all the same, do nothing"
else
    echo "update exist, do rebase!"
    git reset --hard upstream/master
    git push origin master --force
fi
cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent -k`

Verifique seu repositório bifurcado. Periodicamente, sempre mostrará esta notificação:

Este ramo é igual a <upstream>: master .

Use estes comandos (no caso de sorte)

git remote -v
git pull
git fetch upstream
git checkout master
git merge upstream/master --no-ff
git add .
git commit -m"Sync with upstream repository."
git push -v