dirtravel 0.0.1

data/lib/dirtravel.rb

@@ -0,0 +1,233 @@
+# DirTravel is a library for getting information about files and
+# directories recursively to a tree structure. This library extends
+# the RubyTree classes to include directory and files info. Please
+# refer to RubyTree documentation for RubyTree related features.
+#
+# A proxy object "DirTravel::Travel" is used to gather the directory
+# content. The "filetree" class method provides interface for getting
+# the content with few options (see: DirTravel::Travel.filetree for
+# details).
+# 
+# Examples:
+#   require 'dirtravel'
+#
+#   # Collect all entries under '.'
+#   d = DirTravel::Travel.filetree( '.' )
+#
+#   # Display names of the entries in the hierarhcy.
+#   d.children.each do |i|
+#     puts i.name
+#   end
+#
+#   # Display absolute path for file (leaf level) entries.
+#   d.each_leaf do |i|
+#     puts i.abspath
+#   end
+#
+#   # Get MP3 files and create a list of all album directories
+#   # (assuming "...<album>/<song>" hierarhcy).
+#   d = DirTravel::Travel.filetree( '.', { :suffix => '.mp3' } )
+#   albums = d.select_level( d.node_height - 1 )
+#
+
+module DirTravel
+    
+    require 'rubytree'
+
+
+    # Extend RubyTree base class with file and directory features.
+    class Entry < Tree::TreeNode
+        attr_accessor :name
+
+        def initialize( name )
+            super( name, nil )
+        end
+
+
+        # Return path components as Array.
+        #
+        # @param basedir [Entry] Starting level for the hierarchy.
+        # @return [Array] Array of names in hierarchy.
+        def pathArray( basedir = self )
+            parents = []
+            while basedir
+                parents.push basedir.name
+                basedir = basedir.parent
+            end
+            parents.reverse
+        end
+
+        # Relative path.
+        def path
+            pathArray.join( '/' )
+        end
+
+        # Relative path under root.
+        def subpath
+            pathArray[ 1 .. -1 ].join( '/' )
+        end
+
+        # Absolute path.
+        def abspath
+            File.absolute_path( path )
+        end
+
+        # Return containing directory name.
+        # 
+        # @param basedir [Entry] Starting level for the hierarchy.
+        # @return [String] Containing directory.
+        def dir( basedir = self )
+            pathArray( basedir.parent ).join( '/' )
+        end
+
+        # Select all siblings from given node depth.
+        #
+        # @param level [Integer] Selected level in hierachy. Level is
+        #   number of step down in hierarhcy.
+        # @return [Array] Array of siblings in selected hierarchy.
+        def select_level( level )
+            select do |i| i.node_depth == level; end
+        end
+
+        # Return all file entries in hierarchy.
+        def files
+            select do |i| i.kind_of?( FileEntry ) end
+        end
+
+        # File.stat data for the Entry.
+        def stat
+            File.stat( path )
+        end
+    end
+    
+
+    # Directory type entry.
+    class DirEntry < Entry
+        def initialize( name )
+            super( name )
+        end
+    end
+    
+    
+    # File type entry.
+    class FileEntry < Entry
+        attr_reader :suffix, :basename
+        
+        def initialize( name )
+            super( name )
+            @suffix = File.extname( name )
+            @basename = File.basename( name, @suffix )
+        end
+        
+    end
+
+
+    # Create directory recursion tree (with
+    # Travel.filetree). Optionally filter with suffix and modify
+    # tree building with options Hash (see below).
+    # 
+    # == Parameters:
+    # sort::
+    #   Sort directory entries (default: false).
+    # suffix::
+    #   Limit search to files with "suffix" (default: nil).
+    # files::
+    #   Include files to search (default: true).
+    #
+    # Example:
+    #    d1 = DirTravel::Travel.filetree( dir1, { :sort => true, :suffix => '.mp3' } )
+
+    class Travel
+
+        # Root DirEntry of Travel.
+        attr_accessor :root
+
+        # Default options for Travel.
+        attr_accessor :defaults
+
+        # Starting directory for Travel
+        attr_accessor :basedir
+        
+        # Create directory recursion tree.
+        # @param basedir [String] Starting directory (top).
+        # @param options [Hash] Hash optionally including keys: :sort, :suffix, :files.
+        # @return [DirEntry] Root item of the file system hierarchy.
+        def Travel.filetree( basedir = '.', options = {} )
+            r = Travel.new( basedir, options )
+            r.travel
+            r.root
+        end
+
+
+        def initialize( basedir = '.', options = {} )
+            @basedir = basedir
+
+            @defaults = {
+                :suffix => nil,
+                :sort   => false,
+                :files  => true,
+            }                
+
+            @defaults.merge!( options )
+
+            @root = DirEntry.new( @basedir )
+        end
+
+
+        # Recursively get all files with suffix. Ignore suffix if
+        # suffix is nil.
+        def travel( suffix = @defaults[ :suffix ] )
+            entriesIn( @basedir, @root, suffix )
+        end
+
+
+        private
+
+        # Recursively get all files with suffix. Ignore suffix if
+        # suffix is nil.
+        def entriesIn( dir, node, suffix = nil )
+
+            list = entries( dir )
+
+            list.each do |i|
+
+                if File.file?( dir + '/' + i )
+                    
+                    # File entry.
+
+                    if ( !suffix || suffix == File.extname( i ) ) &&
+                            @defaults[ :files ]
+                        node.add( FileEntry.new( i ) )
+                    end
+
+                else
+
+                    # Dir entry.
+
+                    newNode = DirEntry.new( i )
+                    node.add( newNode )
+                    entriesIn( dir + '/' + i, newNode, suffix )
+
+                end
+
+            end
+
+            self
+        end
+
+        # Directory entries with dot entries filtered out.
+        def entries( dir )
+            entries = Dir.entries( dir ).select do |i| nonDotEntry( i ); end
+            entries.sort! if @defaults[ :sort ]
+            entries
+        end
+
+        # Test for non-dot-entry.
+        def nonDotEntry( name )
+            ( name != '.' && name != '..' )
+        end
+
+    end
+
+    
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: dirtravel
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tero Isannainen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubytree
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+description: DirTravel provides content of filesystem directories by recursively travelling
+  the directory hierarchy. The content is organized in RubyTree structure which overloaded
+  directory entry methods.
+email: tero.isannainen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dirtravel.rb
+homepage: 
+licenses:
+- Ruby
+post_install_message: Check README...
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Small and simple library for accessing filesystem directories.
+test_files: []
+has_rdoc: