software - ¿Cómo actualizo un repositorio bifurcado de GitHub?

github login (16)

A la fecha de esta respuesta, GitHub no tiene ( o debo decir que ya no? ) Esta función en la interfaz web. Sin embargo, puede solicitar a [email protected] 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

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

Unos días más tarde, otro contribuyente hizo otro cambio. Así que mi tenedor no contiene ese cambio.

¿Cómo puedo conseguir ese cambio en mi horquilla? ¿Debo eliminar y volver a crear mi bifurcación cuando tengo más cambios para contribuir? ¿O hay un botón de actualización?

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

Abra su tenedor en GitHub.
Haga clic en Solicitudes de extracción .
Haga clic en Nueva solicitud de extracción . De manera predeterminada, GitHub comparará el original con su fork, y no debería haber nada para comparar si no hizo ningún cambio.
Haga clic en cambiar la base si ve ese enlace. De lo contrario, coloque manualmente la horquilla de base en su horquilla y la horquilla de cabeza en la corriente. Ahora GitHub comparará tu horquilla con el original, y deberías ver todos los cambios más recientes.
Cree una solicitud de extracción y asigne un nombre predecible a su solicitud de extracción (por ejemplo, Update from original ).
Desplácese hacia abajo para Combinar solicitud de extracción , pero no haga clic en nada todavía.

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

El valor predeterminado creará un feo compromiso de combinación.
Si hace clic en el menú desplegable y selecciona "Aplastar y fusionar", todas las confirmaciones intermedias se aplastarán en una. Esto es más a menudo algo que no quieres.
Si hace clic en Rebase y se fusiona , todas las confirmaciones se harán "con" usted, las relaciones públicas originales se vincularán a sus relaciones públicas, y GitHub mostrará This branch is X commits ahead, Y commits behind <original fork> .

Así que sí, puede mantener su repo actualizado con su flujo ascendente utilizando la interfaz de usuario web de GitHub, pero al hacerlo le manchará el historial de confirmación. Quédate en la línea de comandos , es fácil.

Actualizo mis repos bifurcados con esta única 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í.

Android Studio ahora ha aprendido a trabajar con los repositorios de horquillas de GitHub (ni siquiera tiene que agregar un repositorio remoto "ascendente" mediante el comando de la consola).

Abrir el menú VCS → Git

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

Rebase mi horquilla GitHub
Crear solicitud de extracción

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

(Uso Android Studio 3.0 con los complementos "Git integration" y "GitHub").

Aquí está el documento oficial de GitHub en Syncing a fork :

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ó.
Consejo: la sincronización de su fork 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)
Sincronizando
Se requieren dos pasos para sincronizar su repositorio con el flujo ascendente: primero debe recuperar el control remoto, luego debe combinar la rama deseada en su rama local.
Atractivo
La captura desde el repositorio remoto traerá sus sucursales y sus respectivas confirmaciones. Estos se almacenan en su repositorio local bajo sucursales 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 de upstream almacenada en una rama 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
Fusionando
Ahora que hemos recuperado el repositorio anterior, queremos fusionar sus cambios en nuestra sucursal local. Esto hará que esa rama se sincronice 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 ningún compromiso único, 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 desea actualizar su repositorio en GitHub, siga las instrucciones here

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

Esto supone que ya ha configurado un apuntador remoto en sentido ascendente en el repositorio de origen (donde se originó el origen ) y lo ha sincronizado con 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 todos los jefes en el repositorio remoto ascendente y elimina el SHA-1 seguido del prefijo refs/heads/ branch name.

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 ha sido reescrita, o usted ha enviado confirmaciones en esa bifurcación a su bifurcación. En el primer caso en el que no haya comprometido nada en la rama de su horquilla, es seguro presionar con fuerza (agregue el interruptor -f ; es decir, git push -f en el comando anterior). En el otro caso, esto es normal ya que su rama de bifurcación se ha desviado y no puede esperar que el comando de sincronización funcione hasta que sus confirmaciones se hayan vuelto a fusionar en sentido ascendente .

Cuando haya clonado su repositorio bifurcado, vaya a la ruta del directorio donde reside su clon y las pocas líneas en su terminal 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 bueno para ir. Todos los cambios actualizados en el repositorio principal se insertarán en su repositorio de bifurcaciones.

El comando "fetch" es indispensable para mantenerse actualizado en un proyecto: solo cuando realice un "git fetch" se le informará sobre los cambios que sus colegas enviaron al servidor remoto.

Todavía puede visitar here para más consultas

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 recomendable ponerse en contacto con [email protected] para agregar su soporte para que se implemente una función como esta. La solicitud de función no oficial anterior podría ser utilizada como evidencia de la cantidad de interés en que se esté implementando.

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

Abra https://github.com/<repo>/commits/<hash> , donde repo es su bifurcación, y el hash es un hash completo de confirmación que puede encontrar en la interfaz web ascendente. Por ejemplo, puedo abrir https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 , que apunta a linux como el tiempo de escritura.
Haga clic en el botón "Árbol: ....".
Escriba el nombre de la nueva rama y presione Enter

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

Cómo funciona (es una conjetura, no sé exactamente cómo lo hace GitHub): las bifurcaciones comparten el almacenamiento de objetos y usan namespaces de namespaces para separar las referencias de los usuarios. Por lo tanto, puede acceder a todos los compromisos a través de su bifurcación, incluso si no existían en el momento de bifurcar.

Eso depende del tamaño de tu repositorio y de cómo lo bifurcas.

Si es un repositorio bastante grande, es posible que haya querido administrarlo de una manera especial (por ejemplo, historial de eliminación). Básicamente, puede obtener diferencias entre las versiones actuales y anteriores, confirmarlas y luego seleccionar nuevamente al maestro.

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

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

Seleccione el repositorio en la interfaz de usuario.
Haga clic en el botón "Actualizar del usuario / rama" en la parte superior.

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

Desde el clon local de su bifurcación, cree su control remoto aguas arriba. 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

Suponiendo que nunca hayas cometido nada en Master, deberías haberlo hecho ya. Ahora puede llevar a su maestro local a su horquilla remota de GitHub de origen. También puede cambiar la base de su desarrollo en su maestro local ahora actualizado.

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

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

Salida a su sucursal

Sintaxis: git branch yourDevelopmentBranch
Ejemplo: git checkout master

Extraiga 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

Una gran cantidad de respuestas terminan moviendo su bifurcación una por delante del repositorio principal. Esta respuesta resume los pasos que se encuentran here cuales moverán su fork a la misma confirmación que el padre .

Cambie el directorio a su repositorio local.
- Cambia a la rama maestra si no eres git checkout master
Agregue el padre como un repositorio remoto, git remote add upstream <repo-location>
Emitir git fetch upstream
Emisión git rebase upstream/master
- En esta etapa, verificas que se confirma lo que se fusionará al escribir git status
Emite git push origin master

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

Prólogo: Tu fork es el "origen" y el repositorio desde el que bifurcaste es el "upstream".

Supongamos que ya ha clonado su fork a su computadora con un comando como este:

git clone [email protected]:your_name/project_name.git cd project_name

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

Agregue el "upstream" a su repositorio clonado ("origen"):
git remote add upstream [email protected]:original_author/project_name.git
Obtener los confirmaciones (y ramas) de la "corriente arriba":
git fetch upstream
Cambie a la rama "maestra" de su bifurcación ("origen"):
git checkout master
Guarda los cambios de tu rama "maestra":
git stash
Combine los cambios de la rama "maestra" de la "corriente arriba" en su rama "maestra" de su "origen":
git merge upstream/master
Resuelva los conflictos de fusión si los hubiera y confirme su fusión
git commit -am "Merged from upstream"
Empuja los cambios a tu horquilla.
git push
Recupere sus cambios escondidos (si los hay)
git stash pop
Has terminado ¡Felicidades!

GitHub también proporciona instrucciones para este tema: help.github.com/articles/syncing-a-fork

En su clon local de su repositorio bifurcado, puede agregar el repositorio original de GitHub como "remoto". (Los "mandos a distancia" son como los apodos para las URL de los repositorios; por ejemplo, el origin es uno.) Luego, puede obtener todas las ramas de ese repositorio ascendente y volver a preparar su trabajo para continuar trabajando en la versión ascendente. En términos de comandos que pueden parecer:

# 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 volver a escribir 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, es probable que sea mejor cambiar de base.

Si has rebasado tu rama en upstream/master es posible que debas forzar el empuje para empujarlo a tu propio repositorio bifurcado en GitHub. Lo harías con:

git push -f origin master

Solo necesita usar la -f la primera vez después de haber cambiado de base.