Comment puis-je ajouter un répertoire vide à un référentiel Git?

https://stackoverflow.com/questions/115983

02-07-2019
|

Question

Comment puis-je ajouter un répertoire vide (qui ne contient aucun fichier) à un référentiel Git?

La solution

Une autre façon de rendre un répertoire (presque) vide (dans le référentiel) consiste à créer un fichier .gitignore à l'intérieur de ce répertoire contenant ces quatre lignes:

# Ignore everything in this directory
*
# Except this file
!.gitignore

Dans ce cas, il n'est pas nécessaire que la commande soit conforme à la solution de m104. <

Cela donne également l'avantage que les fichiers de ce répertoire ne s'afficheront pas sous la forme " non suivi " quand vous faites un statut git.

Rendre le commentaire de @GreenAsJade persistant:

Je pense que cela vaut la peine de noter que cette solution répond précisément à la question posée, mais n’est peut-être pas ce que beaucoup de personnes qui auront consulté cette question auront cherché. Cette solution garantit que le répertoire reste vide. Il indique & «Je ne veux vraiment jamais que les fichiers soient archivés ici &». Contrairement à & "Je n'ai pas encore de fichiers à enregistrer ici, mais j'ai besoin du répertoire ici, les fichiers risquent de revenir plus tard &";.

Autres conseils

Vous ne pouvez pas. Consultez la FAQ sur Git .

Actuellement, la conception de l'index git   (zone de transit) permet uniquement aux fichiers de   être répertorié, et personne assez compétent   faire le changement pour permettre vide   répertoires a assez pris soin de   cette situation pour y remédier.

Les répertoires sont ajoutés automatiquement   lors de l'ajout de fichiers à l'intérieur. Cette   est, les annuaires ne doivent jamais être ajoutés   au référentiel, et ne sont pas suivis   seuls.

Vous pouvez dire " git add <dir> " et cela   ajoutera des fichiers à cet endroit.

Si vous avez vraiment besoin d’un répertoire pour   existent dans les caisses, vous devez créer un   déposer dedans. .gitignore fonctionne bien pour   Cet objectif; vous pouvez le laisser vide,   ou remplissez les noms des fichiers que vous   attendez-vous à apparaître dans le répertoire.

Créez un fichier vide appelé .gitkeep dans le répertoire et ajoutez-le.

Vous pouvez toujours mettre un fichier README dans le répertoire avec une explication de la raison pour laquelle vous souhaitez créer ce répertoire, sinon vide, dans le référentiel.

touch .keep

Sous Linux, cela crée un fichier vide nommé .keep. Ce nom est préféré à .gitkeep car le premier est agnostique par rapport à Git, alors que le dernier est spécifique à Git. Deuxièmement, comme un autre utilisateur l’a noté, la .git convention de préfixe devrait être réservée aux fichiers et aux répertoires utilisés par Git.

Sinon, comme indiqué dans une autre answer , le répertoire peut contenir une description README ou README.md fichier à la place.

Bien entendu, cela nécessite que la présence du fichier ne provoque pas la rupture de votre application.

Pourquoi aurions-nous besoin de dossiers versionnés vides

Premières choses d'abord:

Un répertoire vide ne peut pas faire partie d'un arbre sous le système de gestion de versions Git .

Cela ne fera tout simplement pas l'objet d'un suivi. Mais il existe des scénarios dans lesquels & Quot; versioning & Quot; les répertoires vides peuvent avoir un sens, par exemple:

échafaudez une structure de dossiers prédéfinie , en la mettant à la disposition de chaque utilisateur / contributeur du référentiel; ou, en tant que cas spécialisé de ce qui précède, créer un dossier pour fichiers temporaires , tel qu'un cache/ ou logs/ répertoire, où nous souhaitons fournir le dossier mais .gitignore son contenu
En rapport avec ce qui précède, certains projets ne fonctionneront pas sans certains dossiers (ce qui est souvent le signe d'un projet mal conçu, mais il s'agit souvent d'un scénario réel et peut-être, problèmes de permission à résoudre).

Quelques solutions de contournement suggérées

De nombreux utilisateurs suggèrent:

Placer un fichier README ou un autre fichier avec du contenu afin de rendre le répertoire non vide, ou
Créer un fichier .gitkeep avec une sorte de " logique inverse " (c’est-à-dire d’inclure tous les fichiers) qui, à la fin, a le même objectif que la première approche.

Bien que les deux solutions fonctionnent sûrement , je les trouve incompatibles avec une approche significative du contrôle de version Git.

Pourquoi êtes-vous censé mettre des fichiers ou des fichiers README erronés que vous ne voulez peut-être pas vraiment dans votre projet?
Pourquoi utiliser <=> pour faire (conserver des fichiers ) est tout le contraire de ce que cela signifie (fichiers exclure ), même si cela est possible ?

approche .gitkeep

Utilisez un fichier vide nommé <=> afin de forcer la présence du dossier dans le système de gestion des versions.

Bien que cela ne semble pas être une si grande différence:

Vous utilisez un fichier qui a pour but de conserver le dossier unique . Vous n'y mettez aucune information que vous ne voulez pas mettre.

Par exemple, vous devriez utiliser les fichiers README comme des informations utiles, pas comme une excuse pour conserver le dossier.

La séparation des problèmes est toujours une bonne chose, et vous pouvez toujours ajouter un <=> pour ignorer les fichiers indésirables.
Le nommer <=> le rend très clair et simple à partir du nom de fichier lui-même (ainsi que pour les autres développeurs , ce qui est bon pour un projet partagé et l'un des objectifs principaux d'un Référentiel Git) que ce fichier est
- Un fichier non lié au code (en raison du point et du nom)
- Un fichier clairement lié à Git
- Son but ( garder ) est clairement énoncé, cohérent et opposé sémantiquement dans sa signification de ignorer

Adoption

J'ai constaté l'approche <=> adoptée par des infrastructures très importantes telles que Laravel , Angular-CLI .

Comme décrit dans d'autres réponses, Git n'est pas en mesure de représenter des répertoires vides dans sa zone d'activation. (Voir la FAQ sur les Git .) Toutefois, si, pour votre Pour être précis, un répertoire est suffisamment vide s'il contient un fichier .gitignore uniquement. Vous pouvez alors créer <=> des fichiers dans des répertoires vides uniquement via:

find . -type d -empty -exec touch {}/.gitignore \;

Andy Lester a raison, mais si votre répertoire doit simplement être vide et non pas vide , vous pouvez y placer un fichier .gitignore vide comme solution de contournement.

Soit dit en passant, il s’agit d’un problème de mise en oeuvre, et non de problème fondamental de conception du stockage Git. Comme cela a été mentionné à maintes reprises sur la liste de diffusion Git, la raison pour laquelle cela n'a pas été implémenté est que personne ne s'est assez soucié de soumettre un correctif pour ce correctif, non pas & # 8217; t ou ne devrait pas & # 8217; t être fait.

La méthode Ruby on Rails pour la création d'un dossier de journal:

mkdir log && touch log/.gitkeep && git add log/.gitkeep

Le répertoire des journaux sera maintenant inclus dans l’arborescence. C’est très utile lors du déploiement, vous n’aurez donc pas à écrire de routine pour créer des répertoires de journaux.

Les fichiers journaux peuvent être conservés en émettant,

echo log/dev.log >> .gitignore

mais vous le saviez probablement.

Git ne suit pas les répertoires vides. Voir la FAQ sur Git pour plus d'explications. La solution de contournement recommandée consiste à placer un fichier .gitignore dans le répertoire vide. Je n’aime pas cette solution, car le <=> est & "Caché &"; par convention Unix. De plus, il n'y a pas d'explication sur la raison pour laquelle les répertoires sont vides.

Je suggère de placer un fichier README dans le répertoire vide pour expliquer pourquoi le répertoire est vide et pourquoi il doit être suivi dans Git. Avec le fichier README en place, le répertoire n'est plus vide pour Git.

La vraie question est pourquoi avez-vous besoin du répertoire vide dans git? Habituellement, vous avez une sorte de script de construction capable de créer le répertoire vide avant la compilation / l'exécution. Sinon, faites-en un. C’est une bien meilleure solution que de mettre des répertoires vides dans git.

Vous avez donc une raison pour laquelle vous avez besoin d’un répertoire vide dans git. Mettez cette raison dans le fichier README. De cette façon, les autres développeurs (et vous-même, à l'avenir) savent pourquoi le répertoire vide doit être présent. Vous saurez également que vous pouvez supprimer le répertoire vide lorsque le problème qui l'exige est résolu.

Pour répertorier chaque répertoire vide, utilisez la commande suivante:

find -name .git -prune -o -type d -empty -print

Pour créer des fichiers README réservés dans chaque répertoire vide:

find -name .git -prune -o -type d -empty -exec sh -c \
  "echo this directory needs to be empty because reasons > {}/README.emptydir" \;

Pour ignorer tout le répertoire, à l'exception du fichier README, insérez les lignes suivantes dans votre <=>:

path/to/emptydir/*
!path/to/emptydir/README.emptydir
path/to/otheremptydir/*
!path/to/otheremptydir/README.emptydir

Sinon, vous pouvez simplement exclure tous les fichiers README du fichier ignoré:

path/to/emptydir/*
path/to/otheremptydir/*
!README.emptydir

Pour répertorier tous les fichiers README après leur création:

find -name README.emptydir

AVERTISSEMENT: ce tweak ne fonctionne pas vraiment. Désolé pour le désagrément.

Message original ci-dessous:

J'ai trouvé une solution en jouant avec les internes de Git!

Supposons que vous soyez dans votre référentiel.
Créez votre répertoire vide:
```
$ mkdir path/to/empty-folder
```
Ajoutez-le à l'index à l'aide d'une commande de plomberie et de l'arborescence vide SHA-1 :
```
$ git update-index --index-info
040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904    path/to/empty-folder
```
Tapez la commande puis entrez la deuxième ligne. Appuyez sur Entrée , puis sur Ctrl + D pour mettre fin à votre saisie. Remarque: le format est mode [ESPACE] type [ESPACE] SHA-1hash [TAB] (l'onglet est important, le format de réponse ne le conserve pas).
C'est ça! Votre dossier vide est dans votre index. Tout ce que vous avez à faire est de vous engager.

Cette solution est courte et semble fonctionner correctement ( voir l'EDIT! ), mais ce n'est pas si facile à retenir ...

L'arborescence vide SHA-1 peut être trouvée en créant un nouveau référentiel Git vide, cd dans celui-ci et en émettant git write-tree, qui génère l'arborescence vide SHA-1.

EDIT:

J'utilise cette solution depuis que je l'ai trouvée. Cela semble fonctionner exactement de la même manière que pour créer un sous-module, à la différence qu'aucun module n'est défini nulle part. Cela entraîne des erreurs lors de l’émission git submodule init|update. Le problème est que git update-index réécrit la 040000 tree partie dans 160000 commit.

De plus, aucun fichier placé sous ce chemin ne sera remarqué par Git, car il pense appartenir à un autre référentiel. C'est méchant car on peut facilement l'ignorer!

Cependant, si vous n’utilisez pas déjà (et n’allez pas) utiliser de sous-modules Git dans votre référentiel, le & "; vide &"; Le dossier restera vide ou si vous voulez que Git connaisse son existence et ignore son contenu, vous pouvez utiliser ce réglage. Aller de la manière habituelle avec les sous-modules prend plus de pas que ce tweak.

Peut-être que l'ajout d'un répertoire vide semble être le chemin de moindre résistance , car vous avez des scripts qui supposent que ce répertoire existe (peut-être parce qu'il s'agit d'une cible pour les fichiers binaires générés). Une autre approche consiste à modifier vos scripts pour créer le répertoire selon vos besoins .

mkdir --parents .generated/bin ## create a folder for storing generated binaries
mv myprogram1 myprogram2 .generated/bin ## populate the directory as needed

Dans cet exemple, vous pouvez insérer un lien symbolique (brisé) dans le répertoire afin de pouvoir y accéder sans le & "; generated &"; préfixe (mais cela est facultatif).

ln -sf .generated/bin bin
git add bin

Lorsque vous souhaitez nettoyer votre arborescence source, vous pouvez simplement:

rm -rf .generated ## this should be in a "clean" script or in a makefile

Si vous adoptez l’approche souvent suggérée consistant à archiver un dossier presque vide, vous aurez la complexité mineure de supprimer le contenu sans supprimer également le & "; .gitignore &"; fichier.

Vous pouvez ignorer tous vos fichiers générés en ajoutant ce qui suit à votre racine .gitignore:

.generated

Supposons qu'il vous faut un répertoire vide nommé tmp :

$ mkdir tmp
$ touch tmp/.gitignore
$ git add tmp
$ echo '*' > tmp/.gitignore
$ git commit -m 'Empty directory' tmp

En d'autres termes, vous devez ajouter le fichier .gitignore à l'index avant de pouvoir dire à Git de l'ignorer (et de tout le reste du répertoire vide).

J'ai également été confronté au problème des répertoires vides. Le problème avec l'utilisation de fichiers d'espaces réservés, c'est que vous devez les créer et les supprimer s'ils ne sont plus nécessaires (car plus tard, des sous-répertoires ou des fichiers ont été ajoutés. Avec de grandes arborescences source, la gestion de ces fichiers d'espaces réservés peut s'avérer fastidieuse et erronée. enclin.

C’est pourquoi j’ai décidé d’écrire un outil open source permettant de gérer automatiquement la création / suppression de tels fichiers réservés. Il est écrit pour la plate-forme .NET et fonctionne sous Mono (.NET pour Linux) et Windows.

Il suffit de regarder: http://code.google.com/p/markemptydirs

Vous ne pouvez pas et ne pourrez jamais, malheureusement. C'est une décision prise par Linus Torvald lui-même. Il sait ce qui est bon pour nous.

Il y a un coup de gueule quelque part que j'ai lu une fois.

J'ai trouvé des répertoires Re: Empty .. , mais peut-être existe-t-il un autre.

Vous devez vivre avec les solutions de contournement ... malheureusement.

J'aime les réponses de @ Artur79 et @mjs. J'ai donc utilisé une combinaison des deux et en ai fait un standard pour nos projets.

find . -type d -empty -exec touch {}/.gitkeep \;

Cependant, seuls quelques développeurs travaillent sur Mac ou Linux. Beaucoup de travail sur Windows et je ne pouvais pas trouver un équivalent simple one-liner pour accomplir la même chose là-bas. Certains ont eu la chance d’avoir Cygwin installé pour d’autres raisons, mais le fait de prescrire Cygwin pour cette raison semblait excessif.

Modifier pour une meilleure solution

Donc, comme la plupart de nos développeurs ont déjà installé Ant , la première chose à laquelle j'ai pensé était de: mettre en place un fichier de construction Ant pour accomplir cela indépendamment de la plate-forme. On peut toujours le trouver ici

Cependant , j'ai ensuite pensé qu'il serait préférable d'en faire une petite commande d'utilitaire. Je l'ai donc recréée à l'aide de Python et l'ai publiée dans le fichier PyPI ici . Vous pouvez l'installer en exécutant simplement:

pip3 install gitkeep2

Cela vous permettra de créer et de supprimer .gitkeep des fichiers de manière récursive, ainsi que de leur ajouter des messages pour que vos pairs puissent comprendre pourquoi ces répertoires sont importants. Ce dernier bit est un bonus. Je pensais que ce serait bien si les <=> fichiers pouvaient être auto-documentés.

$ gitkeep --help
Usage: gitkeep [OPTIONS] PATH

  Add a .gitkeep file to a directory in order to push them into a Git repo
  even if they're empty.

  Read more about why this is necessary at: https://git.wiki.kernel.org/inde
  x.php/Git_FAQ#Can_I_add_empty_directories.3F

Options:
  -r, --recursive     Add or remove the .gitkeep files recursively for all
                      sub-directories in the specified path.
  -l, --let-go        Remove the .gitkeep files from the specified path.
  -e, --empty         Create empty .gitkeep files. This will ignore any
                      message provided
  -m, --message TEXT  A message to be included in the .gitkeep file, ideally
                      used to explain why it's important to push the specified
                      directory to source control even if it's empty.
  -v, --verbose       Print out everything.
  --help              Show this message and exit.

J'espère que vous le trouverez utile.

Lorsque vous ajoutez un fichier .gitignore, si vous souhaitez y insérer une quantité de contenu (que vous souhaitez que Git ignore), vous pouvez ajouter une seule ligne avec uniquement un astérisque * pour vous assurer que vous n'ajoutez pas le contenu ignoré accidentellement.

Comme mentionné, il n'est pas possible d'ajouter des répertoires vides, mais voici une ligne qui ajoute des fichiers .gitignore vides à tous les répertoires.

ruby -e 'require "fileutils" ; Dir.glob(["target_directory","target_directory/**"]).each { |f| FileUtils.touch(File.join(f, ".gitignore")) if File.directory?(f) }'

J'ai collé ceci dans un fichier Rakefile pour un accès facile.

La solution de Jamie Flournoy fonctionne très bien. Voici une version un peu améliorée pour conserver le .htaccess:

# Ignore everything in this directory
*
# Except this file
!.gitignore
!.htaccess

Cette solution vous permet de valider un dossier vide, par exemple /log, /tmp ou /cache et le dossier restera vide.

Je crée toujours une fonction pour vérifier la structure de dossiers souhaitée et la construire pour moi dans le projet. Cela résout ce problème car les dossiers vides sont conservés dans Git par proxy.

function check_page_custom_folder_structure () {
    if (!is_dir(TEMPLATEPATH."/page-customs"))
        mkdir(TEMPLATEPATH."/page-customs");    
    if (!is_dir(TEMPLATEPATH."/page-customs/css"))
        mkdir(TEMPLATEPATH."/page-customs/css");
    if (!is_dir(TEMPLATEPATH."/page-customs/js"))
        mkdir(TEMPLATEPATH."/page-customs/js");
}

C’est en PHP, mais je suis sûr que la plupart des langages prennent en charge les mêmes fonctionnalités, et comme la création des dossiers est prise en charge par l’application, les dossiers seront toujours présents.

Voici un hack, mais c’est marrant que ça marche (Git 2.2.1). Similaire à ce que @Teka a suggéré, mais plus facile à retenir:

Ajouter un sous-module à un référentiel (git submodule add path_to_repo)
Ceci ajoutera un dossier et un fichier .submodules. Valider un changement.
Supprimez <=> le fichier et validez la modification.

Vous avez maintenant un répertoire qui est créé lorsque la validation est extraite. Une chose intéressante est que si vous regardez le contenu de l’arborescence de ce fichier, vous obtiendrez:

fatal: nom d'objet non valide b64338b90b4209263b50244d18278c0999867193

Je n’encouragerais cependant pas à l’utiliser, car il pourrait ne plus fonctionner dans les futures versions de Git. Ce qui peut laisser votre référentiel corrompu.

Il n’existe aucun moyen de permettre à Git de suivre les répertoires. La seule solution consiste donc à ajouter un fichier d’espace réservé dans le répertoire que Git doit suivre.

Le fichier peut être nommé et contenir tout ce que vous voulez, mais la plupart des gens utilisent un fichier vide nommé .gitkeep (bien que certaines personnes préfèrent le VCS-agnostic .keep).

Le préfixe . le marque comme un fichier caché.

Une autre idée serait d’ajouter un README fichier expliquant l’utilisation du répertoire.

Vous ne pouvez pas. Ceci est une décision de conception intentionnelle prise par les mainteneurs de Git. Fondamentalement, le but d’un système de gestion de code source comme Git est de gérer le code source et les répertoires vides ne sont pas du code source. Git est également souvent décrit comme un suivi de contenu, et encore une fois, les répertoires vides ne sont pas des contenus (bien au contraire, en fait), ils ne sont donc pas suivis.

Si vous souhaitez ajouter un dossier qui hébergera de nombreuses données transitoires dans plusieurs répertoires sémantiques, une solution consiste à ajouter quelque chose comme ceci à votre racine .gitignore ...

/app/data/**/*.* !/app/data/**/*.md

Ensuite, vous pouvez valider des fichiers README.md descriptifs (ou des fichiers vierges, peu importe, du moment que vous pouvez les cibler de manière unique, comme avec *.md dans ce cas) dans chaque répertoire pour vous assurer qu'ils sont tous conservés. une partie du repo mais les fichiers (avec les extensions) sont conservés ignorés. LIMITATION: . ne sont pas autorisés dans les noms de répertoire!

Vous pouvez remplir tous ces répertoires avec des fichiers xml / images ou autre et ajouter plusieurs répertoires sous /app/data/ au fil du temps, à mesure que le stockage de votre application évolue (avec les fichiers README.md servant à graver une description de chaque répertoire de stockage correspond exactement).

Il n'est pas nécessaire de modifier davantage votre .gitignore ou de le décentraliser en créant un nouveau <=> pour chaque nouveau répertoire. Ce n’est probablement pas la solution la plus intelligente, mais elle est concise en ce qui concerne Gitignore et fonctionne toujours pour moi. Sympa et simple! ;)

Ajouter une option supplémentaire à la mêlée.

En supposant que vous souhaitiez ajouter un répertoire à git qui, pour toutes les raisons liées à .gitignore, doit rester vide et que son contenu ne soit jamais suivi, un * comme suggéré à maintes reprises ici fera l'affaire .

Le format, comme mentionné, est:

*
!.gitignore

Maintenant, si vous voulez un moyen de faire cela en ligne de commande, d'un seul coup, alors que à l'intérieur du répertoire que vous souhaitez ajouter, vous pouvez exécuter:

$ echo "*" > .gitignore && echo '!.gitignore' >> .gitignore && git add .gitignore

Moi-même, j’utilise un script shell pour le faire. Nommez le script comme vous le souhaitez et ajoutez-le quelque part dans votre chemin d'inclusion ou faites-le directement référence:

#!/bin/bash

dir=''

if [ "$1" != "" ]; then
    dir="$1/"
fi

echo "*" > $dir.gitignore && \
echo '!.gitignore' >> $dir.gitignore && \
git add $dir.gitignore

Avec cela, vous pouvez soit l'exécuter à partir du répertoire que vous souhaitez ajouter, soit référencer le répertoire en tant que premier et unique paramètre:

$ ignore_dir ./some/directory

Une autre option (en réponse à un commentaire de @GreenAsJade), si vous souhaitez suivre un dossier vide qui PEUT contenir des fichiers suivis à l'avenir, mais restera vide pour l'instant, vous pouvez omettre Cliquez sur <=> dans le fichier <=> et vérifiez que y est bien entré. En gros, tout le fichier indique & "n'ignorez pas moi " ;, mais sinon, le répertoire est vide et suivi.

Votre <=> fichier ressemblerait à:

!.gitignore

Voilà, vérifiez-le dans et vous avez un répertoire vide, mais suivi, dans lequel vous pourrez suivre les fichiers ultérieurement.

La raison pour laquelle je suggère de garder cette ligne dans le fichier est qu’elle donne le but <=>. Sinon, certains pourraient penser à l'enlever. Cela peut aider si vous placez un commentaire au-dessus de la ligne.

Parfois, vous devez gérer des bibliothèques ou des logiciels mal écrits, qui nécessitent un " vrai " répertoire vide et existant. Mettre un simple .gitignore ou .keep pourrait les casser et causer un bogue. Ce qui suit pourrait aider dans ces cas, mais aucune garantie ...

Créez d'abord le répertoire requis:

mkdir empty

Ensuite, vous ajoutez un lien symbolique brisé à ce répertoire (mais dans tous les cas autres que le cas d'utilisation décrit ci-dessus, veuillez utiliser un README avec une explication):

ln -s .this.directory empty/.keep

Pour ignorer les fichiers de ce répertoire, vous pouvez l'ajouter à la racine <=>:

echo "/empty" >> .gitignore

Pour ajouter le fichier ignoré, utilisez un paramètre pour le forcer:

git add -f empty/.keep

Après la validation, vous avez un lien symbolique cassé dans votre index et git crée le répertoire. Le lien brisé présente certains avantages, car il ne s'agit pas d'un fichier normal et ne pointe vers aucun fichier normal. Donc, cela correspond même à la partie de la question & Quot; (qui ne contient aucun fichier) & Quot ;, non par intention mais par le sens, je suppose:

find empty -type f

Cette commande affiche un résultat vide, car aucun fichier n'est présent dans ce répertoire. Ainsi, la plupart des applications, qui obtiennent tous les fichiers d'un répertoire, ne voient généralement pas ce lien, du moins si elles font un & "Fichier existe &"; ou un " est lisible " ;. Même certains scripts n'y trouveront aucun fichier:

$ php -r "var_export(glob('empty/.*'));"
array (
  0 => 'empty/.',
  1 => 'empty/..',
)

Mais je recommande fortement d’utiliser cette solution uniquement dans des circonstances particulières. Une bonne écriture <=> dans un répertoire vide est généralement une meilleure solution. (Et je ne sais pas si cela fonctionne avec un système de fichiers Windows ...)

Vous pouvez enregistrer ce code sous le nom de create_readme.php et exécuter le code PHP à partir du répertoire racine. de votre projet Git.

> php create_readme.php

Cela ajoutera des fichiers README à tous les répertoires vides afin que ces répertoires soient ensuite ajoutés à l'index.

<?php
    $path = realpath('.');
    $objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path),       RecursiveIteratorIterator::SELF_FIRST);
    foreach($objects as $name => $object){
        if ( is_dir($name) && ! is_empty_folder($name) ){
            echo "$name\n" ;
            exec("touch ".$name."/"."README");
        }
    }

    function is_empty_folder($folder) {
        $files = opendir($folder);
        while ($file = readdir($files)) {
            if ($file != '.' && $file != '..')
                return true; // Not empty
            }
        }
?>

Puis faites

git commit -m "message"
git push

Parfois, j'ai des référentiels avec des dossiers qui ne contiendront jamais que des fichiers considérés comme & "contenu &"; & # 8212; en d'autres termes, ce ne sont pas des fichiers que je tiens à être versionnés, et donc ne devrait jamais être commis. Avec le fichier .gitignore de Git, vous pouvez ignorer des répertoires entiers. Mais il est parfois utile d’avoir le dossier dans le dépôt. Voici une excellente solution pour répondre à ce besoin.

Ce que j'ai fait par le passé est de placer un fichier .gitignore à la racine de mon référentiel, puis d'exclure le dossier, comme suit:

/app/some-folder-to-exclude
/another-folder-to-exclude/*

Cependant, ces dossiers ne font pas partie du référentiel. Vous pouvez ajouter quelque chose comme un fichier README. Mais vous devez ensuite dire à votre application de ne pas s’inquiéter du traitement des fichiers README.

Si votre application dépend des dossiers présents (bien que vides), vous pouvez simplement ajouter un fichier .gitignore au dossier en question et l'utiliser pour atteindre deux objectifs:

Dites à Git qu'il y a un fichier dans le dossier, ce qui oblige Git à l'ajouter au référentiel. Dites à Git d'ignorer le contenu de ce dossier, moins ce fichier lui-même. Voici le fichier .gitignore à mettre dans vos répertoires vides:

*
!.gitignore

La première ligne (*) indique à Git d’ignorer tout ce qui se trouve dans ce répertoire. La deuxième ligne indique à Git de ne pas ignorer le fichier .gitignore. Vous pouvez insérer ce fichier dans tous les dossiers vides que vous souhaitez ajouter au référentiel.

Pour cela, vous pouvez ajouter un fichier .gitkeep au répertoire que vous souhaitez conserver (actuellement) vide.

Voir cette réponse SOF pour plus d'informations - ce qui explique également pourquoi certaines personnes trouvent la convention opposée consistant à ajouter un .gitignore fichier (comme indiqué dans de nombreuses réponses ici) source de confusion.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow