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
Respuestas:
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
git stash show "stash@{0}" -p > patchlugar del segundo comando de shell del OP.
stash@{0}..
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
git stash list --oneline), por lo que técnicamente no tiene que aplicar el escondite a un nuevo objeto de compromiso. En otras palabras, no es necesario crear una nueva rama. Sin embargo, empujar un alijo directamente a un control remoto es difícil por decir lo menos.
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.Aplique su alijo y haga una confirmación
Haga clic en su confirmación y haga un parche, lleve el archivo del parche con usted.
Vaya a un repositorio diferente, seleccione la misma rama principal que acaba de usar en 1)
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
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:
stash_+ los números en la referencia de alijo lógico)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=$PWDNB: 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:
for ref in $refs; do git fetch $oldpath $ref; git stash store -m "$(git show -s --pretty=%s $ref)" $ref; done
git stash saveahora está en desuso a favor degit stash push