¿Cómo actualizo un repository bifurcado de GitHub?

Recientemente bifurqué un proyecto y apliqué varias correcciones. Luego creé una request de extracción que luego se aceptó.

Unos días después, otro contribuyente hizo otro cambio. Entonces mi tenedor no contiene ese cambio … ¿Cómo puedo get ese cambio en mi tenedor?

¿Debo eliminar y volver a crear mi tenedor cuando tenga más cambios para contribuir? ¿O hay un button de actualización?

En su clon local de su repository bifurcado, puede agregar el repository original de GitHub como "remoto". (Los "controles remotos" son como apodos para las direcciones URL de los repositorys, el origin es uno, por ejemplo). Luego, puede search todas las twigs de ese repository en sentido ascendente y volver a establecer la base de su trabajo para continuar trabajando en la versión ascendente. En términos de commands 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 twig maestra (por ejemplo, porque otras personas lo hayan clonado), debe replace el último command con git merge upstream/master . Sin embargo, para realizar más requestes de extracción que estén lo más limpias posible, probablemente sea mejor volver a establecer la base.


Si ha networkingefinido su twig en upstream/master , puede que necesite forzar el push para insertlo en su propio repository bifurcado en GitHub. Lo harías con:

 git push -f origin master 

Solo necesita usar la -f la primera vez después de volver a establecer la base.

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

  1. Abre tu tenedor en GitHub.
  2. Haga clic en Pull Requests .
  3. Haga clic en Nueva request de extracción . Por defecto, GitHub comparará el original con su tenedor, y no debería haber nada para comparar si no hizo ningún cambio.
  4. Haga clic en cambiar la base si ve ese enlace. De lo contrario, configure manualmente la horquilla de la base desplegable en la horquilla y la horquilla en la parte superior. Ahora GitHub comparará tu tenedor con el original, y deberías ver todos los últimos cambios. enter image description here
  5. Cree una request de extracción y asigne un nombre pnetworkingecible a su request de extracción (por ejemplo, Update from original ).
  6. Desplázate hasta Combinar request de extracción , pero no hagas clic en nada todavía.

Ahora tiene tres opciones, pero cada una conducirá a un historial de compromiso less que limpio.

  1. El valor pnetworkingeterminado creará una fea fusión de confirmación.
  2. Si haces clic en el menu desplegable y seleccionas "Squash and merge", todas las confirmaciones intermedias se agruparán en una. Esto es más a menudo algo que no quieres.
  3. Si hace clic en Rebase y fusionar , todas las confirmaciones se realizarán "con" usted, las RR.PP. originales se vincularán a su PR, y GitHub mostrará This branch is X commits ahead, Y commits behind <original fork> .

Así que sí, puedes mantener tu repository actualizado con su upstream utilizando la interfaz de usuario web de GitHub, pero al hacerlo se manchará tu historial de confirmaciones. Manténgase en la línea de command , es fácil.

Aquí está el documento oficial de GitHub sobre Sincronización de un tenedor :

Sincronizando un tenedor

La puesta en marcha

Antes de que pueda sincronizar, necesita agregar un control remoto que apunta al repository aguas arriba. Es posible que haya hecho esto cuando originalmente se bifurcó.

Consejo: Sincronizar tu tenedor solo actualiza tu copy local del repository; no actualiza su repository 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) 

Sincronizando

Se requieren dos pasos para sincronizar su repository con el flujo ascendente: primero debe get desde el control remoto, luego debe fusionar la twig deseada en su sucursal local.

Atractivo

La obtención del repository remoto traerá sus twigs y sus respectivos commits. Estos se almacenan en su repository local bajo twigs 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 twig maestra upstream almacenada en una twig 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 

Fusión

Ahora que hemos obtenido el repository en sentido ascendente, queremos fusionar sus cambios en nuestra sucursal local. Esto pondrá a esa twig en synchronization con la stream 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 tiene commits únicos, en cambio, 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(-) 

Consejo: si quiere actualizar su repository en GitHub, siga las instrucciones aquí

Muchas respuestas terminan moviendo el tenedor, uno se compromete antes que el repository padre. Esta respuesta resume los pasos que se encuentran aquí, que moverán su tenedor al mismo compromiso que el padre .

  1. Cambie el directory a su repository local.

    • Cambia a la twig principal si no eres git checkout master
  2. Agregue el padre como un repository remoto, git remote add upstream <repo-location>

  3. Emitir git fetch upstream
  4. git rebase upstream/master

    • En esta etapa, comtesting que confirma qué se fusionará escribiendo el git status
  5. Problema git push origin master

Para get más información acerca de estos commands, consulte el paso 3 .

Desde noviembre de 2013 se ha abierto una request de function no oficial con GitHub para pedirles que agreguen un método muy simple e intuitivo para mantener un fork local sincronizado con el upstream:

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

Nota: dado que la request de function no es oficial, también es aconsejable ponerse en contacto con support@github.com para agregar su compatibilidad con una característica como esta a implementar. La request de característica no oficial anterior se podría utilizar como evidencia de la cantidad de interés en que esto se implemente.

Prólogo: Tu tenedor es el "origen" y el repository del que has salido es el "ascendente".

Supongamos que ya clonaste tu tenedor en tu computadora con un command como este:

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

Si eso se da, entonces debes continuar en este order:

  1. Agregue el "upstream" a su repository clonado ("origen"):

     git remote add upstream git@github.com:original_author/project_name.git 
  2. Obtenga los commits (y branches) del "upstream":

     git fetch upstream 
  3. Cambie a la twig "maestra" de su tenedor ("origen"):

     git checkout master 
  4. Muestre los cambios de su twig "maestra":

     git stash 
  5. Combina los cambios desde la twig "principal" de "ascendente" en tu twig "maestra" de tu "origen":

     git merge upstream/master 
  6. Resuelva los conflictos de fusión si los hay y comprométase 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. ¡Terminaste! ¡Felicitaciones!

GitHub también proporciona instrucciones para este tema: Sincronización de un tenedor

A partir de la date de esta respuesta, GitHub no tiene (¿ o no decir más? ) Esta function en la interfaz web. Sin embargo, puede pedirle a support@github.com que agregue su voto para eso.

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

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

Si, como yo, nunca comprometes nada directamente con el maestro , lo cual deberías hacer, puedes hacer lo siguiente.

Desde el clon local de tu tenedor, crea tu control remoto en sentido ascendente. Solo necesitas hacer eso una vez:

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

Entonces, cuando quiera ponerse al día con la twig principal del repository en sentido ascendente, necesita:

 git checkout master git pull upstream master 

Asumiendo que nunca has cometido nada sobre el maestro, deberías haberlo hecho ya. Ahora puede enviar su maestro local a su tenedor GitHub remoto de origen. También puede volver a establecer la base de su twig de desarrollo en su maestro local actualizado.

Por lo tanto, más allá de la configuration inicial ascendente y el pago maestro, todo lo que necesita hacer es ejecutar el siguiente command para sincronizar su maestro con el flujo ascendente: git pull upstream master .

Si está usando GitHub para Windows, ahora tienen una function de un clic para actualizar las horquillas:

  1. Seleccione el repository en la interfaz de usuario.
  2. Haga clic en el button "Actualizar desde usuario / twig" en la parte superior.

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

Pago a su sucursal

Sintaxis: git branch yourDevelopmentBranch
Ejemplo: git checkout master

Extraiga la twig de repository de origen para get 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

En realidad, es posible crear una bifurcación en su bifurcación de cualquier confirmación de la subida en el browser:

  • abra https://github.com/<repo>/commits/<hash> , donde repo es su fork, y hash es 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 a Linux master como hora de escritura.
  • click el button "Árbol: ….".
  • escriba el nombre de la nueva twig y presione Entrar

enter image description here

Luego puede search esa twig en su clon local, y no tendrá que volver a colocar todos esos datos en la parte superior de github cuando presione las ediciones encima de esa confirmación. O usa la interfaz web para cambiar algo en esa twig.

Cómo funciona (es una suposition, no sé cómo exactamente lo hace github): comparte el almacenamiento de objects y usa espacios de nombres para separar las references de los usuarios. Para que pueda acceder a todas las confirmaciones a través de su tenedor, incluso si no existían en el momento de la bifurcación.

Como complemento de esta respuesta, estaba buscando una forma de actualizar todas las twigs de seguimiento remoto de mi repository clonado desde el inicio de una sola vez. Así es como lo hice.

Esto supone que ya ha configurado un control remoto en upstream en el repository fuente y lo ha sincronizado con git fetch upstream .

Correr:

 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 command mostrará una list de todas las cabezas en el repository remoto upstream y eliminará el prefijo SHA-1 y /refs/heads/ .

Luego, para cada una de estas twigs, enviará la copy local de la twig remota ( refs/remotes/upstream/<branch> ) directamente a la twig remota en el origin ( refs/heads/<branch> ).

Cualquiera de estos commands de synchronization de bifurcación puede fallar por una de estas dos razones: o se ha reescrito la bifurcación upstream o se han enviado confirmaciones en esa bifurcación a su bifurcación. En el primer caso en el que no haya comprometido nada con la twig de su horquilla, es seguro empujar con fuerza ( git push -f ). En el otro caso, esto es normal ya que la bifurcación de la bifurcación ha divergido y no puede esperar que el command de synchronization funcione hasta que sus confirmaciones se hayan fusionado de nuevo en upstream .

Actualizo mis repositorys bifurcados con esta única línea:

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

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

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

Si se trata de un repository bastante grande, es posible que haya querido administrarlo de una manera especial (por ejemplo, eliminar el historial). Básicamente, puede get diferencias entre las versiones actual y anterior, confirmarlas y luego volver a seleccionar el maestro.

Intenta leer este . Describe cómo manejar grandes repositorys Git y cómo reenviarlos con los últimos cambios.

Android Studio ahora ha aprendido a trabajar con repositorys de github fork (ni siquiera tiene que agregar el repository remoto "en sentido ascendente" por el command de la console)

Abra el menu VCS -> git

y preste atención a los 2 últimos elementos del menu emergente:

  • Rebase mi tenedor github

  • Crear request de extracción

Pruébalos. Utilizo el primero exitosamente. De todos modos, después de que las twigs "ascendentes" del repository remoto desde el que se bifurcó estarán accesibles en Android Studio y podrá operar con ellas fácilmente.

(Uso Android Studio 3.0 con los complementos "git integration" y "github")

enter image description here