Exportar un alijo a otra computadora

Necesito una forma de exportar un cambio oculto a otra computadora.

En Computer1 hice

$ git stash save feature

Estoy tratando de llevar el parche oculto a un archivo y luego importarlo a otra computadora

$ git stash show -p > patch

Este comando me da un archivo que puedo mover a otra computadora donde se clona este repositorio, pero la pregunta es cómo volver a importarlo como escondite.

Gracias

Puede aplicar un archivo de parche (sin confirmar los cambios aún) simplemente ejecutando

git apply patchfile

Luego, simplemente puede crear un nuevo alijo desde el directorio de trabajo actual:

git stash

Alternativamente, puede crear una rama desde su escondite (en la computadora 1), utilizando

git stash branch stashed_changes_branch

compromete tus cambios:

git commit -a

luego agréguelo como control remoto en la computadora 2:

git remote add pc1 user@computer1:/path/to/repo

ahora puede recuperar la información remota utilizando

git fetch pc1

ahora puede importar la confirmación de la forma que desee; usando git cherry-pick , git rebase o lo que quieras ... Si quieres que se vea como si acabaras de aplicar git stash ; puedes usar git cherry-pick --no-commit.

Si no tiene conexión directa entre la computadora1 y la computadora2; puedes usar un control remoto (como github o algo similar):

git push origin stashed_changes_branch

y en la computadora2:

git fetch

Alternativamente, puede exportar las reservas locales completas a otro compilador de la siguiente manera

• git pull tanto en el directorio git antiguo como en el nuevo para garantizar que ambos tengan los últimos cambios.
• copie la carpeta .git del antiguo directorio git al nuevo repositorio

Cómo exportar Stash en SourceTree:

1. Haga una nueva rama "StashTransfer" desde una rama donde va a usar su Stash

2. Aplique su alijo y haga una confirmación

3. Haga clic en su confirmación y haga un parche, lleve el archivo del parche con usted.

4. Vaya a un repositorio diferente, seleccione la misma rama principal que acaba de usar en 1)

5. Acciones / Aplicar parche, seleccione Modo: modifique los archivos de copia de trabajo, presione Aplicar parche ahora tiene modificaciones no confirmadas del parche en su entorno de trabajo actual

6. Hacer un nuevo alijo para el repositorio actual

Puede crear un alijo como archivo de parche desde una máquina, luego puede compartir ese archivo de parche con otras máquinas.

Crear el alijo como un parche

$ git stash show "stash@{0}" -p > changes.patch

El "alijo @ {0}" es la referencia del alijo. Creará un archivo de parche con el último alijo. Si desea un comando diferente, use $ git stash listpara ver su lista de escondites y seleccione cuál desea parchear.

Aplicando el parche

Ahora transfiera ese alijo a otra máquina y péguelo en la carpeta raíz de su proyecto. Luego ejecuta este comando

$ git apply changes.patch

Si hay un error y desea revertir el cambio

$ git apply changes.patch --reverse

Otra opción es rsyncla .gitcarpeta de una computadora a otra computadora. rsyncprocesa solo cambios de archivo (más rápido que una copia).

Una desventaja de este enfoque es que las configuraciones también se sobrescribirán, lo que puede no ser deseable si ejecuta diferentes configuraciones .git entre las dos máquinas. Pero podría superar esto excluyendo archivos con la --excludeopción en rsync.

En general, creo que una solución Git nativa es más limpia, pero este rsynctruco podría ser bueno para alguien apurado que podría estar más familiarizado con rsync que con git.

El comando de inicio de la publicación original:

git stash show -p stash@{x} > patch_file

no funcionó para mí (por alguna razón creó archivos de parche inutilizables). En cambio tuve que:

git stash apply stash@{x}
git commit

por cada alijo que quería transferir. Luego, coloqué el repositorio 'padre' dentro del archivo: /// alcance del repositorio 'hijo', e hice lo siguiente, para cada confirmación de alijo:

git fetch file:///path_to_parent_git && git cherry-pick commit_sha
git reset --soft HEAD^
git stash save my_new_stash_on_child

Esto es más complejo pero fue el truco para mí.

Si desea mover sus cambios de una máquina a otra, siempre puede confirmar sus cambios en su máquina y luego hacer un restablecimiento parcial en su máquina.

Oficina

git commit -m "-stash-"

Cocina

git reset --soft HEAD~1

Un escondite es una confirmación especial de fusión del árbol de trabajo entre la confirmación básica y el índice. Una forma podría ser guardar cada uno como parches separados, retirar el escondite del primer padre, restaurar el índice y el árbol de trabajo de los dos parches y finalmente restaurar el escondite (parece que una respuesta es así).

Esto es necesario para recrear completamente toda la información del alijo, y si no le importa, debe al menos revisar el primer padre del alijo antes de restaurar para evitar conflictos y realizar un seguimiento de dónde se creó el alijo.

Esto es lo que hice para restaurar completamente todos los escondites de un repositorio a otro. Si no puede tenerlos en la misma computadora, puede guardar las etiquetas ocultas en un paquete después de crearlas y copiar la lista de referencias y el paquete en la computadora de destino.

Desde la raíz del repositorio original:

1. Obtenga la lista de referencias de alijo
2. Etiquete sus referencias de alijo para que pueda recuperarlas con git fetch (los nombres de las etiquetas no importan, cámbielo si hay un conflicto. Usé stash_+ los números en la referencia de alijo lógico)
3. Convierta las referencias lógicas en hashes sha1 en orden inverso : las usaremos más tarde
4. Guarde esa ruta de repositorio - también para más tarde

refs=$(git stash list|cut -d: -f1)
for ref in $refs; do tag stash_${ref//[^0-9]} $ref; done
refs=$(git rev-parse $refs|tac)
oldpath=$PWD

NB: Esto requiere bash o shell compatible (ksh, zsh debería hacer ...) También podría incrementar una variable, por ejemplo, stash_$((i++))si su shell no es compatible${param//pattern}

Ahora en el nuevo repositorio, para cada referencia:

1. Obtenga la referencia del repositorio anterior (ni siquiera necesitamos usar los nombres de las etiquetas, porque las hemos etiquetado podemos recuperarlas con git fetch)
2. Vuelva a importar el alijo de la referencia, utilizando el asunto de esa referencia como el mensaje de alijo.

for ref in $refs; do git fetch $oldpath $ref; git stash store -m "$(git show -s --pretty=%s $ref)" $ref; done