tag - Ignore los cambios específicos a un archivo en git, pero no el archivo completo

git status (9)

Tengo un archivo en un repositorio de git que tiene un cambio local. Quiero que git ignore el cambio local para siempre, pero no el archivo. En particular,

Si el archivo no se toca además de este cambio, git add . Nunca se debe poner en escena.
Del mismo modo, git commit -a no debería cometerlo.
Si alguna vez realizo un cambio adicional en el archivo, debería poder realizar ese cambio, pero el cambio que estoy ignorando no debe realizarse ni confirmarse.

¿Hay alguna forma de hacer esto? Haciendo un poco de investigación, leí sobre "ciclos de borrones / limpieza", donde, si leo correctamente,

el archivo se marcaría como sin cambios,
el cambio que hice se sobrescribiría cuando pague,
y luego una secuencia de comandos volvería a aplicar automáticamente el cambio y luego marcaría el archivo como nuevo sin cambios.

Sin embargo, soy muy nuevo en git y scripting (soy un pasante con experiencia en C # y Java), así que si eso es lo que tengo que hacer, ¿puedes publicar instrucciones detalladas o un enlace a un tutorial sobre cómo establecer una mancha? / limpiar ciclo hasta?

Antecedentes: Quiero que mi rama de trabajo no esté sincronizada con el troncal. Hay un error de baja prioridad que solo afecta a las máquinas de desarrollo, así que en lugar de solucionarlo, solo estamos comentando el código ofensivo. Obviamente, no queremos que este código se elimine de la producción, donde funciona bien.

A partir de Git 2.5 (julio de 2015), puede utilizar git worktree :

git worktree add -b patch-1 ../patch-1

Básicamente, esto es solo crear una rama, pero coloca la nueva rama en una nueva carpeta junto con el repositorio principal. Esto es bueno porque puede trabajar en esta rama, incluso sin comprometerse, y luego volver al maestro con un directorio de trabajo limpio.

Como lo veo, la situación que está describiendo es la siguiente: desea mantener un directorio de trabajo que sea diferente del repositorio local.

Esto no es aconsejable; Como estos cambios no se han confirmado, tendrá pocos recursos si un archivo se borra o modifica accidentalmente de una manera que no desea.

Por lo tanto, se recomienda que, de hecho, confirme todos sus cambios. Si desea separar estos cambios, puede hacerlo fácilmente utilizando una rama. Ejemplo

git checkout -b new-branch # now you can change the file without affecting master echo bar >> foo git add git commit # and back to master git checkout master

El "modo de parche" de Git es perfecto para agregar solo ciertos cambios de un archivo a su confirmación.

Para iniciarlo, escriba git add -p , git commit -p (directamente para confirmar el mensaje cuando haya terminado), o git add --interactive (más git add --interactive ).

Básicamente, te lleva a través de cada sección del código que se muestra en git diff y te pregunta si quieres organizarlo o no.

Cuando llegue al cambio, responda no o e para abrir el parche en su $ EDITOR.

Estas respuestas son buenas, pero quizás no resuelvan mejor el problema de @Kevin. Tenía una preocupación similar, a menudo editaba un archivo de configuración, por lo que la aplicación en la que estaba trabajando tendría acceso a mi propia base de datos de desarrollo privada en lugar de a la de producción. ¡Es solo una cuestión de tiempo antes de que accidentalmente me registre y presione esos cambios de configuración! Solo necesitaba una forma ligera de ignorar un archivo. Esto es lo que aprendí:

Primero, haga el cambio necesario a su archivo. Lo llamaré my_config .
Haga un archivo de parche de ese cambio con git diff >../somewhere-else/my_config.patch
Ahora dígale a git que ignore ese archivo (sin tener que cambiar el archivo .gitignore registrado): git update-index --assume-unchanged my_config

Ahora, mientras no realice cambios en my_config que quiera registrar, puede trabajar libremente. Para dejar de ignorar my_config , haga git update-index --no-assume-unchanged my_config . Después de introducir los cambios de alguien más en my_config , puede restaurar fácilmente su cambio privado con git apply ../somewhere-else/my_config.patch , luego ... asumir-sin cambios nuevamente, como arriba, y ¡volver a trabajar!

Aquí hay algunos alias útiles que puede poner en su ~/.gitconfig :

[alias] unchanged = update-index --assume-unchanged changed = update-index --no-assume-unchanged show-unchanged = !"git ls-files -v | sed -e ''s/^[a-z] //p; d''"

Puede utilizar el bit de omisión de worktree. Enciéndelo con:

git update-index --skip-worktree <file>

Después de eso, git nunca realizará cambios locales para <file> y fallará (en voz alta) si el propio git tiene que escribir en <file> (por ejemplo, en una combinación o un pago).

Si alguna vez desea realizar un cambio futuro, puede desactivarlo, configurar el nuevo cambio y luego volver a activarlo:

git update-index --no-skip-worktree <file> git add -p <file> git update-index --skip-worktree <file>

Si bien no es perfecto, esto podría ser lo suficientemente bueno. Dependerá de usted que <file> tenga cambios no programados, ya que git ya no le dirá que

Nota: Mi sugerencia original era utilizar asumir-sin cambios. Como se explica en Git - Diferencia entre ''asumir-sin cambiar'' y ''saltar-trabajar-árbol'' , lo que realmente desea es omitir-trabajar-árbol.

Sí, esto probablemente se podría hacer usando filtros de manchas / limpieza. Sin embargo, recomiendo encarecidamente no hacer esto, ya que sería bastante complejo y propenso a errores (por ejemplo, confundiría muchas herramientas que se basan en git, dificultaría la depuración de problemas, etc.).

Además, generalmente no es una buena idea tener cambios locales permanentes. Un punto importante del uso de un SCM es que puede retirar una versión y hacer que funcione de inmediato. Eso significa que todo lo que necesita debe ser registrado.

No creo que haya ninguna manera "agradable" de hacer esto, ni con git ni probablemente con la mayoría de los otros SCM. Te recomendaría que reconsideres tus necesidades.

El problema parece ser que tiene un archivo con "contenido mixto": un contenido que es siempre el mismo y otro que necesita ser cambiado localmente (¿opciones específicas de la máquina?). La forma recomendada de manejar esto no es registrar el archivo problemático, sino registrar un archivo de "plantilla" y luego generar el archivo real en el momento de la compilación. Intenta investigar esto. Será más trabajo ahora (posiblemente), pero facilitará las cosas, especialmente si necesita una mayor variación o si otras personas desean trabajar en el mismo proyecto.

Editar (basado en la información en el comentario)

Usted escribe que desea ignorar un cambio de código local que solo es necesario para las máquinas de desarrollo, pero no en producción.

En ese caso, en lugar de comentar, ajuste el código en una condición de algún tipo, de modo que solo se ejecute en las máquinas dev (p. Ej., Utilizando la compilación condicional o leyendo un archivo de configuración o alguna propiedad del entorno, o ... (1 )). Entonces puedes verificar el código normalmente.

Aún mejor, solo arregla el error. Si un error dificulta el desarrollo, en mi humilde opinión es de alta prioridad.

Solo comentar el código no es una buena idea. Es propenso a errores y debe hacerse cada vez que se retira. Sobre todo, ejecutar un código diferente en el desarrollo y en la producción es un problema y debe evitarse siempre que sea posible.

(1) Como ejemplo: en nuestra empresa, tenemos una variable de entorno específicamente para casos como este. Indica si el código se está ejecutando en desarrollo, en prueba beta o en producción, y se establece mediante nuestros scripts de compilación y despliegue. Sin embargo, generalmente solo se usa para cosas simples como elegir diferentes rutas de archivos. Se desaconseja cambiar la lógica del programa en función del entorno, como se explicó anteriormente.

Si está usando intellij como su IDE, entonces tiene una característica interesante (listas de cambios) que creo que hace exactamente lo que OP está solicitando.

Puede marcar y nombrar una parte específica de su diferencia local. Si la memoria sirve, esto mantendrá esos cambios separados de todas las demás modificaciones locales y solo se preparará para el compromiso si usted elige activamente hacerlo, siempre y cuando lo haga con su cometido desde intellij.

Si no puede usar .gitignore ya que necesita hacer cambios paralelos en el mismo archivo (como se encuentra en sus comentarios), entonces una opción es git add -p. Puede agregar u omitir en consecuencia.

El problema con el comando git anterior aquí es que será más un proceso manual. Supongo que es posible que no encuentre ningún otro enfoque automatizado para su problema.

Nota: otras personas han dicho que mantenerse al margen de los cambios locales persistentes es una mala idea, y no tengo ninguna razón para estar en desacuerdo. Considere otras opciones.

Aquí está el método que me gusta:

Realice algunos cambios que desea mantener en su máquina local.
Use git branch local y git checkout local para crear una nueva sucursal para sus cambios locales. (Si no me equivoco, estos comandos no configurarán una rama remota automáticamente, por lo que la nueva rama no será empujada).
Utilice git commit para confirmar sus cambios.
Realice los cambios que desea empujar hacia arriba.
Use git checkout parent para volver a la rama que desea empujar.
Utilice git commit para comprometerse con esta rama.
Usa git push para impulsar tus cambios.
Use git checkout local para volver a su sucursal local.
Use git rebase parent para traer los cambios de parent a local . El uso de rebase lo hará para que sus cambios locales se mantengan por encima de los cambios en parent .
Vuelva al paso 4 y repita hasta la náusea.

Con esto, no tiene que decirle manualmente a git qué cambios son locales y cuáles no siempre que quiera hacer un cambio no local.