Ruby: come trovo e rimuiamo ricorsivamente le directory vuote?

Question

Sto provando a scrivere un po 'di ruby ​​che ricercherebbe in modo ricorsivo una determinata directory per tutte le directory figlio vuote e le rimuoverò.

Pensieri?

Nota: mi piacerebbe una versione di script, se possibile. Questo è sia un bisogno pratico che qualcosa per aiutarmi ad imparare.

Answer 1

In ruby:

Dir['**/*']           \ 
    .select { |d| File.directory? d }     \ 
    .select { |d| (Dir.entries(d) - %w[ . .. ]).empty? } \ 
    .each { |d| Dir.rmdir d } 

Answer 2

Perché non usare la shell?

trovare. -type d -empty -exec rmdir '{}' \;

Fa esattamente quello che vuoi.

Answer 3

Dir.glob('**/*').each do |dir| 
    begin 
    Dir.rmdir dir if File.directory?(dir) 
    # rescue # this can be dangereous unless used cautiously 
    rescue Errno::ENOTEMPTY 
    end 
end 

Answer 4

Ho testato questo script su OS X, ma se siete su Windows, avrete bisogno di apportare modifiche.

È possibile trovare i file in una directory, inclusi i file nascosti, con voci Dir #.

Questo codice eliminerà le directory che diventano vuote una volta eliminate tutte le sottodirectory.

def entries(dir) 
    Dir.entries(dir) - [".", ".."] 
end 

def recursively_delete_empty(dir) 
    subdirs = entries(dir).map { |f| File.join(dir, f) }.select { |f| File.directory? f } 
    subdirs.each do |subdir| 
    recursively_delete_empty subdir 
    end 

    if entries(dir).empty? 
    puts "deleting #{dir}" 
    Dir.rmdir dir 
    end 
end 

Answer 5

module MyExtensions 
    module FileUtils 
    # Gracefully delete dirs that are empty (or contain empty children). 
    def rmdir_empty(*dirs) 
     dirs.each do |dir| 
     begin 
      ndel = Dir.glob("#{dir}/**/", File::FNM_DOTMATCH).count do |d| 
      begin; Dir.rmdir d; rescue SystemCallError; end 
      end 
     end while ndel > 0 
     end 
    end 
    end 

    module ::FileUtils 
    extend FileUtils 
    end 
end 

Answer 6

Dir['/Users/path/Movies/incompleteAnime/foom/**/*']. \ 
select { |d| File.directory? d }. \ 
sort.reverse. \ 
each {|d| Dir.rmdir(d) if Dir.entries(d).size == 2} 

proprio come il primo esempio, ma il primo esempio non sembra gestire il bit ricorsivo. L'ordinamento e l'inversione assicurano prima di tutto la gestione delle directory più nidificate.

suppongo sort.reverse potrebbe essere scritto come sort {|a,b| b <=> a} per l'efficienza

Answer 7

Bisogna eliminare in ordine inverso, altrimenti se si dispone di un foo directory vuota con una barra sottodirectory si elimina bar, ma non FOO.

Dir.glob(dir + "/**/*").select { |d| 
    File.directory?(d) 
    }.reverse_each { |d| 
    if ((Dir.entries(d) - %w[ . .. ]).empty?) 
     Dir.rmdir(d) 
    end 
    } 

Answer 8

Guardando gli esempi da kch, dB. e Vishnu sopra, ho messo insieme una battuta che penso sia una soluzione più elegante:

Dir['**/'].reverse_each { |d| Dir.rmdir d if Dir.entries(d).size == 2 } 

io uso '**/' invece di '/**/*' per il glob, che restituisce solo directory, quindi non ho per verificare se è una directory più tardi. Sto usando reverse_each invece di sort.reverse.each in quanto è più breve e presumibilmente più efficiente, secondo questo post. Io preferisco Dir.entries(d).size == 2 a (Dir.entries(d) - %w[ . .. ]).empty? perché è un po 'più facile da leggere e capire, anche se lo (Dir.entries(d) - %w[ . .. ]).empty? probabilmente funzionerebbe meglio se dovessi eseguire il tuo script su Windows.

Ho provato un po 'su Mac OS X e funziona bene, anche con le directory vuote ricorsive.