Faire en sorte que .gitignore ignore tout sauf quelques fichiers

Je comprends qu'un fichier .gitignore masque les fichiers spécifiés du contrôle de version de Git. J'ai un projet (LaTeX) qui génère beaucoup de fichiers supplémentaires (.auth, .dvi, .pdf, logs, etc.) pendant son exécution, mais je ne veux pas que ceux-ci soient suivis.

Je suis conscient que je pourrais (devrait peut-être) faire en sorte que tous ces fichiers soient placés dans un sous-dossier séparé dans le projet, car je pourrais alors simplement ignorer le dossier.

Cependant, existe-t-il un moyen possible de conserver les fichiers de sortie à la racine de l'arborescence du projet et d'utiliser .gitignore pour ignorer tout sauf les fichiers que je suis avec Git? Quelque chose comme

# Ignore everything
*

# But not these files...
script.pl
template.latex
# etc...

Un préfixe facultatif !qui annule le modèle; tout fichier correspondant exclu par un modèle précédent sera à nouveau inclus. Si un modèle annulé correspond, cela remplacera les sources de modèles de priorité inférieure.

# Ignore everything
*

# But not these files...
!.gitignore
!script.pl
!template.latex
# etc...

# ...even if they are in subdirectories
!*/

# if the files to be tracked are in subdirectories
!*/a/b/file1.txt
!*/a/b/c/*

Si vous souhaitez ignorer tout le contenu d'un répertoire, sauf un fichier à l'intérieur, vous pouvez écrire une paire de règles pour chaque répertoire dans le chemin du fichier. Par exemple .gitignore pour ignorer le dossier pippo sauf de pippo / pluto / paperino.xml

.gitignore

pippo/*
!pippo/pluto
pippo/pluto/*
!pippo/pluto/paperino.xml

Vous souhaitez utiliser à la /*place *ou */dans la plupart des cas

L'utilisation *est valide, mais elle fonctionne récursivement. Il ne cherchera plus dans les répertoires à partir de ce moment. Les gens recommandent d'utiliser !*/à nouveau la liste blanche des répertoires, mais il est en fait préférable de mettre sur liste noire le dossier de plus haut niveau avec/*

# Blacklist files/folders in same directory as the .gitignore file
/*

# Whitelist some files
!.gitignore
!README.md

# Ignore all files named .DS_Store or ending with .log
**/.DS_Store
**.log

# Whitelist folder/a/b1/ and folder/a/b2/
# trailing "/" is optional for folders, may match file though.
# "/" is NOT optional when followed by a *
!folder/
folder/*
!folder/a/
folder/a/*
!folder/a/b1/
!folder/a/b2/
!folder/a/file.txt

# Adding to the above, this also works...
!/folder/a/deeply
/folder/a/deeply/*
!/folder/a/deeply/nested
/folder/a/deeply/nested/*
!/folder/a/deeply/nested/subfolder

Le code ci - dessus ne tiendrait pas compte de tous les fichiers à l' exception .gitignore, README.md, folder/a/file.txt, folder/a/b1/et folder/a/b2/et tout le contenu de ces deux derniers dossiers. (Et les fichiers .DS_Storeet *.logseraient ignorés dans ces dossiers.)

Évidemment, je pourrais faire par exemple !/folderou !/.gitignoretrop.

Plus d'informations: http://git-scm.com/docs/gitignore

Un peu plus précis:

Exemple: Ignorez tout webroot/cache- mais gardez webroot/cache/.htaccess.

Remarquez la barre oblique (/) après le cachedossier:

ÉCHOUE

webroot/cache*
!webroot/cache/.htaccess

TRAVAUX

webroot/cache/*
!webroot/cache/.htaccess

# ignore these
*
# except foo
!foo

Pour ignorer certains fichiers d'un répertoire, vous devez le faire dans le bon ordre :

Par exemple, ignorez tout dans le dossier "application" sauf index.php et le dossier "config" faites attention à la commande .

Vous devez nier ce que vous voulez d'abord.

ÉCHOUE

application/*

!application/config/*

!application/index.php

TRAVAUX

!application/config/*

!application/index.php

application/*

Vous pouvez utiliser git config status.showUntrackedFiles noet tous les fichiers non suivis vous seront cachés. Voir man git-configpour plus de détails.

Pour exclure un dossier de .gitignore, les opérations suivantes peuvent être effectuées.

!app/

app/*
!app/bower_components/

app/bower_components/*
!app/bower_components/highcharts/

Cela ignorera tous les fichiers / sous-dossiers à l'intérieur à l' bower_componentsexception de /highcharts.

Il y a un tas de questions similaires à ce sujet, donc je posterai ce que j'ai écrit avant:

La seule façon de faire fonctionner cela sur ma machine était de le faire de cette façon:

# Ignore all directories, and all sub-directories, and it's contents:
*/*

#Now ignore all files in the current directory 
#(This fails to ignore files without a ".", for example 
#'file.txt' works, but 
#'file' doesn't):
*.*

#Only Include these specific directories and subdirectories and files if you wish:
!wordpress/somefile.jpg
!wordpress/
!wordpress/*/
!wordpress/*/wp-content/
!wordpress/*/wp-content/themes/
!wordpress/*/wp-content/themes/*
!wordpress/*/wp-content/themes/*/*
!wordpress/*/wp-content/themes/*/*/*
!wordpress/*/wp-content/themes/*/*/*/*
!wordpress/*/wp-content/themes/*/*/*/*/*

Remarquez comment vous devez autoriser explicitement le contenu pour chaque niveau que vous souhaitez inclure. Donc, si j'ai des sous-répertoires 5 sous les thèmes, je dois encore le préciser.

Ceci est du commentaire de @ Yarin ici: https://stackoverflow.com/a/5250314/1696153

Ces sujets étaient utiles:

• Comment fonctionnent les modèles niés dans .gitignore?
• Comment fonctionnent les règles d'exclusion de gitignore?

J'ai aussi essayé

*
*/*
**/**

et **/wp-content/themes/**

ou /wp-content/themes/**/*

Rien de tout cela n'a fonctionné pour moi non plus. Beaucoup de traces et d'erreurs!

J'ai eu un problème avec le sous-dossier.

Ne marche pas:

/custom/*
!/custom/config/foo.yml.dist

Travaux:

/custom/config/*
!/custom/config/foo.yml.dist

J'ai essayé toutes les réponses ci-dessus, mais aucune n'a fonctionné pour moi. Après avoir lu la documentation de gitignore ( ici ), j'ai découvert que si vous excluez d'abord un dossier, les noms de fichiers dans le sous-dossier ne sont pas indexés. Donc, si vous utilisez le point d'exclamation par la suite pour inclure un fichier, il ne se trouve pas dans l'index et n'est donc pas inclus dans votre client git.

C'était le moyen de trouver la solution. J'ai commencé par ajouter des exceptions pour tous les sous-dossiers de mon arborescence de dossiers pour le faire fonctionner, ce qui est un sacré travail. Par la suite, j'ai pu compacter la configuration détaillée dans la configuration ci-dessous, ce qui est un peu contraire à la documentation.

.Gitignore de travail:

# Ignore the 'Pro' folder, except for the '3rdparty' subfolder 
/Pro/*
!Pro/3rdparty/

# Ignore the '3rdparty' folder, except for the 'domain' subfolder
/Pro/3rdparty/*
!Pro/3rdparty/domain/

# Ignore the 'domain' folder, except for the 'modulename' subfolder
Pro/3rdparty/domain/*
!Pro/3rdparty/domain/modulename/

En conséquence, je vois dans mon client git que seuls les deux fichiers à l'intérieur du dossier Pro / 3rdparty / domain / modulename / sont mis en scène pour le prochain commit, et c'est exactement ce que je cherchais.

Et si vous devez ajouter à la liste blanche plusieurs sous-dossiers du même dossier, regroupez les lignes de point d'exclamation sous l'instruction exclude comme ceci:

# Ignore the 'Pro' folder, except for the '3rdparty' subfolder 
/Pro/*
!Pro/3rdparty/

# Ignore the '3rdparty' folder, except for the 'domain' & 'hosting' subfolders
/Pro/3rdparty/*
!Pro/3rdparty/domain/
!Pro/3rdparty/hosting/

# Ignore the 'domain' folder, except for the 'modulename' subfolder
Pro/3rdparty/domain/*
!Pro/3rdparty/domain/modulename/

# Ignore the 'hosting' folder, except for the 'modulename' subfolder
Pro/3rdparty/hosting/*
!Pro/3rdparty/hosting/modulename/

Sinon, cela ne fonctionnera pas comme prévu.

C'est ce qui a fonctionné pour moi, je voulais engager un seul plugin Cordova dans le repo:

...
plugins/*
!plugins/cordova-plugin-app-customization

Je sais que je suis en retard pour la fête, mais voici ma réponse.

Comme l'a dit @Joakim, pour ignorer un fichier, vous pouvez utiliser quelque chose comme ci-dessous.

# Ignore everything
*

# But not these files...
!.gitignore
!someFile.txt

mais si le fichier se trouve dans des répertoires imbriqués, il est un peu difficile d'écrire manuellement les règles.

Par exemple, si nous voulons ignorer tous les fichiers d'un gitprojet, mais pas ceux a.txtqui se trouvent dans aDir/anotherDir/someOtherDir/aDir/bDir/cDir. Ensuite, notre .gitignoresera quelque chose comme ça

# Skip all files
*

# But not `aDir/anotherDir/someOtherDir/aDir/bDir/cDir/a.txt`
!aDir/
aDir/*
!aDir/anotherDir/
aDir/anotherDir/*
!aDir/anotherDir/someOtherDir/
aDir/anotherDir/someOtherDir/*
!aDir/anotherDir/someOtherDir/aDir/
aDir/anotherDir/someOtherDir/aDir/*
!aDir/anotherDir/someOtherDir/aDir/bDir/
aDir/anotherDir/someOtherDir/aDir/bDir/*
!aDir/anotherDir/someOtherDir/aDir/bDir/cDir/
aDir/anotherDir/someOtherDir/aDir/bDir/cDir/*
!aDir/anotherDir/someOtherDir/aDir/bDir/cDir/a.txt

Le .gitignorefichier donné ci-dessus sautera tous les répertoires et fichiers sauf!aDir/anotherDir/someOtherDir/aDir/bDir/cDir/a.txt

Comme vous l'avez peut-être remarqué, il est difficile de définir ces règles.

Pour résoudre cet obstacle, j'ai créé une application console simple nommée git-do-not-ignore qui générera les règles pour vous. J'ai hébergé le projet dans github avec des instructions détaillées.

Exemple d'utilisation

java -jar git-do-not-ignore.jar "aDir/anotherDir/someOtherDir/aDir/bDir/cDir/a.txt"

Production

!aDir/
aDir/*
!aDir/anotherDir/
aDir/anotherDir/*
!aDir/anotherDir/someOtherDir/
aDir/anotherDir/someOtherDir/*
!aDir/anotherDir/someOtherDir/aDir/
aDir/anotherDir/someOtherDir/aDir/*
!aDir/anotherDir/someOtherDir/aDir/bDir/
aDir/anotherDir/someOtherDir/aDir/bDir/*
!aDir/anotherDir/someOtherDir/aDir/bDir/cDir/
aDir/anotherDir/someOtherDir/aDir/bDir/cDir/*
!aDir/anotherDir/someOtherDir/aDir/bDir/cDir/a.txt

Il existe également une version Web simple disponible ici

Je vous remercie.

J'ai Jquery et Angular de bower. Bower les a installés dans

/public_html/bower_components/jquery/dist/bunch-of-jquery-files
/public_html/bower_components/jquery/src/bunch-of-jquery-source-files
/public_html/bower_components/angular/angular-files

Le jquery minimisé est à l'intérieur du distrépertoire et angular est à l'intérieur du angularrépertoire. Je n'avais besoin que de fichiers réduits pour être validés sur github. Quelques manipulations avec .gitignore et c'est ce que j'ai réussi à conjurer ...

/public_html/bower_components/jquery/*
!public_html/bower_components/jquery/dist
/public_html/bower_components/jquery/dist/*
!public_html/bower_components/jquery/dist/jquery.min.js
/public_html/bower_components/angular/*
!public_html/bower_components/angular/angular.min.js

J'espère que quelqu'un pourrait trouver cela utile.

Voici comment je l'ai fait:

# Ignore everything
*

# Whitelist anything that's a directory
!*/

# Whitelist some files
!.gitignore

# Whitelist this folder and everything inside of it
!wordpress/wp-content/themes/my-theme/**

# Ignore this folder inside that folder
wordpress/wp-content/themes/my-theme/node_modules

# Ignore this file recursively
**/.DS_Store

Utilisez gig status -upour afficher les fichiers individuels dans les répertoires non suivis de manière récursive - avec git statusvous ne verriez que les dossiers, ce qui pourrait vous induire en erreur en pensant que tout ce qui s'y trouve a été suivi

Solution simple si vous devez tout ignorer sauf quelques fichiers et quelques dossiers racine :

/*
!.gitignore
!showMe.txt
!my_visible_dir

La magie est /*(comme décrit ci-dessus), elle ignore tout dans le dossier (racine) MAIS PAS récursivement.

J'ai également eu quelques problèmes avec la négation de fichiers uniques. J'ai pu les valider, mais mon IDE (IntelliJ) s'est toujours plaint des fichiers ignorés, qui sont suivis.

git ls-files -i --exclude-from .gitignore

Affichage des deux fichiers, que j'ai exclus de cette façon:

public/
!public/typo3conf/LocalConfiguration.php
!public/typo3conf/PackageStates.php

En fin de compte, cela a fonctionné pour moi:

public/*
!public/typo3conf/
public/typo3conf/*
!public/typo3conf/LocalConfiguration.php
!public/typo3conf/PackageStates.php

La clé était d'abord la négation du dossier typo3conf/ .

De plus, il semble que l'ordre des déclarations n'a pas d'importance . Au lieu de cela, vous devez annuler explicitement tous les sous-dossiers, avant de pouvoir annuler des fichiers uniques.

Le dossier !public/typo3conf/et le contenu du dossier public/typo3conf/*sont deux choses différentes pour .gitignore.

Excellent fil! Ce problème m'a dérangé pendant un certain temps;)

Jusqu'à présent, rien n'a fonctionné pour moi car j'essayais d'ajouter un pot de lib.

Cela n'a pas fonctionné:

build/*
!build/libs/*
!build/libs/
!build/libs/myjarfile.jar 

Cela a fonctionné:

build/*
!build/libs

J'ai ce travail

# Vendor
/vendor/braintree/braintree_php/*
!/vendor/braintree/braintree_php/lib

Avait le même problème que OP mais aucune des 10 meilleures réponses votées n'a vraiment fonctionné .
J'ai finalement découvert ce qui suit

Mauvaise syntaxe:

*
!bin/script.sh

Syntaxe correcte:

*
!bin
!bin/script.sh

Explication de la page de manuel de gitignore :

Un préfixe optionnel "!" ce qui annule le motif; tout fichier correspondant exclu par un modèle précédent sera à nouveau inclus. Il n'est pas possible de ré-inclure un fichier si un répertoire parent de ce fichier est exclu . Git ne répertorie pas les répertoires exclus pour des raisons de performances, donc tous les modèles sur les fichiers contenus n'ont aucun effet, peu importe où ils sont définis.

Exemple étendu:

$ arbre.

.
├── .gitignore
└── bin
    ├── ignore.txt
    └── sub
        └── folder
            └── path
                ├── other.sh
                └── script.sh

$ cat .gitignore

*
!.gitignore
!bin
!bin/sub
!bin/sub/folder
!bin/sub/folder/path
!bin/sub/folder/path/script.sh

$ git status --untracked-files --ignored

On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        .gitignore
        bin/sub/folder/path/script.sh

Ignored files:
  (use "git add -f <file>..." to include in what will be committed)
        bin/ignore.txt
        bin/sub/folder/path/other.sh

nothing added to commit but untracked files present (use "git add" to track)

Essentiel

# Ignore everything
*

# But not these files...
!script.pl
!template.latex

Et probablement inclure:

!.gitignore

Référence

Depuis https://git-scm.com/docs/gitignore :

Un préfixe facultatif " !" qui annule le modèle; tout fichier correspondant exclu par un modèle précédent sera à nouveau inclus. Il n'est pas possible de ré-inclure un fichier si un répertoire parent de ce fichier est exclu. Git ne répertorie pas les répertoires exclus pour des raisons de performances, donc tous les modèles sur les fichiers contenus n'ont aucun effet, peu importe où ils sont définis. Mettez une barre oblique inversée (" \") devant le premier " !" pour les motifs qui commencent par un " !" littéral , par exemple, " \!important!.txt".

...

Exemple pour tout exclure sauf un répertoire spécifique foo/bar(notez le /*- sans la barre oblique, le caractère générique exclurait également tout ce qu'il contient foo/bar):

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

Il me semble avoir trouvé quelque chose qui a fonctionné pour moi et que personne d'autre n'a mentionné.

# Ignore everything
*

# But not these files...
!.gitignore
!script.pl
!template.latex
# etc...

# And if you want to include a sub-directory and all sub-directory and files under it, but not all sub-directories
!subdir/
!subdir/**/*

Fondamentalement, cela semble empêcher un sous-répertoire d'être ignoré, vous devez avoir deux entrées, une pour le sous-répertoire lui-même !subdir/, puis une autre qui s'étend à tous les fichiers et dossiers sous-jacents!subdir/**/*