subir - quitar archivos de git

gitignore sin archivos binarios

Question

¿Cómo se pueden ignorar los archivos binarios en git usando el archivo .gitignore ?

Ejemplo:

$ g++ hello.c -o hello

El archivo "hola" es un archivo binario. ¿Puede ignorar este archivo?

Answer 1

.gitignore usa programación glob para filtrar archivos, al menos en Linux.

Estoy a punto de dar una charla de codificación en un Meetup y, en preparación, hice un directorio con varios subdirectorios que se nombran de acuerdo con el orden en el que quiero presentarlos: 01_subject1, 02_subject2, 03_subject3. Cada subdirectorio contiene un archivo fuente con una extensión dependiente del idioma que se compila en un archivo ejecutable cuyo nombre coincide con el nombre del archivo de origen sin la extensión de acuerdo con la práctica habitual.

Excluyo los archivos compilados en los directorios con prefijo numérico con la siguiente línea .gitignore:

[0-9][0-9]_*/[!/.]*

Según mi comprensión de la documentación, no debería funcionar. Tener el asterisco final debe fallar porque debe coincidir con cualquier cantidad de caracteres no especificados, incluido el ''.'' + extensión. Omitir el asterisco final debería fallar (y lo hace) porque [!/.] Coincide con un solo carácter que no es de punto. Sin embargo, agregué el asterisco final, como lo haría con una expresión regular, y funciona. Por trabajo, me refiero a que git nota los cambios en el archivo fuente, pero no la existencia o los cambios a los archivos compilados.

Answer 2

Agrega algo como

*.o

en el archivo .gitignore y colóquelo en la raíz de su repositorio (o puede colocarlo en cualquier subdirectorio que desee, se aplicará desde ese nivel) y registrarlo.

Editar:

Para los binarios sin extensión, es mejor que los coloques en bin/ o en alguna otra carpeta. Después de todo, no hay ignorar en función del tipo de contenido.

Puedes probar

*
!*.*

pero eso no es infalible.

Answer 3

Aquí hay otra solución que usa el archivo. De esta forma, las secuencias de comandos ejecutables no terminarán en gitignore. Es posible que necesite cambiar la forma en que se interpreta la salida del archivo para que coincida con su sistema. Uno podría entonces configurar un gancho precompromiso para llamar a este script cada vez que se comprometa.

import subprocess, os

git_root = subprocess.check_output([''git'', ''root'']).decode("UTF-8").strip()
exes = []
cut = len(git_root)

for root, dirnames, filenames in os.walk(git_root+"/src/"):
  for fname in filenames:
    f = os.path.join(root,fname)
    if not os.access(f,os.X_OK):
      continue

    ft = subprocess.check_output([''file'', f]).decode("UTF-8")

    if ''ELF'' in ft and ''executable'' in ft:
      exes.append(f[cut:])

gifiles = [ str.strip(a) for a in open(git_root + "/.gitignore").readlines() ]
gitignore=frozenset(exes+gifiles)

with open(git_root+"/.gitignore", "w") as g:
  for a in sorted(gitignore):
    print(a, file=g)

Answer 4

Basándose en la respuesta de VenomVendors

# Ignore all
*

# Unignore all files with extensions recursively
!**/*.*

# Unignore Makefiles recursively
!**/Makefile

# other .gitignore rules...

Answer 5

Creé un archivo .gitignore con dos entradas en el directorio GOPATH.

/bin
/pkg

Ignora todos los desarrollos compilados, actualmente.

Answer 6

No conozco ninguna otra solución, sino que las agrego una por una a .gitignore .

Una forma cruda de probar es grep la salida del comando de archivo:

find . /( ! -regex ''.*//..*'' /) -type f | xargs -n 1 file | egrep "ASCII|text"

EDITAR

¿Por qué simplemente no te llamas ejecutable hello.bin ?

Answer 7

Para agregar todos los archivos ejecutables a su .gitignore (lo que probablemente quiera decir con "archivo binario" a juzgar por su pregunta), puede usar

find . -executable -type f >>.gitignore

Si no le interesa el orden de las líneas en su .gitignore , también puede actualizar su .gitignore con el siguiente comando, que también elimina los duplicados y mantiene el orden alfabético intacto.

T=$(mktemp); (cat .gitignore; find . -executable -type f | sed -e ''s%^/./%%'') | sort | uniq >$T; mv $T .gitignore

Tenga en cuenta que no puede canalizar la salida directamente a .gitignore , porque eso truncaría el archivo antes de que cat abra para su lectura. Además, es posible que desee agregar /! -regex ''.*/.*/.*'' /! -regex ''.*/.*/.*'' como una opción para encontrar si no desea incluir archivos ejecutables en subdirectorios.

Answer 8

Puede probar en su .gitignore :

*
!*.c

Este enfoque tiene muchas desventajas, pero es aceptable para proyectos pequeños.

Answer 9

Si está utilizando un archivo MAKE, puede intentar modificar sus reglas de creación para agregar los nombres de los archivos binarios nuevos a su archivo .gitignore.

Aquí hay un archivo Makefile para un pequeño proyecto Haskell;

all: $(patsubst %.hs, %, $(wildcard *.hs))

%: %.hs
    ghc $^
    grep -xq "$@" .gitignore || echo $@ >> .gitignore

Este makefile define una regla para crear ejecutables a partir del código Haskell. Después de invocar a ghc, verificamos el .gitignore para ver si el binario ya está en él. Si no es así, agregamos el nombre del archivo binario al archivo.

Answer 10

Solo agrega hello o /hello a tu .gitignore. Cualquiera de los dos funciona

Answer 11

Su mejor opción con los binarios es darles una extensión que pueda filtrar fácilmente con un patrón estándar, o ponerlos en directorios que pueda filtrar a nivel de directorio.

La sugerencia de extensión es más aplicable en Windows, porque las extensiones son estándar y básicamente necesarias, pero en Unix, puede o no usar extensiones en los binarios ejecutables. En este caso, puede ponerlos en un bin / carpeta y agregar bin/ a su .gitignore.

En su ejemplo muy específico y de pequeño alcance, puede poner hello en su .gitignore.

Answer 12

Una forma de ignorar también en algún subdirectorio, no solo en una raíz:

# Ignore everything in a root
/*
# But not files with extension located in a root
!/*.*
# And not my subdir (by name)
!/subdir/
# Ignore everything inside my subdir on any level below
/subdir/**/*
# A bit of magic, removing last slash or changing combination with previous line
# fails everything. Though very possibly it just says not to ignore sub-sub-dirs.
!/subdir/**/
# ...Also excluding (grand-)children files having extension on any level
# below subdir
!/subdir/**/*.*

O bien, si desea incluir solo algunos tipos específicos de archivos:

/*
!/*.c
!/*.h
!/subdir/
/subdir/**/*
!/subdir/**/
!/subdir/**/*.c
!/subdir/**/*.h

¡Parece que incluso puede funcionar como para cada subdirectorio nuevo si lo deseas !:

/*
!/*.c
!/*.h
!/*/
/*/**/*
!/*/**/
!/*/**/*.c
!/*/**/*.h

Las barras diagonales principales son importantes solo en las dos primeras líneas y son opcionales en otras. La barra inclinada en !/*/ Y !/subdir/ también es opcional, pero solo en esta línea.

Answer 13

# Ignore all
*

# Unignore all with extensions
!*.*

# Unignore all dirs
!*/

### Above combination will ignore all files without extension ###

# Ignore files with extension `.class` & `.sm`
*.class
*.sm

# Ignore `bin` dir
bin/
# or
*/bin/*

# Unignore all `.jar` in `bin` dir
!*/bin/*.jar

# Ignore all `library.jar` in `bin` dir
*/bin/library.jar

# Ignore a file with extension
relative/path/to/dir/filename.extension

# Ignore a file without extension
relative/path/to/dir/anotherfile