Ruby Créer Récursive De L'Arbre De Répertoire

J'ai besoin de parcourir récursivement un répertoire et créez un arbre pour être utilisé avec le jsTree de contrôle. La commande accepte un format JSON comme. J'ai besoin de quelques rubis magique pour ce faire proprement et rapidement.

Toute aide est appréciée.

OriginalL'auteur Mem | 2011-04-02

  1. 25

    Vous voulez probablement quelque chose comme ceci (non testé):

    def directory_hash(path, name=nil)
  data = {:data => (name || path)}
  data[:children] = children = []
  Dir.foreach(path) do |entry|
    next if (entry == '..' || entry == '.')
    full_path = File.join(path, entry)
    if File.directory?(full_path)
      children << directory_hash(full_path, entry)
    else
      children << entry
    end
  end
  return data
end

    De manière récursive à pied vers le bas de l'arbre, construire une table de hachage. Transformer en json avec votre favori de la sérialisation de la bibliothèque.

    J'ai fait un petit changement pour l'empêcher de traverser trop loin: next if (entry == '..' || entry == '.') Merci beaucoup pour votre aide. J'ai vraiment l'apprécier.
    Ah merci, bonne place. J'ai modifié la réponse ci-dessus.

    OriginalL'auteur Glenjamin

  2. 7

    D'abord prendre votre arbre, de le convertir à une liste de chemins d'accès aux feuilles, semblables à:

    def leaves_paths tree
  if tree[:children]
    tree[:children].inject([]){|acc, c|
      leaves_paths(c).each{|p|
        acc += [[tree[:name]] + p]
      }
      acc
    }
  else
    [[tree[:name]]]
  end
end

    (Pas sûr si ci-dessus suit exactement votre jsTree structure, mais le principe est le même.)

    Voici un exemple d'entrée et de sortie:

    tree = {name: 'foo', children: [
      {name: 'bar'},
      {name: 'baz', children: [
        {name: 'boo'}, 
        {name: 'zoo', children: [
          {name: 'goo'}
        ]}
      ]}
    ]}

p leaves_paths tree
#=> [["foo", "bar"], ["foo", "baz", "boo"], ["foo", "baz", "zoo", "goo"]]

    Ensuite, pour chaque chemin d'accès, appel FileUtils#mkdir_p:

    paths = leaves_paths tree
paths.each do |path|
  FileUtils.mkdir_p(File.join(*path))
end

    Et vous devriez être ok.

    Edit: version plus Simple:

    Vous n'avez pas besoin de créer une liste de feuilles, juste de parcourir toute l'arborescence et de créer un répertoire pour chaque nœud:

    # executes block on each tree node, recursively, passing the path to the block as argument
def traverse_with_path tree, path = [], &block
  path += [tree[:name]]
  yield path
  tree[:children].each{|c| traverse_with_path c, path, &block} if tree[:children]
end

traverse_with_path tree do |path|
  FileUtils.mkdir(File.join(*path))
end

    Edit2:

    Oh, désolé, j'ai mal compris. Donc, voici une façon de faire un Hachage basé sur l'arborescence des répertoires sur le disque:

    Dir.glob('**/*'). # get all files below current dir
  select{|f|
    File.directory?(f) # only directories we need
  }.map{|path|
    path.split '/' # split to parts
  }.inject({}){|acc, path| # start with empty hash
    path.inject(acc) do |acc2,dir| # for each path part, create a child of current node
      acc2[dir] ||= {} # and pass it as new current node
    end
    acc
  }

    Donc, pour la structure suivante:

    #$ mkdir -p foo/bar
#$ mkdir -p baz/boo/bee
#$ mkdir -p baz/goo

    code ci-dessus renvoie ce hash:

    {
  "baz"=>{
    "boo"=>{
      "bee"=>{}},
    "goo"=>{}},
  "foo"=>{
    "bar"=>{}}}

    Espère que vous allez réussir à répondre à vos besoins.

    Hey, merci beaucoup pour la réponse. Je pourrais avoir été clair dans mon premier post, mais je n'ai pas besoin de créer tous les répertoires, mais de manière récursive la liste de tous les fichiers/répertoires donné un chemin.
    Merci beaucoup pour votre aide. Le code fonctionne très bien, mais ne récupère que les répertoires, néanmoins assez simple à modifier. L'apprécier.
    cela m'a aidé purement pour le Mkdir_p()
    Vous n'avez pas à utiliser Dir.glob('**/*') + prédicat File.directory?(f) . 2 étoiles avec slash est assez (Dir.glob('**/))

    OriginalL'auteur Mladen Jablanović

  3. 1

    Ruby module de recherche (require 'find') est minimaliste, mais les poignées de la récursivité de répertoire: http://www.ruby-doc.org/stdlib/libdoc/find/rdoc/classes/Find.html

    Merci pour votre réponse rapide. Je suis en train d'utiliser le Trouver, mais je suis pas sûr de savoir comment créer la structure des thats nécessaires pour l'arbre (par exemple, un répertoire a des enfants qui sont des sous-répertoires et ceux qui ont des enfants, etc.).

    OriginalL'auteur

  4. 1

    Accepté la réponse n'a pas de travail à compter de juin 2015. J'ai changé la clé :data à 'text'. J'ai aussi généralisé le code pour exclure des répertoires et des fichiers.

    def directory_hash(path, name=nil, exclude = [])                                
  exclude.concat(['..', '.', '.git', '__MACOSX', '.DS_Store'])                  
  data = {'text' => (name || path)}                                             
  data[:children] = children = []                                               
  Dir.foreach(path) do |entry|                                                  
    next if exclude.include?(entry)                                             
    full_path = File.join(path, entry)                                          
    if File.directory?(full_path)                                               
      children << directory_hash(full_path, entry)                              
    else                                                                        
      children << {'icon' => 'jstree-file', 'text' => entry}                    
    end                                                                         
  end                                                                           
  return data                                                                   
end

    OriginalL'auteur Martin Velez