Come posso aggiungere una directory vuota a un repository Git?

Come posso aggiungere una directory vuota (che non contiene file) a un repository Git?

Un altro modo per rendere una directory (quasi) vuota (nel repository) è quello di creare un .gitignorefile all'interno di quella directory che contenga queste quattro righe:

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

Quindi non è necessario ottenere l'ordine nel modo giusto nella soluzione di m104 .

Ciò offre anche il vantaggio che i file in quella directory non verranno visualizzati come "non tracciati" quando si esegue uno stato git.

Rendere persistente il commento di @GreenAsJade :

Penso che valga la pena notare che questa soluzione fa esattamente ciò che la domanda è stata posta, ma forse non è ciò che molte persone che stanno cercando questa domanda avrebbero cercato. Questa soluzione garantisce che la directory rimanga vuota. Dice "Non voglio mai veramente fare il check-in dei file qui". Al contrario di "Non ho ancora nessun file da controllare qui, ma ho bisogno della directory qui, i file potrebbero arrivare più tardi".

Non puoi. Vedi le domande frequenti su Git .

Attualmente la progettazione dell'indice git (area di gestione temporanea) consente solo di elencare i file e nessuno abbastanza competente da apportare la modifica per consentire alle directory vuote di occuparsi di questa situazione abbastanza da rimediare.

Le directory vengono aggiunte automaticamente quando si aggiungono file al loro interno. Cioè, le directory non devono mai essere aggiunte al repository e non vengono tracciate da sole.

Puoi dire " git add <dir>" e aggiungerà i file lì dentro.

Se hai davvero bisogno di una directory per i checkout, devi creare un file al suo interno. .gitignore funziona bene per questo scopo; puoi lasciarlo vuoto o inserire i nomi dei file che ti aspetti di apparire nella directory.

Crea un file vuoto chiamato .gitkeepnella directory e aggiungilo.

È sempre possibile inserire un file README nella directory con una spiegazione del motivo per cui si desidera questa directory, altrimenti vuota, nel repository.

touch .keep

Su Linux, questo crea un file vuoto chiamato .keep. Per quello che vale, questo nome è agnostico per Git, mentre .gitkeepsarebbe specifico per Git. In secondo luogo, come ha notato un altro utente, la .gitconvenzione del prefisso dovrebbe essere riservata ai file e alle directory che Git stesso utilizza.

In alternativa, come indicato in un'altra risposta , la directory può contenere invece un descrittivo READMEo un README.mdfile .

Naturalmente ciò richiede che la presenza del file non causi l'interruzione dell'applicazione.

Perché dovremmo aver bisogno di cartelle vuote con versione

Cominciando dall'inizio:

Una directory vuota non può far parte di un albero nel sistema di versioning Git .

Semplicemente non verrà tracciato. Ma ci sono scenari in cui le directory vuote "versioning" possono essere significative, ad esempio:

• impalcatura di una struttura di cartelle predefinita , rendendola disponibile per ogni utente / collaboratore del repository; o, come caso specializzato di cui sopra, creando una cartella per file temporanei , come una directory cache/o logs/, dove vogliamo fornire la cartella ma il .gitignoresuo contenuto
• in relazione a quanto sopra, alcuni progetti non funzioneranno senza alcune cartelle (che è spesso un suggerimento di un progetto mal progettato, ma è uno scenario del mondo reale frequente e forse potrebbero esserci, diciamo, problemi di autorizzazione da affrontare).

Alcuni suggerimenti suggeriti

Molti utenti suggeriscono:

1. Posizionamento di un READMEfile o di un altro file con alcuni contenuti per rendere la directory non vuota, oppure
2. Creare un .gitignorefile con una sorta di "logica inversa" (cioè includere tutti i file) che, alla fine, ha lo stesso scopo dell'approccio n. 1.

Mentre entrambe le soluzioni sicuramente funzionano, le trovo incompatibili con un approccio significativo al controllo delle versioni di Git.

• Perché dovresti mettere file fasulli o README che forse non vuoi davvero nel tuo progetto?
• Perché usare .gitignoreper fare una cosa ( conservare i file) che è esattamente l'opposto di ciò che significa ( escludere i file), anche se è possibile?

approccio .gitkeep

Utilizzare un file vuoto chiamato .gitkeepper forzare la presenza della cartella nel sistema di controllo delle versioni.

Anche se potrebbe non sembrare una differenza così grande:

• Si utilizza un file che ha il solo scopo di conservare la cartella. Non ci metti nessuna informazione che non vuoi mettere.

  Ad esempio, dovresti usare README come pure README con informazioni utili, non come una scusa per conservare la cartella.

  La separazione delle preoccupazioni è sempre una buona cosa e puoi ancora aggiungere un .gitignoreper ignorare i file indesiderati.

• Denominarlo .gitkeeprende molto chiaro e semplice dal nome del file stesso (e anche ad altri sviluppatori , il che è buono per un progetto condiviso e uno degli scopi principali di un repository Git) che questo file è

  • Un file non correlato al codice (a causa del punto iniziale e del nome)
  • Un file chiaramente correlato a Git
  • Il suo scopo ( mantenere ) è chiaramente dichiarato e coerente e semanticamente opposto nel suo significato da ignorare

Adozione

Ho visto l' .gitkeepapproccio adottato da quadri molto importanti come Laravel , Angular-CLI .

Come descritto in altre risposte, Git non è in grado di rappresentare directory vuote nell'area di gestione temporanea. (Vedi le FAQ di Git .) Tuttavia, se, per i tuoi scopi, una directory è abbastanza vuota se contiene .gitignoresolo un file, puoi creare .gitignorefile in directory vuote solo tramite:

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

Andy Lester ha ragione, ma se la tua directory deve solo essere vuota e non vuota vuota, puoi inserire un .gitignorefile vuoto come soluzione alternativa.

A parte questo, questo è un problema di implementazione, non un problema di progettazione dello storage Git fondamentale. Come è stato menzionato molte volte nella mailing list di Git, la ragione per cui questo non è stato implementato è che nessuno si è preoccupato abbastanza di inviargli una patch, non che non potesse o non avrebbe dovuto essere fatto.

Il modo di creazione della cartella di registro di Ruby on Rails :

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

Ora la directory di registro verrà inclusa nella struttura. È molto utile durante la distribuzione, quindi non sarà necessario scrivere una routine per creare directory di registro.

I file di registro possono essere esclusi emettendo,

echo log/dev.log >> .gitignore

ma probabilmente lo sapevi.

Git non tiene traccia di directory vuote. Vedi le Domande frequenti su Git per ulteriori spiegazioni. La soluzione suggerita è quella di mettere un .gitignorefile nella directory vuota. Non mi piace quella soluzione, perché .gitignoreè "nascosta" dalla convenzione Unix. Inoltre non vi è alcuna spiegazione del perché le directory siano vuote.

Suggerisco di mettere un file README nella directory vuota spiegando perché la directory è vuota e perché deve essere tracciata in Git. Con il file README in atto, per quanto riguarda Git, la directory non è più vuota.

La vera domanda è: perché hai bisogno della directory vuota in git? Di solito hai una sorta di script di compilazione che può creare la directory vuota prima di compilare / eseguire. Altrimenti, creane uno. Questa è una soluzione di gran lunga migliore rispetto a mettere directory vuote in git.

Quindi hai qualche motivo per cui hai bisogno di una directory vuota in git. Inserisci questo motivo nel file README. In questo modo altri sviluppatori (e in futuro tu) sanno perché la directory vuota deve essere lì. Saprai anche che puoi rimuovere la directory vuota quando il problema che richiede la directory vuota è stato risolto.

Per elencare ogni directory vuota, utilizzare il seguente comando:

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

Per creare i README del segnaposto in ogni directory vuota:

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

Per ignorare tutto nella directory tranne il file README, inserisci le seguenti righe nel tuo .gitignore:

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

In alternativa, puoi semplicemente escludere ogni file README dall'ignorare:

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

Per elencare tutti i README dopo che sono già stati creati:

find -name README.emptydir

ATTENZIONE: Questo tweak non funziona davvero come risulta. Ci dispiace per l'inconvenienza.

Post originale qui sotto:

Ho trovato una soluzione giocando con gli interni di Git!

1. Supponi di essere nel tuo repository.

2. Crea la tua directory vuota:

   $ mkdir path/to/empty-folder
   

3. Aggiungilo all'indice usando un comando idraulico e l'albero vuoto SHA-1 :

   $ git update-index --index-info
   040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904    path/to/empty-folder
   

   Digita il comando e quindi inserisci la seconda riga. Premere Entere quindi Ctrl+ Dper terminare l'immissione. Nota: il formato è in modalità [SPACE] tipo [SPACE] SHA-1hash [TAB] percorso (la scheda è importante, la formattazione della risposta non la conserva).

4. Questo è tutto! La tua cartella vuota è nel tuo indice. Tutto quello che devi fare è impegnarti.

Questa soluzione è breve e apparentemente funziona bene ( vedi EDIT! ), Ma non è così facile da ricordare ...

L'albero vuoto SHA-1 può essere trovato creando un nuovo repository Git vuoto, cdin esso ed emissione git write-tree, che genera l'albero vuoto SHA-1.

MODIFICARE:

Sto usando questa soluzione da quando l'ho trovata. Sembra funzionare esattamente come la creazione di un sottomodulo, tranne per il fatto che nessun modulo è definito da nessuna parte. Questo porta ad errori durante l'emissione git submodule init|update. Il problema è che git update-indexriscrive la 040000 treeparte in 160000 commit.

Inoltre, qualsiasi file inserito in quel percorso non verrà mai notato da Git, poiché ritiene che appartengano ad altri repository. Questo è brutto in quanto può essere facilmente trascurato!

Tuttavia, se non hai già (e non vuoi) utilizzare alcun sottomodulo Git nel tuo repository e la cartella "vuota" rimarrà vuota o se vuoi che Git sappia della sua esistenza e ignori il suo contenuto, puoi andare con questo tweak. Seguire la solita maniera con i sottomoduli richiede più passaggi di questo tweak.

Diciamo che hai bisogno di una directory vuota chiamata tmp :

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

In altre parole, è necessario aggiungere il file .gitignore all'indice prima di poter dire a Git di ignorarlo (e tutto il resto nella directory vuota).

Forse l'aggiunta di una directory vuota sembra che sarebbe il percorso di minor resistenza perché hai degli script che prevedono che quella directory esista (forse perché è una destinazione per i binari generati). Un altro approccio sarebbe quello di modificare i tuoi script per creare la directory come necessario .

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

In questo esempio, è possibile archiviare un collegamento simbolico (interrotto) alla directory in modo da potervi accedere senza il prefisso ".generated" (ma questo è facoltativo).

ln -sf .generated/bin bin
git add bin

Quando vuoi ripulire l'albero dei sorgenti puoi semplicemente:

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

Se si adotta l'approccio spesso suggerito per il controllo in una cartella quasi vuota, si ha la minore complessità di eliminare il contenuto senza eliminare anche il file ".gitignore".

Puoi ignorare tutti i tuoi file generati aggiungendo quanto segue al tuo .gitignore root:

.generated

Ho affrontato il problema anche con directory vuote. Il problema con l'utilizzo dei file segnaposto è che è necessario crearli ed eliminarli, se non sono più necessari (perché in seguito sono stati aggiunti sottodirectory o file. Con alberi di origine di grandi dimensioni la gestione di questi file segnaposto può essere ingombrante ed errore prona.

Questo è il motivo per cui ho deciso di scrivere uno strumento open source in grado di gestire automaticamente la creazione / cancellazione di tali file segnaposto. È scritto per la piattaforma .NET e funziona su Mono (.NET per Linux) e Windows.

Dai un'occhiata a: http://code.google.com/p/markemptydirs

Mi piacciono le risposte di @ Artur79 e @mjs, quindi ho usato una combinazione di entrambi e l'ho resa uno standard per i nostri progetti.

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

Tuttavia, solo una manciata dei nostri sviluppatori lavora su Mac o Linux. Molto lavoro su Windows e non sono riuscito a trovare un semplice one-liner equivalente per ottenere lo stesso risultato. Alcuni hanno avuto la fortuna di installare Cygwin per altri motivi, ma prescrivere Cygwin solo per questo sembrava eccessivo.

Modifica per una soluzione migliore

Quindi, dal momento che la maggior parte dei nostri sviluppatori ha già installato Ant , la prima cosa che ho pensato è stata quella di mettere insieme un file di build Ant per farlo indipendentemente dalla piattaforma. Questo può ancora essere trovato qui

Tuttavia , in seguito ho pensato che sarebbe stato meglio trasformarlo in un piccolo comando di utilità, quindi l'ho ricreato usando Python e l'ho pubblicato su PyPI qui . Puoi installarlo semplicemente eseguendo:

pip3 install gitkeep2

Ti consentirà di creare e rimuovere i .gitkeepfile in modo ricorsivo e ti consentirà inoltre di aggiungere loro dei messaggi affinché i tuoi colleghi possano capire perché tali directory sono importanti. Quest'ultimo bit è bonus. Ho pensato che sarebbe bello se i .gitkeepfile potessero essere auto-documentati.

$ 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.

Spero che lo trovi utile.

Non puoi e sfortunatamente non sarai mai in grado di farlo. Questa è una decisione presa dallo stesso Linus Torvald. Sa cosa è buono per noi.

C'è uno sfogo là fuori che ho letto una volta.

Ho trovato Re: Directory vuote ... , ma forse ce n'è un'altra.

Devi convivere con le soluzioni alternative ... purtroppo.

Quando aggiungi un .gitignorefile, se hai intenzione di mettere qualsiasi quantità di contenuto (che vuoi che Git ignori) potresti voler aggiungere una sola riga con solo un asterisco *per assicurarti di non aggiungere accidentalmente il contenuto ignorato .

Non c'è modo di convincere Git a tenere traccia delle directory, quindi l'unica soluzione è quella di aggiungere un file segnaposto all'interno della directory che Git deve tenere traccia.

Il file può essere nominato e contenere tutto ciò che vuoi, ma la maggior parte delle persone usa un file vuoto chiamato .gitkeep(sebbene alcune persone preferiscano il VCS-agnostico .keep).

Il prefisso lo .contrassegna come un file nascosto.

Un'altra idea sarebbe quella di aggiungere un READMEfile che spiega a cosa servirà la directory.

Come accennato, non è possibile aggiungere directory vuote, ma qui c'è una riga che aggiunge file vuoti .gitignore a tutte le directory.

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

L'ho bloccato in un Rakefile per un facile accesso.

La soluzione di Jamie Flournoy funziona alla grande. Ecco una versione leggermente migliorata per mantenere .htaccess:

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

Con questa soluzione è possibile eseguire il commit di una cartella vuota, ad esempio /log, /tmpoppure /cachela cartella rimarrà vuota.

Costruisco sempre una funzione per verificare la struttura delle cartelle desiderata e crearla per me all'interno del progetto. Questo risolve questo problema poiché le cartelle vuote sono mantenute in Git dal 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");
}

Questo è in PHP, ma sono sicuro che la maggior parte delle lingue supporta la stessa funzionalità e poiché l'applicazione delle cartelle è curata dall'applicazione, le cartelle saranno sempre lì.

Ecco un trucco, ma è divertente che funzioni (Git 2.2.1). Simile a quanto suggerito da @Teka, ma più facile da ricordare:

• Aggiungi un sottomodulo a qualsiasi repository ( git submodule add path_to_repo)
• Ciò aggiungerà una cartella e un file .submodules. Commetti un cambiamento.
• Elimina il .submodulesfile e conferma la modifica.

Ora, hai una directory che viene creata quando viene eseguito il checkout. Una cosa interessante è che se guardi il contenuto dell'oggetto albero di questo file otterrai:

fatale: nome oggetto non valido b64338b90b4209263b50244d18278c0999867193

Non incoraggerei a usarlo anche se potrebbe smettere di funzionare nelle future versioni di Git. Il che potrebbe lasciare corrotto il tuo repository.

Molti hanno già risposto a questa domanda. Basta aggiungere una versione di PowerShell qui.

Trova tutte le cartelle vuote nella directory

Aggiungi un file .gitkeep vuoto lì dentro

Get-ChildItem 'Path to your Folder' -Recurse -Directory | Where-Object {[System.IO.Directory]::GetFileSystemEntries($_.FullName).Count -eq 0} | ForEach-Object { New-Item ($_.FullName + "\.gitkeep") -ItemType file}

Se vuoi aggiungere una cartella che ospiterà molti dati transitori in più directory semantiche, un approccio è quello di aggiungere qualcosa di simile alla tua radice .gitignore ...

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

Quindi è possibile eseguire il commit di file README.md descrittivi (o file vuoti, non importa, purché sia ​​possibile indirizzarli in modo univoco come *.mdin questo caso) in ciascuna directory per assicurarsi che tutte le directory rimangano parte del repository ma il i file (con estensioni) vengono ignorati. LIMITAZIONE: .i nomi di directory non sono consentiti!

Puoi riempire tutte queste directory con file xml / images o qualsiasi altra cosa e aggiungere più directory /app/data/nel tempo man mano che le esigenze di archiviazione per la tua app si sviluppano (con i file README.md che servono a masterizzare in una descrizione di ciò per cui ogni directory di archiviazione è destinata Esattamente).

Non è necessario modificare ulteriormente .gitignoreo decentralizzare creando un nuovo .gitignoreper ogni nuova directory. Probabilmente non è la soluzione più intelligente ma è concisa dal punto di vista gitignore e funziona sempre per me. Bello e semplice! ;)

Un modo semplice per farlo è quello di aggiungere un .gitkeepfile alla directory che desideri (attualmente) vuota.

Vedi questa risposta SOF per ulteriori informazioni - il che spiega anche perché alcune persone trovano confusa la convenzione concorrente di aggiungere un file .gitignore (come indicato in molte risposte qui).

Aggiungendo un'altra opzione alla mischia.

Supponendo che tu voglia aggiungere una directory a gitquella, per tutti gli scopi correlati git, dovrebbe rimanere vuota e non avere mai il suo contenuto monitorato, .gitignorecome suggerito più volte qui, farà il trucco.

Il formato, come detto, è:

*
!.gitignore

Ora, se vuoi un modo per farlo dalla riga di comando, in un colpo solo, mentre all'interno della directory che vuoi aggiungere, puoi eseguire:

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

Io stesso ho uno script di shell che uso per fare questo. Assegna un nome allo script come desideri e aggiungilo da qualche parte nel percorso di inclusione oppure fai riferimento direttamente a:

#!/bin/bash

dir=''

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

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

Con questo, puoi eseguirlo dall'interno della directory che desideri aggiungere o fare riferimento alla directory poiché è il primo e unico parametro:

$ ignore_dir ./some/directory

Un'altra opzione (in risposta a un commento di @GreenAsJade), se si desidera tenere traccia una cartella vuota che MAGGIO contengono file monitorati in futuro, ma sarà vuoto, per ora, è possibile ommit il *dal .gitignorefile e verificare che in. In sostanza, tutti i file sta dicendo è "non ignorare me ", ma per il resto, la directory è vuota e monitorati.

Il tuo .gitignorefile sarebbe simile a:

!.gitignore

Ecco fatto, controlla quello e hai una directory vuota, ma tracciata, in cui puoi tracciare i file in un secondo momento.

Il motivo per cui suggerisco di mantenere una riga nel file è che fornisce lo .gitignorescopo. Altrimenti, qualcuno lungo la linea potrebbe pensare di rimuoverlo. Potrebbe essere utile inserire un commento sopra la riga.

A volte devi avere a che fare con librerie o software scritti male, che hanno bisogno di una directory "reale" vuota ed esistente. Mettere un semplice .gitignoreo .keeppotrebbe romperli e causare un bug. Quanto segue potrebbe aiutare in questi casi, ma nessuna garanzia ...

Innanzitutto creare la directory necessaria:

mkdir empty

Quindi aggiungi un collegamento simbolico interrotto a questa directory (ma in qualsiasi altro caso diverso dal caso d'uso sopra descritto, utilizza un READMEcon una spiegazione):

ln -s .this.directory empty/.keep

Per ignorare i file in questa directory, è possibile aggiungerlo nella radice .gitignore:

echo "/empty" >> .gitignore

Per aggiungere il file ignorato, utilizzare un parametro per forzarlo:

git add -f empty/.keep

Dopo il commit hai un link simbolico interrotto nel tuo indice e git crea la directory. Il collegamento interrotto presenta alcuni vantaggi, poiché non è un file normale e non indica alcun file normale. Quindi si adatta anche alla parte della domanda "(che non contiene file)", non per l'intenzione ma per il significato, immagino:

find empty -type f

Questo comando mostra un risultato vuoto, poiché in questa directory non sono presenti file. Quindi la maggior parte delle applicazioni, che ottengono tutti i file in una directory di solito non vedono questo link, almeno se fanno un "file esiste" o un "è leggibile". Anche alcuni script non troveranno alcun file lì:

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

Ma consiglio vivamente di usare questa soluzione solo in circostanze speciali, una buona scrittura READMEin una directory vuota è di solito una soluzione migliore. (E non so se questo funziona con un filesystem di Windows ...)

Leggendo le risposte di @ofavre e @ stanislav-bashkyrtsev usando riferimenti a sottomodulo GIT rotti per creare le directory GIT, sono sorpreso che nessuno abbia ancora suggerito questo semplice emendamento dell'idea per rendere il tutto sano e sicuro:

Invece di hackerare un sottomodulo falso in GIT , basta aggiungerne uno vuoto .

Immettere: https://gitlab.com/empty-repo/empty.git

Un repository GIT con esattamente un commit:

commit e84d7b81f0033399e325b8037ed2b801a5c994e0
Author: Nobody <none>
Date: Thu Jan 1 00:00:00 1970 +0000

Nessun messaggio, nessun file impegnato.

uso

Per aggiungere una directory vuota al repository GIT:

git submodule add https://gitlab.com/empty-repo/empty.git path/to/dir

Per convertire tutte le directory vuote esistenti in sottomoduli:

find . -type d -empty -delete -exec git submodule add -f https://gitlab.com/empty-repo/empty.git \{\} \;

Git memorizzerà l'ultimo hash di commit durante la creazione del riferimento del sottomodulo, quindi non devi preoccuparti di me (o GitLab) che lo utilizza per iniettare file dannosi. Purtroppo non ho trovato alcun modo per forzare l'ID commit utilizzato durante il checkout, quindi dovrai verificare manualmente che l'ID commit di riferimento siae84d7b81f0033399e325b8037ed2b801a5c994e0 utilizzando git submodule statusdopo aver aggiunto il repository.

Non è ancora una soluzione nativa, ma probabilmente il meglio che possiamo avere senza che qualcuno metta le mani davvero , molto sporco nella base di codice GIT.

Appendice: ricreare questo commit

Dovresti essere in grado di ricreare questo commit esatto usando (in una directory vuota):

# Initialize new GIT repository
git init

# Set author data (don't set it as part of the `git commit` command or your default data will be stored as “commit author”)
git config --local user.name "Nobody"
git config --local user.email "none"

# Set both the commit and the author date to the start of the Unix epoch (this cannot be done using `git commit` directly)
export GIT_AUTHOR_DATE="Thu Jan 1 00:00:00 1970 +0000"
export GIT_COMMITTER_DATE="Thu Jan 1 00:00:00 1970 +0000"

# Add root commit
git commit --allow-empty --allow-empty-message --no-edit

La creazione di commit GIT riproducibili è sorprendentemente difficile ...

Non puoi. Questa è una decisione di progettazione intenzionale da parte dei manutentori di Git. Fondamentalmente, lo scopo di un sistema di gestione del codice sorgente come Git è la gestione del codice sorgente e le directory vuote non sono codice sorgente. Git è anche spesso descritto come un tracker di contenuti e, di nuovo, le directory vuote non sono dei contenuti (al contrario, in realtà), quindi non vengono monitorate.

Puoi salvare questo codice come create_readme.php ed eseguire il codice PHP dalla directory principale del tuo progetto Git.

> php create_readme.php

Aggiungerà i file README a tutte le directory vuote in modo che tali directory vengano quindi aggiunte all'indice.

<?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
            }
        }
?>

Quindi fa

git commit -m "message"
git push