Git commit no ha terminado pero no puede continuar en esa máquina

A veces me encuentro con el problema de tener código no confirmado en una estación de trabajo que no está lista para una confirmación pero que debe completarse en una estación de trabajo o computadora portátil diferente.

¿Alguien tiene una solución para este problema, como un "compromiso suave" o alguna otra forma de transferir los cambios a otra máquina para trabajar en ellos en otro lugar?

Preferiría no ser forzado a comprometer e impulsar cambios que no se implementan correctamente.

Lo siguiente asume que su repositorio local es un clon de un repositorio en otro servidor, por ejemplo, github; y que tiene derechos para realizar cambios en el servidor ascendente. En mi ejemplo, he llamado a este repositorio ascendente "origen". Ejecute git remote showpara enumerar otros repositorios, esto puede darle una pista sobre cómo se llama.

Sugeriría hacer una rama, luego puede revisar la rama en otra máquina. De hecho, si crea una rama tan pronto como comience a trabajar, puede "comprometerse" con su rama, realizar un seguimiento y una copia de seguridad de su trabajo, sin tener que tener un conjunto de códigos estable. Una vez que esté satisfecho con su trabajo, puede fusionarlo nuevamente en su rama "maestra".

• Para ramificar su repositorio: git checkout -b MyNewBranch
• Para impulsar cambios comprometidos en su nueva sucursal: git push origin MyNewBranch
• Para ver una sucursal en otra máquina: git checkout MyNewBranch
• Para cambiar a otra rama (por ejemplo, "maestro"): git checkout master
• Cuando esté en master, para fusionar MyNewBranch nuevamente: git merge MyNewBranch
• Para enumerar sucursales: git branch

Puede usar git diffpara crear un parche y luego aplicarlo en otra máquina. O puede crear una confirmación temporal y luego extraerla de otra máquina. Incluso puede crear una rama temporal en alguna otra máquina, empujar su confirmación temporal allí y luego eliminar la rama.

Mi método favorito es el segundo: crear una confirmación temporal, luego ir a otra máquina y hacer algo como esto:

$ git fetch ssh://first_machine/path/to/repo whatever_branch_i_was_working_on
$ git reset --hard FETCH_HEAD
$ git reset HEAD^

Me comprometo ella. Lo empujo a la rama personal , reviso en el otro lado y corrijo. Y elimine la rama personal cuando haya terminado.

Por supuesto, puede empujar directamente entre los repositorios, puede usar bundle o format-patch/ am, pero una rama personal es, con mucho, la solución más fácil. Y reescribir el historial no es un gran problema, siempre que no se envíe a ninguna rama compartida. En muchos proyectos, se supone que las personas deben rebobinar las ramas de características para que sean más fáciles de entender para su revisión.

El enfoque fácil es el que usted describe: copie el .gitdirectorio oculto y los archivos del proyecto en otra máquina donde pueda confirmar y finalizar, o simplemente continuar trabajando.

El .gitdirectorio es donde se guarda el historial de git, por lo que conservarlo junto con los archivos reales mantiene intacto todo el historial del proyecto.

Si ha terminado de usar la máquina original de forma permanente, probablemente le recomiendo este enfoque.

Como otros han respondido, con Git no debería importarle el código no terminado en sus sucursales personales. Sin embargo, si por alguna razón, realmente no quieres que tu trabajo inacabado toque el repositorio principal, ¡puedes utilizar la naturaleza distribuida de Git!

Hay una herramienta simple llamada git bundleque puede ayudarlo a pasar fácilmente los cambios sin un repositorio central. Primero, clone el repositorio:

git clone https://github.com/octocat/Spoon-Knife.git working_copy_1
cd working_copy_1

hacer algunos cambios y confirmarlos en una rama temporal:

git checkout -b tmp_branch
git commit -a -m "temporary changes"

Ahora, agrupa los cambios:

git bundle create ../tmp.bundle tmp_branch

Ahora tiene un archivo de paquete que puede enviar por correo a su nueva máquina. ¿Cómo lo usas allí? Creemos una nueva copia de trabajo:

cd ..
git clone https://github.com/octocat/Spoon-Knife.git working_copy_2
cd working_copy_2

necesitamos tratar nuestro paquete como otro control remoto, para que podamos obtener los cambios de él

git remote add tmp ../tmp.bundle
git fetch tmp

Dado que el objetivo era transferir los cambios sin dejar rastro, querremos aplastarlos en la copia de trabajo para perder la confirmación temporal:

git merge tmp/tmp_branch --squash

y todo lo que queda es eliminar el control remoto temporal:

git remote remove tmp

¡VIOLA! ¡Los cambios se transfirieron a la nueva copia de trabajo sin dejar rastro de rama ni confirmación!

Pero en realidad, este proceso es bastante largo y engorroso. Esto es Git, no SVN: realmente no debería haber ninguna razón para no empujar su rama personal al repositorio central.