remota - git agregar agregar archivos ignorados

git push example

Question

Estoy tratando de eliminar un directorio previamente rastreado de git, que funciona, pero se vuelve a agregar con cada git add . posterior git add . , git add -A , etc. Esto es lo que hice:

Agregar a .gitignore en la raíz del proyecto:

node_modules

Ejecute lo siguiente:

git rm -r --cached node_modules
git commit -a -m "removed node_modules"
git push origin master

Hasta ahora todo bien, esto elimina el directorio del repositorio remoto. El problema es cuando más tarde ejecuto el git status , me dice que el directorio node_modules no se ha rastreado y continúa volviendo a agregarlo en futuros commits.

¿Qué me estoy perdiendo y / o cómo puedo encontrar la raíz de mi problema?

Desde here :

El comando git add no agregará archivos ignorados por defecto. ... El comando git add se puede usar para agregar archivos ignorados con la opción -f (forzar).

Información adicional de los comentarios:

Estoy rastreando el archivo .gitignore.

git check-ignore node_modules/ returns node_modules / como se esperaba.

Sin uso de submódulos.

Actualizar:

Creé una muestra que parece replicar el problema siguiendo los pasos anteriores:

https://github.com/awhitehouse104/SampleRepo

Resolución:

Para resumir la respuesta y los comentarios de abajo, el problema estaba en la codificación de mi archivo .gitignore. Había usado echo ''node_modules'' > .gitignore para crear el archivo en Windows 8 y salió como UTF-16 con BOM (según la respuesta a continuación). Después de algunas búsquedas en google, parece que esta es la codificación predeterminada con powershell y puedo confirmar que el guardado como UTF-8 parece haber resuelto el problema.

tldr; Probablemente no use este método para crear archivos .gitignore o esté preparado para cambiar la codificación

echo ''node_modules'' > .gitignore

Answer 1

Agregue el archivo a git ignore, luego

git update-index --assume-unchanged <file>

Answer 2

Creé un repositorio para tratar de duplicar su problema, y ​​obtuve la primera respuesta de http://www..com/questions/11451535/gitignore-not-working para trabajar.

Aquí está mi informe si tiene curiosidad: https://github.com/IAMZERG/so_project_gitignore

Intente agregar esto al .gitignore en su lugar:

** / directory_to_remove

Después de eso, ejecute git rm --cached directory_to_remove -r

El estado de git debería mostrar que eliminó un grupo de archivos en el directorio que está tratando de eliminar. Entonces, comprométalo y presiona hacia tu control remoto, y todo debería estar dorado ... ¿Tal vez?

Answer 3

El origen tiene que ser simple. Aquí hay un pequeño golpe para demostrarlo. Siéntase libre de editarlo, si no representa su caso de uso.

#!/bin/bash
rm -rf /tmp/git_test
mkdir /tmp/git_test/
git init --bare /tmp/git_test/primary_repo
# populate repo
cd /tmp/git_test/
git clone ./primary_repo ./secondary_repo
cd secondary_repo
echo hi_bob > some_content
mkdir node_modules
echo hi_dave > node_modules/moduleA
git add .
git commit -m "populated primary"
git push
# do the removal in tertiary
cd /tmp/git_test/
git clone ./primary_repo ./tertiary_repo
cd tertiary_repo
echo node_modules >> .gitignore
git add .gitignore
git rm -r --cached node_modules
git commit -a -m "removed node_modules"
git push origin master
rm -r node_modules
echo --------------------------------
echo git status:
git status

Answer 4

Es probable que tengas una regla negativa (regla de incluir de nuevo, la que comienza con an ! ) En tu archivo .gitignore algún lugar después de la línea node_modules .

git check-ignore tiene un error / ambigüedad en los documentos. Usted espera que si git check-ignore node_modules/ prints node_modules/ , entonces node_modules/ es ignorado. Pero en realidad imprime una ruta de acceso si ese nombre de ruta coincide con cualquier patrón de ignorar, ya sea positivo o negativo. La única forma de estar seguro es usar la opción -v ( --verbose ), que hará que git check-ignore imprima el patrón coincidente.
Además, si git check-ignore -v dice que se ignora un directorio, no significa necesariamente que se ignoren todos los archivos en ese directorio. Repo de ejemplo:

/
.git/
.gitignore
node_modules/
bar
foo

$ cat .gitignore
/node_modules/*
!/node_modules/foo
$ git check-ignore -v node_modules/
.gitignore:1:/node_modules/* node_modules/
^ positive pattern => ignored
$ git check-ignore -v node_modules/foo
.gitignore:2:!/node_modules/foo node_modules/foo
^ negative pattern => not ignored
$ git add -A
$ git status
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# new file: node_modules/foo
#

Entonces, si git check-ignore -v node_modules/ says node_modules/ es ignorado, git add -A node_modules/ y luego ejecute git check-ignore -v --no-index en los archivos individuales que se agregaron, para descubrir por qué se agregaron .

Actualización: no esperaba eso: su archivo .gitignore está en la codificación "UTF-16 con BOM (marca de orden de bytes)":

$ cat .gitignore | hexdump -vC
00000000 ff fe 6e 00 6f 00 64 00 65 00 5f 00 6d 00 6f 00 |..n.o.d.e._.m.o.|
00000010 64 00 75 00 6c 00 65 00 73 00 0d 00 0a 00 |d.u.l.e.s.....|

Es por eso que probablemente Git no pueda manejarlo. Guarde el archivo en UTF-8 sin BOM, eso debería solucionar el problema. Pero también sugiero que se presente un informe de error contra git check-ignore : en este caso, su resultado no es coherente con lo que git realmente ignora.

Answer 5

Esto es lo que hago para ignorar la carpeta node_modules después de rastrearla.

1. Crea el archivo .gitignore y agrega node_modules a él.

2. Confirme el archivo .gitignore . Después de este punto, lo que actualice en la carpeta node_modules no aparecerá en git status .

3. Pero esto no elimina lo que ya tenemos en el repositorio en la carpeta node_modules . Entonces ahora debemos eliminar todo lo que hemos cometido previamente.

   Para esto, use git rm --cached node_modules -r

4. Ahora el git status mostrará que los archivos se eliminaron.

5. Use el comando git commit -m "node_modules removed" con cualquier mensaje.

Ahora todo debe ser eliminado del repositorio y los cambios futuros no serán rastreados.

Answer 6

He encontrado una forma de agregar archivos a .gitignore, incluso si ya se han confirmado una vez. Es un poco brutal pero funciona genial.

1. Agregue los diferentes archivos a su .gitignore

2. Saca estos archivos de tu proyecto de git

3. Volver a analizar y cambiar de escenario, estas operaciones le dirán que estos archivos se han eliminado

4. Cometer

5. Mueva sus archivos a su proyecto, ¡ya no serán rastreados!

Answer 7

Otro enfoque si no quieres usar git rm --cached

rm -Rf node_modules
git add -u
git commit -m "stop tracking node_modules"
npm install
# done

También tenga en cuenta la distinción entre node_modules y node_modules / que parece tener correcto. (Gracias umläute por la nota sobre esto)

Answer 8

Tu puedes hacer

git check-ignore -v --no-index path/with/unexpected/result

para ver por qué git add o no esa ruta.

git check-ignore docs .

En particular, el punto es que desea verificar qué se está agregando realmente, no un directorio.

más aún, find . -name .git find . -name .git . Los submódulos son repos anidados, .gitmodules y el comando del submódulo son útiles, pero están ahí para ayudarlos.

Answer 9

Tuve un problema similar. Asegurándome de que mi codificación era ANSI y que los finales de línea fueron Unix (LF) corrigió mi problema.

Answer 10

gitignore: especifica los archivos intencionalmente no rastreados para ignorar.

$ HOME / .config / git / ignore, $ GIT_DIR / info / exclude, .gitignore

Cada línea en un archivo de gitignore especifica un patrón. Al decidir si ignorar una ruta, Git normalmente verifica patrones de gitignore de múltiples fuentes, con el siguiente orden de precedencia, de mayor a menor (dentro de un nivel de precedencia, el último patrón coincidente decide el resultado):

Para ignorar todo el directorio, debe usar /** ,

Un seguimiento / ** coincide con todo lo que está dentro. Por ejemplo, abc / ** hace coincidir todos los archivos dentro del directorio "abc", con respecto a la ubicación del archivo .gitignore, con profundidad infinita.

O

Puede ignorar todo el directorio agregando esta línea a su archivo raíz .gitignore:

/ Dir_Name

En su lugar, puede agregar un archivo /logs/.gitignore que contenga esto:

[^.] *

El directorio permanecerá en su repositorio, pero se ignorarán todos los archivos dentro del directorio. ¡Fácil!

Los pasos que debes seguir son:

1. Eliminarlo del directorio del proyecto (sin eliminarlo):

   git rm - carpeta caca / /

2. Si aún no tiene un .gitignore, puede hacer uno directamente dentro de la carpeta de su proyecto:
3. proyecto / .gitignore. Coloca la carpeta / * (o cualquiera de los patrones que creas mejores de la lista anterior) en el .gitignore Commit:
4. git commit -m "mensaje".
5. Presiona tu cambio a github.

Ejemplo para excluir todo, excepto un directorio específico foo / bar (tenga en cuenta el / * - sin la barra inclinada, el comodín también excluiría todo dentro de foo / bar):

$ cat .gitignore
# exclude everything except directory foo/bar
/*
!/foo
/foo/*
!/foo/bar