Recientemente bifurqué un proyecto y apliqué varias correcciones. Luego creé una solicitud de extracción que luego fue aceptada.

Unos días después, otro contribuyente hizo otro cambio. Entonces mi tenedor no contiene ese cambio.

¿Cómo puedo obtener ese cambio en mi tenedor? ¿Debo eliminar y volver a crear mi bifurcación cuando tenga que realizar más cambios? ¿O hay un botón de actualización?

En su clon local de su repositorio bifurcado, puede agregar el repositorio original de GitHub como "remoto". (Los "controles remotos" son como apodos para las URL de los repositorios; origines uno, por ejemplo). Luego, puede buscar todas las ramas de ese repositorio ascendente y volver a redactar su trabajo para continuar trabajando en la versión ascendente. En términos de comandos que podrían verse así:

# 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

Si no desea reescribir el historial de su rama maestra (por ejemplo, porque otras personas pueden haberlo clonado), debe reemplazar el último comando con git merge upstream/master. Sin embargo, para realizar más solicitudes de extracción que sean lo más limpias posible, probablemente sea mejor volver a redactar.

Si ha reubicado su rama, upstream/masteres posible que deba forzar el empuje para empujarlo a su propio repositorio bifurcado en GitHub. Harías eso con:

git push -f origin master

Solo necesita usar -fla primera vez después de haber reescrito.

A partir de mayo de 2014, es posible actualizar una bifurcación directamente desde GitHub. Esto todavía funciona a partir de septiembre de 2017, PERO conducirá a un historial de confirmación sucio.

1. Abre tu tenedor en GitHub.
2. Haga clic en Pull Requests.
3. Haga clic en New Pull Request. De forma predeterminada, GitHub comparará el original con su bifurcación, y no debería haber nada para comparar si no realizó ningún cambio.
4. Haga clic switching the basesi ve ese enlace. De lo contrario, configure manualmente el base forkmenú desplegable en su bifurcación y el head forken la parte superior. Ahora GitHub comparará su bifurcación con el original, y debería ver todos los últimos cambios.
5. Create pull requesty asigne un nombre predecible a su solicitud de extracción (por ejemplo, Update from original).
6. Desplázate hacia abajo Merge pull request, pero aún no hagas clic en nada.

Ahora tiene tres opciones, pero cada una conducirá a un historial de confirmación menos que limpio.

1. El valor predeterminado creará una confirmación de fusión fea.
2. Si hace clic en el menú desplegable y elige "Aplastar y fusionar", todas las confirmaciones que intervienen se agruparán en una. Esto es a menudo algo que no quieres.
3. Si hace clic Rebase and merge, todas las confirmaciones se realizarán "con" usted, los RP originales se vincularán a su RP y se mostrará GitHub This branch is X commits ahead, Y commits behind <original fork>.

Entonces, sí, puede mantener actualizado su repositorio con su flujo ascendente utilizando la interfaz de usuario web de GitHub, pero hacerlo dañará su historial de confirmación. En cambio, quédese con la línea de comando : es fácil.

Aquí está el documento oficial de GitHub sobre Sincronizar una bifurcación :

Sincronizando un tenedor

La puesta en marcha

Antes de poder sincronizar, debe agregar un control remoto que apunte al repositorio ascendente. Es posible que haya hecho esto cuando originalmente se bifurcó.

Sugerencia: la sincronización de su bifurcación solo actualiza su copia local del repositorio; no actualiza su repositorio en 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)

Sincronización

Hay dos pasos necesarios para sincronizar su repositorio con el flujo ascendente: primero debe buscar desde el control remoto, luego debe fusionar la rama deseada en su rama local.

Atractivo

La recuperación desde el repositorio remoto traerá sus ramas y sus respectivas confirmaciones. Estos se almacenan en su repositorio local bajo ramas especiales.

$ 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

Ahora tenemos la rama maestra del flujo ascendente almacenada en una rama local, flujo ascendente / maestro

$ 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

Fusionando

Ahora que hemos obtenido el repositorio ascendente, queremos fusionar sus cambios en nuestra rama local. Esto sincronizará esa rama con el flujo ascendente, sin perder nuestros cambios locales.

$ 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

Si su sucursal local no tenía ninguna confirmación única, git realizará un "avance rápido":

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

Sugerencia: si desea actualizar su repositorio en GitHub, siga las instrucciones aquí

Muchas respuestas terminan moviendo su fork una confirmación por delante del repositorio principal. Esta respuesta resume los pasos encontrados aquí que moverán su bifurcación al mismo commit que el padre .

1. Cambie el directorio a su repositorio local.

   • Cambie a la rama maestra si no está git checkout master

2. Agregue el padre como un repositorio remoto, git remote add upstream <repo-location>

3. Problema git fetch upstream

4. Problema git rebase upstream/master

   • En esta etapa, verifica que confirma lo que se fusionará escribiendo git status

5. Problema git push origin master

Para obtener más información sobre estos comandos, consulte el paso 3 .

Si, como yo, nunca comprometes nada directamente para dominar , lo que realmente deberías hacer, puedes hacer lo siguiente.

Desde el clon local de su bifurcación, cree su control remoto ascendente. Solo necesitas hacer eso una vez:

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

Luego, cuando quiera ponerse al día con la rama maestra del repositorio ascendente, debe:

git checkout master
git pull upstream master

Asumiendo que nunca has cometido nada sobre el maestro, ya deberías haberlo hecho. Ahora puede empujar a su maestro local a su bifurcación remota GitHub de origen. También puede cambiar la base de su rama de desarrollo en su maestro local ahora actualizado.

Después de la configuración inicial ascendente y la comprobación principal, todo lo que necesita hacer es ejecutar el siguiente comando para sincronizar su maestro con el ascendente: git pull upstream master .

Prólogo: su bifurcación es el "origen" y el repositorio desde el que se bifurcó es el "ascendente".

Supongamos que ya clonaste tu fork en tu computadora con un comando como este:

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

Si eso se da, entonces debe continuar en este orden:

1. Agregue el "flujo ascendente" a su repositorio clonado ("origen"):

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

2. Obtenga los commits (y las ramas) del "upstream":

   git fetch upstream
   

3. Cambie a la rama "maestra" de su bifurcación ("origen"):

   git checkout master
   

4. Guarda los cambios de tu rama "maestra":

   git stash
   

5. Combine los cambios de la rama "maestra" de la "corriente arriba" en su rama "maestra" de su "origen":

   git merge upstream/master
   

6. Resolver conflictos de fusión, si los hay, y confirmar su fusión.

   git commit -am "Merged from upstream"
   

7. Empuja los cambios a tu tenedor

   git push
   

8. Recupere sus cambios escondidos (si los hay)

   git stash pop
   

9. Ya terminaste! ¡Felicidades!

GitHub también proporciona instrucciones para este tema: Sincronizar una bifurcación

Desde noviembre de 2013, se ha abierto una solicitud de función no oficial con GitHub para pedirles que agreguen un método muy simple e intuitivo para mantener una bifurcación local sincronizada con el flujo ascendente:

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

Nota: Dado que la solicitud de función no es oficial, también es aconsejable ponerse support@github.comen contacto para agregar su soporte para que se implemente una función como esta. La solicitud de características no oficiales anterior podría usarse como evidencia del monto de interés en esta implementación.

A la fecha de esta respuesta, GitHub no tiene ( o debo decir que ya no? ) Esta característica en la interfaz web. Sin embargo, puede solicitar support@github.comagregar su voto para eso.

Mientras tanto, el usuario de GitHub bardiharborow ha creado una herramienta para hacer precisamente esto: https://upriver.github.io/

La fuente está aquí: https://github.com/upriver/upriver.github.io

Si está utilizando GitHub para Windows o Mac, ahora tienen una función de un clic para actualizar las horquillas:

1. Seleccione el repositorio en la interfaz de usuario.
2. Haga clic en el botón "Actualizar desde usuario / sucursal" en la parte superior.

En realidad, es posible crear una bifurcación en su bifurcación a partir de cualquier confirmación del flujo ascendente en el navegador:

• Abierto https://github.com/<repo>/commits/<hash>, donde el repositorio es su bifurcación, y el hash es el hash completo de commit que puede encontrar en la interfaz web ascendente. Por ejemplo, puedo abrir https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 , que apunta al linux mastermomento de la escritura.
• Haga clic en el botón "Árbol: ....".
• Escriba el nombre de la nueva sucursal y presione Enter

Luego puede buscar esa rama en su clon local, y no tendrá que enviar todos esos datos de nuevo a GitHub cuando inserte ediciones encima de esa confirmación. O use la interfaz web para cambiar algo en esa rama.

Cómo funciona (es una suposición, no sé exactamente cómo lo hace GitHub): los tenedores comparten el almacenamiento de objetos y usan espacios de nombres para separar las referencias de los usuarios. Por lo tanto, puede acceder a todas las confirmaciones a través de su bifurcación, incluso si no existían en el momento de la bifurcación.

Sigue los pasos a continuación. Los probé y me ayudó.

Pago a su sucursal

Sintaxis: git branch yourDevelopmentBranch
Ejemplo: git checkout master

Tire de la rama del repositorio de origen para obtener el último código

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

Actualizo mis repositorios bifurcados con esta línea:

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

Use esto si no desea agregar otro punto final remoto a su proyecto, como otras soluciones publicadas aquí.

Como complemento a esta respuesta, estaba buscando una manera de actualizar todas las ramas remotas de mi repositorio clonado ( origen ) desde las ramas aguas arriba de una sola vez. Así es como lo hice.

Esto supone que ya ha configurado un apuntamiento remoto ascendente en el repositorio de origen (desde donde se bifurcó el origen ) y lo ha sincronizado git fetch upstream.

Entonces corre:

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

La primera parte de este comando enumera todas las cabezas en el repositorio remoto ascendente y elimina el SHA-1 seguido del refs/heads/prefijo de nombre de rama.

Luego, para cada una de estas ramas, empuja la copia local de la rama de seguimiento remoto ascendente ( refs/remotes/upstream/<branch>en el lado local) directamente a la rama remota en el origen ( refs/heads/<branch>en el lado remoto).

Cualquiera de estos comandos de sincronización de bifurcación puede fallar por una de dos razones: o la bifurcación ascendente se ha reescrito o usted ha enviado confirmaciones en esa bifurcación a su bifurcación. En el primer caso en el que no ha comprometido nada con la bifurcación en su bifurcación, es seguro presionar con fuerza (agregue el interruptor -f ; es decir, git push -fen el comando anterior). En el otro caso, esto es normal ya que la bifurcación de su bifurcación se ha desviado y no puede esperar que el comando de sincronización funcione hasta que sus confirmaciones se hayan fusionado nuevamente en sentido ascendente .

La aplicación "Pull" es una solución automática de configuración y olvido. Sincronizará la rama predeterminada de su bifurcación con el repositorio ascendente.

Visite la URL, haga clic en el botón verde "Instalar" y seleccione los repositorios donde desea habilitar la sincronización automática.

La rama se actualiza una vez por hora directamente en GitHub, en su máquina local necesita extraer la rama maestra para asegurarse de que su copia local esté sincronizada.

Android Studio ahora ha aprendido a trabajar con repositorios de fork de GitHub (ni siquiera tiene que agregar un repositorio remoto "ascendente" por comando de consola).

Abrir menú VCS → Git

Y preste atención a los dos últimos elementos del menú emergente:

• Rebase mi tenedor GitHub

• Crear solicitud de extracción

Pruébalos. Utilizo el primero para sincronizar mi repositorio local. De todos modos, las ramas del repositorio remoto principal ("upstream") estarán accesibles en Android Studio después de hacer clic en "Rebase my GitHub fork", y podrá operar con ellas fácilmente.

(Uso Android Studio 3.0 con los complementos "Integración Git" y "GitHub").

Cuando haya clonado su repositorio bifurcado, vaya a la ruta del directorio donde reside su clon y las pocas líneas en su Terminal de Git Bash.

$ 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

Y ahí estás listo para ir. Todos los cambios actualizados en el repositorio principal se incluirán en el repositorio de fork.

El comando "buscar" es indispensable para mantenerse actualizado en un proyecto: solo cuando realice una "búsqueda de git" se le informará sobre los cambios que sus colegas introdujeron en el servidor remoto.

Todavía puede visitar aquí para más consultas.

Si configura su upstream. Consulte con git remote -v, entonces esto será suficiente.

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

Eso depende del tamaño de su repositorio y de cómo lo bifurcó.

Si es un repositorio bastante grande, es posible que haya querido administrarlo de una manera especial (por ejemplo, el historial de descartes). Básicamente, puede obtener diferencias entre las versiones actuales y ascendentes, confirmarlas y luego volver a elegir el maestro.

Intenta leer este . Describe cómo manejar grandes repositorios de Git y cómo actualizarlos con los últimos cambios.

Me gustaría agregar a la respuesta de @ krlmlr .

Inicialmente, el repositorio ha bifurcado una rama llamada: master. Si está trabajando en una nueva característica o una solución, generalmente crearía una nueva rama featurey haría los cambios.

Si desea que el repositorio bifurcado esté sincronizado con el repositorio principal, puede configurar un archivo de configuración ( pull.yml) para la aplicación Pull ( en la rama de funciones ), de esta manera:

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

Esto mantiene masteractualizada la rama del repositorio bifurcado con el repositorio principal. Mantiene la featurerama del repositorio bifurcado actualizada a través de la mastersucursal del repositorio bifurcado fusionando la misma. Esto supone que la featurerama es la rama predeterminada que contiene el archivo de configuración.

Aquí mergemethodshay dos en juego, uno es el hardresetque ayuda a forzar los cambios de sincronización en la masterrama del repositorio bifurcado con el repositorio principal y el otro método es merge. Este método se utiliza para fusionar los cambios realizados por usted en la featurerama y los cambios realizados debido a la sincronización forzada en la masterrama. En caso de conflicto de fusión, la aplicación de extracción le permitirá elegir el próximo curso de acción durante la solicitud de extracción.

Puede leer sobre configuraciones básicas y avanzadas y varias mergemethods aquí .

Actualmente estoy usando esta configuración en mi repositorio bifurcado aquí para asegurarme de que una mejora solicitada aquí se mantenga actualizada.

Hay dos cosas principales para mantener un repositorio bifurcado siempre actualizado para siempre.

1. Cree las ramas desde la bifurcación maestra y realice los cambios allí .

Entonces, cuando se acepte su solicitud de extracción, puede eliminar de forma segura la sucursal, ya que su código contribuido estará en vivo en su maestro de su repositorio bifurcado cuando lo actualice con el flujo ascendente. Con esto, su maestro siempre estará en condiciones de limpieza para crear una nueva rama para hacer otro cambio.

2. Cree un trabajo programado para que el maestro de horquillas se actualice automáticamente .

Esto se puede hacer con cron . Aquí hay un código de ejemplo si lo hace en Linux.

$ crontab -e

ponga este código en crontab filepara ejecutar el trabajo por hora.

0 * * * * sh ~/cron.sh

luego cree el cron.sharchivo de script y una interacción git con ssh-agent y / o espere de la siguiente manera

#!/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 su repositorio bifurcado. De vez en cuando siempre mostrará esta notificación:

Esta rama es incluso con <upstream>: maestro .

Use estos comandos (en caso de suerte)

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