folio 0.3.0 → 0.4.0

data/lib/folio/multiglob.rb

@@ -0,0 +1,91 @@
+class Dir
+
+  # Like +glob+ but can take multiple patterns.
+  #
+  #   Dir.multiglob( '*.rb', '*.py' )
+  #
+  # Rather then constants for options multiglob accepts a trailing options
+  # hash of symbol keys.
+  #
+  #   :noescape    File::FNM_NOESCAPE
+  #   :casefold    File::FNM_CASEFOLD
+  #   :pathname    File::FNM_PATHNAME
+  #   :dotmatch    File::FNM_DOTMATCH
+  #   :strict      File::FNM_PATHNAME && File::FNM_DOTMATCH
+  #
+  # It also has an option for recurse.
+  #
+  #   :recurse     Recurively include contents of directories.
+  #
+  # For example
+  #
+  #   Dir.multiglob( '*', :recurse => true )
+  #
+  # would have the same result as
+  #
+  #   Dir.multiglob('**/*')
+  #
+  #--
+  # DEPRECATED
+  #
+  # Multiglob also accepts '+' and '-' prefixes. Any entry that begins with a '-'
+  # is treated as an exclusion glob and will be removed from the final result.
+  # For example, to collect all files in the current directory, less ruby scripts:
+  #
+  #   Dir.multiglob( '*', '-*.rb' )
+  #
+  # This is very useful in collecting files as specificed by a configuration
+  # parameter.
+  #++
+  def self.multiglob(*patterns)
+    options  = (Hash === patterns.last ? patterns.pop : {})
+
+    if options.delete(:recurse)
+      #patterns += patterns.collect{ |f| File.join(f, '**', '**') }
+      multiglob_r(*patterns)
+    end
+
+    bitflags = 0
+    bitflags |= File::FNM_NOESCAPE if options[:noescape]
+    bitflags |= File::FNM_CASEFOLD if options[:casefold]
+    bitflags |= File::FNM_PATHNAME if options[:pathname] or options[:strict]
+    bitflags |= File::FNM_DOTMATCH if options[:dotmatch] or options[:strict]
+
+    patterns = [patterns].flatten.compact
+
+    if options[:recurse]
+      patterns += patterns.collect{ |f| File.join(f, '**', '**') }
+    end
+
+    files = []
+    files += patterns.collect{ |pattern| Dir.glob(pattern, bitflags) }.flatten.uniq
+
+    return files
+  end
+
+  # The same as +multiglob+, but recusively includes directories.
+  #
+  #   Dir.multiglob_r( 'folder' )
+  #
+  # is equivalent to
+  #
+  #   Dir.multiglob( 'folder', :recurse=>true )
+  #
+  # The effect of which is
+  #
+  #   Dir.multiglob( 'folder', 'folder/**/**' )
+  #
+  def self.multiglob_r(*patterns)
+    options = (Hash === patterns.last ? patterns.pop : {})
+    matches = multiglob(*patterns)
+    directories = matches.select{ |m| File.directory?(m) }
+    matches += directories.collect{ |d| multiglob_r(File.join(d, '**'), options) }.flatten
+    matches.uniq
+    #options = (Hash === patterns.last ? patterns.pop : {})
+    #options[:recurse] = true
+    #patterns << options
+    #multiglob(*patterns)
+  end
+
+end
+

data/lib/folio/path.rb

@@ -0,0 +1,56 @@
+#require 'pathname'
+
+module Folio
+
+  class Path
+
+    def initialize(path)
+      if File.exist?(path)
+        @delegate = Pathname.new(path, self)
+      else
+        @delegate = FileObject[path]
+      end
+    end
+
+    def replace(file_object)
+      @delegate = file_object
+    end
+
+    def method_missing(s, *a, &b)
+      @delegate.__send__(s, *a, &b)
+    end
+  end
+
+
+  class Pathname
+
+    def initialize(path, delegator)
+
+    end
+
+    def cd
+      delegator.replace(Directory.new(to_s))
+      delegator.cd()
+    end
+
+  end
+
+end
+
+
+
+
+#module Kernel
+#  def path(name)
+#    Folio::Path.new(name)
+#  end
+#end
+
+#$path = lambda{ |path| Folio::Path.new(path) }
+
+#class String
+#  def to_path
+#    Folio::Path.new(self)
+#  end
+#end
+

data/lib/folio/shell.rb

@@ -1,5 +1,9 @@
 module Folio
   require 'folio/xdg'
+  require 'folio/filetest'
+  require 'folio/fileutils'
+  require 'folio/ziputils'
+  require 'folio/multiglob'
 
   # = Prompt class
   #
@@ -21,7 +25,7 @@ module Folio
       raise FileNotFound, "#{path}" unless ::File.exist?(path)
       raise FileNotFound, "#{path}" unless ::File.directory?(path)
 
-      @work = Directory.new(path)
+      @work = dir(path)
     end
 
     # Opertaton mode. This can be :noop, :verbose or :dryrun.
@@ -48,10 +52,10 @@ module Folio
     attr :work
 
     # Home location.
-    def home ; file('~') ; end
+    def home ; dir('~') ; end
 
     # Root location.
-    def root ; file('/') ; end
+    def root ; dir('/') ; end
 
     # Return a new prompt with the same location.
     # NOTE: Use #dup or #clone ?
@@ -62,17 +66,32 @@ module Folio
     # TODO: Should there be methods like this for each
     #       type, and raise an error if not the right type?
     #
+    #
+    def [](name)
+      FileObject[name]
+    end
+
     def file(name)
       FileObject[name]
     end
 
-    alias_method :[], :file
+    def pathname(name)
+      Pathname.new(name)
+    end
+
+    def doc(name)
+      Document.new(name)
+    end
+
+    def dir(name)
+      Directory.new(name)
+    end
 
     # Join paths.
     def +(fname)
       @work =+ fname
     end
-    alias_method :/, :+
+    alias_method '/', '+'
 
     # Lists all entries.
     def entries
@@ -99,132 +118,331 @@ module Folio
     # Returns Enumerator of documents.
     def directories ; work.directories ; end
 
-    # Glob pattern.
-    def glob(*patterns)
+    # Glob pattern. Returns matches as strings.
+    def glob(*patterns, &block)
+      opts = (::Integer===patterns.last ? patterns.pop : 0)
+      patterns = localize(patterns)
+      matches  = patterns.map{ |pattern| ::Dir.glob(pattern, opts) }.flatten
+      if block_given?
+        matches.each(&block)
+      end
+    end
+
+    # TODO: Ultimately merge #glob and #multiglob.
+    def multiglob(*a)
+      Dir.multiglob(*a)
+    end
+
+    def multiglob_r(*a)
+      Dir.multiglob_r(*a)
+    end
+
+    # Match pattern. Like #glob but returns file objects.
+    def match(*patterns, &block)
       opts = (::Integer===patterns.last ? patterns.pop : 0)
-      pattern = localize(pattern)
-      ::Dir.glob(pattern, opts).each{ |f| FileObject[f] }
+      patterns = localize(patterns)
+      matches  = patterns.map{ |pattern| ::Dir.glob(pattern, opts) }.flatten
+      matches  = matches.map{ |f| FileObject[f] }
+      if block_given?
+        matches.each(&block)
+      end
     end
 
     # Chage working directory.
     def cd(dir, &block)
-      #dir = localize(dir)
       if block
-        @work.cd(dir, &block)
+        Dir.chdir(localize(dir), &block)
       else
         @work += dir
       end
     end
+    alias_method :chdir, :cd
+
+    #############
+    # FileTest  #
+    #############
+
+    #
+    def size(path)        ; FileTest.size(localize(path))       ; end
+    def size?(path)       ; FileTest.size(localize(path))       ; end
+    def directory?(path)  ; FileTest.directory?(localize(path)) ; end
+    def symlink?(path)    ; FileTest.symlink?(localize(path))   ; end
+    def readable?(path)   ; FileTest.readable?(localize(path))  ; end
+    def size?(path)       ; FileTest.size?(localize(path))      ; end
+    def chardev?(path)    ; FileTest.chardev?(localize(path))   ; end
+    def exist?(path)      ; FileTest.exist?(localize(path))     ; end
+    def exists?(path)     ; FileTest.exists?(localize(path))    ; end
+    def zero?(path)       ; FileTest.zero?(localize(path))      ; end
+    def pipe?(path)       ; FileTest.pipe?(localize(path))      ; end
+    def file?(path)       ; FileTest.file?(localize(path))      ; end
+    def sticky?(path)     ; FileTest.sticky?(localize(path))    ; end
+    def blockdev?(path)   ; FileTest.blockdev?(localize(path))  ; end
+    def grpowned?(path)   ; FileTest.grpowned?(localize(path))  ; end
+    def setgid?(path)     ; FileTest.setgid?(localize(path))    ; end
+    def setuid?(path)     ; FileTest.setuid?(localize(path))    ; end
+    def socket?(path)     ; FileTest.socket?(localize(path))    ; end
+    def directory?(path)  ; FileTest.directory?(localize(path)) ; end
+    def owned?(path)      ; FileTest.owned?(localize(path))     ; end
+    def identical?(path)  ; FileTest.identical?(localize(path)) ; end
+    def writable?(path)   ; FileTest.writable?(localize(path))  ; end
+    def executable?(path) ; FileTest.executable?(localize(path))  ; end
+
+    def writable_real?(path)   ; FileTest.writable_real?(localize(path))   ; end
+    def executable_real?(path) ; FileTest.executable_real?(localize(path)) ; end
+    def readable_real?(path)   ; FileTest.readable_real?(localize(path))   ; end
+
+    def safe?(path)  ; FileTest.safe?(localize(path))   ; end
+
+    # TODO: Is #out_of_date? this the same as #uptodate?
+    def out_of_date?(path, *sources)
+      FileTest.out_of_date?(localize(path), *localize(sources))
+    end
+
+    def relative?(path) ; FileTest.relative?(path) ; end
+    def absolute?(path) ; FileTest.absolute?(path) ; end
+
 
     #############
     # FileUtils #
     #############
 
+    # Low-level Methods Omitted
+    # -------------------------
+    # getwd           -> pwd
+    # compare_file    -> cmp
+    # remove_file     -> rm
+    # copy_file       -> cp
+    # remove_dir      -> rmdir
+    # safe_unlink     -> rm_f
+    # makedirs        -> mkdir_p
+    # rmtree          -> rm_rf
+    # copy_stream
+    # remove_entry
+    # copy_entry
+    # remove_entry_secure
+    # compare_stream
+
+    # Present working directory.
+    def pwd
+      work.to_s
+    end
+
+    # Same as identical?
+    def cmp(a,b)
+      fileutils.cmp(a,b)
+    end
+
+    #
+    def uptodate?(new, old_list, options=nil)
+      new = localize(new)
+      old = localize(old_list)
+      fileutils.uptodate?(new, old, options)
+    end
+
     #
-    def mkdir(dir, options)
+    def mkdir(dir, options={})
       dir = localize(dir)
       fileutils.mkdir(dir, options)
     end
 
-    def mkdir_p(dir, options)
+    def mkdir_p(dir, options={})
       dir = localize(dir)
       fileutils.mkdir_p(dir, options)
     end
+    alias_method :mkpath, :mkdir_p
 
-    def rmdir(dir, options)
+    def rmdir(dir, options={})
       dir = localize(dir)
       fileutils.rmdir(dir, options)
     end
 
-    # ln(list, destdir, options)
-    def ln(old, new, options)
+    # ln(list, destdir, options={})
+    def ln(old, new, options={})
       old = localize(old)
       new = localize(new)
       fileutils.ln(old, new, options)
     end
+    alias_method :link, :ln
 
-    # ln_s(list, destdir, options)
-    def ln_s(old, new, options)
+    # ln_s(list, destdir, options={})
+    def ln_s(old, new, options={})
       old = localize(old)
       new = localize(new)
       fileutils.ln_s(old, new, options)
     end
+    alias_method :symlink, :ln_s
 
-    def ln_sf(old, new, options)
+    def ln_sf(old, new, options={})
       old = localize(old)
       new = localize(new)
       fileutils.ln_sf(old, new, options)
     end
 
-    # cp(list, dir, options)
-    def cp(src, dest, options)
+    # cp(list, dir, options={})
+    def cp(src, dest, options={})
       src  = localize(src)
       dest = localize(dest)
       fileutils.cp(src, dest, options)
     end
+    alias_method :copy, :cp
 
-    # cp_r(list, dir, options)
-    def cp_r(src, dest, options)
+    # cp_r(list, dir, options={})
+    def cp_r(src, dest, options={})
       src  = localize(src)
       dest = localize(dest)
       fileutils.cp_r(src, dest, options)
     end
 
-    # mv(list, dir, options)
-    def mv(src, dest, options)
+    # mv(list, dir, options={})
+    def mv(src, dest, options={})
       src  = localize(src)
       dest = localize(dest)
       fileutils.mv(src, dest, options)
     end
+    alias_method :move, :mv
 
-    def rm(list, options)
+    def rm(list, options={})
       list = localize(list)
       fileutils.rm(list, options)
     end
+    alias_method :remove, :rm
 
-    def rm_r(list, options)
+    def rm_r(list, options={})
+      list = localize(list)
+      fileutils.rm_r(list, options)
+    end
+
+    def rm_f(list, options={})
       list = localize(list)
       fileutils.rm_f(list, options)
     end
 
-    def rm_rf(list, options)
+    def rm_rf(list, options={})
       list = localize(list)
       fileutils.rm_rf(list, options)
     end
 
-    def install(src, dest, mode, options)
+    def install(src, dest, mode, options={})
       src  = localize(src)
       dest = localize(dest)
       fileutils.install(src, dest, mode, options)
     end
 
-    def chmod(mode, list, options)
+    def chmod(mode, list, options={})
       list = localize(list)
       fileutils.chmod(mode, list, options)
     end
 
-    def chmod_r(mode, list, options)
+    def chmod_r(mode, list, options={})
       list = localize(list)
       fileutils.chmod_r(mode, list, options)
     end
     #alias_method :chmod_R, :chmod_r
 
-    def chown(user, group, list, options)
+    def chown(user, group, list, options={})
       list = localize(list)
       fileutils.chown(user, group, list, options)
     end
 
-    def chown_r(user, group, list, options)
+    def chown_r(user, group, list, options={})
       list = localize(list)
       fileutils.chown_r(user, group, list, options)
     end
     #alias_method :chown_R, :chown_r
 
-    def touch(list, options)
+    def touch(list, options={})
       list = localize(list)
       fileutils.touch(list, options)
     end
 
+    #
+    def stage(stage_directory, files)
+      dir   = localize(stage_directory)
+      files = localize(files)
+      fileutils.stage(dir, files)
+    end
+
+    #############
+    # ZipUtils  #
+    #############
+
+    # Compress directory to file. Format is determined
+    # by file extension.
+    def compress(folder, file, options={})
+      ziputils.compress(folder, file, options)
+    end
+
+    #
+    def gzip(file=nil, options={})
+      file   = localize(file)
+      ziputils.gzip(file, options)
+    end
+
+    #
+    def bzip2(file=nil, options={})
+      file   = localize(file)
+      ziputils.bzip2(file, options)
+    end
+
+    # Create a zip file of a directory.
+    def zip(folder, file=nil, options={})
+      folder = localize(folder)
+      file   = localize(file)
+      ziputils.zip(folder, file, options)
+    end
+
+    #
+    def tar(folder, file=nil, options={})
+      folder = localize(folder)
+      file   = localize(file)
+      ziputils.tar_gzip(folder, file, options)
+    end
+
+    # Create a tgz file of a directory.
+    def tar_gzip(folder, file=nil, options={})
+      folder = localize(folder)
+      file   = localize(file)
+      ziputils.tar_gzip(folder, file, options)
+    end
+    alias_method :tgz, :tar_gzip
+
+    # Create a tar.bz2 file of a directory.
+    def tar_bzip2(folder, file=nil, options={})
+      folder = localize(folder)
+      file   = localize(file)
+      ziputils.tar_bzip2(folder, file, options)
+    end
+
+    def ungzip(file, options)
+      file   = localize(file)
+      ziputils.ungzip(file, options)
+    end
+
+    def unbzip2(file, options)
+      file   = localize(file)
+      ziputils.unbzip2(file, options)
+    end
+
+    def unzip(file, options)
+      file   = localize(file)
+      ziputils.unzip(file, options)
+    end
+
+    def untar(file, options)
+      file   = localize(file)
+      ziputils.untar(file, options)
+    end
+
+    def untar_gzip(file, options)
+      file   = localize(file)
+      ziputils.untar_gzip(file, options)
+    end
+
+    def untar_bzip2(file, options)
+      file   = localize(file)
+      ziputils.untar_bzip2(file, options)
+    end
+
     #################
     # XDG locations #
     #################
@@ -246,52 +464,58 @@ module Folio
 
     # Return a enumertor of system config directories.
     def root_config() #_directories
-      XDG.xdg_config_dirs.to_enum(:each){ |f| file(f) }
+      XDG.xdg_config_dirs.to_enum(:each){ |f| dir(f) }
     end
 
     # Return a enumertor of system data directories.
     def root_data() #_directories
-      XDG.xdg_data_dirs.to_enum(:each){ |f| file(f) }
+      XDG.xdg_data_dirs.to_enum(:each){ |f| dir(f) }
     end
 
     # Return the home config directory.
     def home_config
-      file(XDG.xdg_config_home)
+      dir(XDG.xdg_config_home)
     end
 
     # Return the home data directory.
     def home_data
-      file(XDG.xdg_data_home)
+      dir(XDG.xdg_data_home)
     end
 
     # Return the home cache directory.
     def home_cache
-      file(XDG.xdg_cache_home)
+      dir(XDG.xdg_cache_home)
     end
 
-    # Return the home config directory.
+    # Return the work config directory.
     def work_config
-      file(XDG.xdg_config_work)
-    end
-
-    # Return the home data directory.
-    def work_data
-      file(XDG.xdg_data_work)
+      dir(XDG.xdg_config_work)
     end
 
-    # Return the home cache directory.
+    # Return the work cache directory.
     def work_cache
-      file(XDG.xdg_cache_work)
+      dir(XDG.xdg_cache_work)
     end
 
   private
 
     def localize(local_path)
+      # some path arguments are optional
+      return local_path unless local_path
+      #
       case local_path
       when Array
-        local_path.collect{ |lp| File.expand_path(File.join(path, lp)) }
+        local_path.collect do |lp|
+          if absolute?(lp)
+            lp
+          else
+            File.expand_path(File.join(work.to_s, lp)) 
+          end
+        end
       else
-        File.expand_path(File.join(path, local_path))
+        # do not localize an absolute path
+        return local_path if absolute?(local_path)
+        File.expand_path(File.join(work.to_s, local_path))
       end
     end
 
@@ -310,6 +534,21 @@ module Folio
       end
     end
 
+    # Returns ZipUtils module based on mode.
+    def ziputils
+      return ::ZipUtils unless @mode
+      case @mode
+      when :dryrun
+        ::ZipUtils::DryRun
+      when :noop
+        ::ZipUtils::Noop
+      when :verbose
+        ::ZipUtils::Verbose
+      else
+        ::ZipUtils
+      end
+    end
+
   public#class
 
     def self.[](path)