folio 0.1.0

data/doc/ri/Folio/Prompt/rm_rf-i.yaml

@@ -0,0 +1,10 @@
+--- !ruby/object:RI::MethodDescription 
+aliases: []
+
+block_params: 
+comment: 
+full_name: Folio::Prompt#rm_rf
+is_singleton: false
+name: rm_rf
+params: (list, options)
+visibility: public

data/doc/ri/Folio/Prompt/rmdir-i.yaml

@@ -0,0 +1,10 @@
+--- !ruby/object:RI::MethodDescription 
+aliases: []
+
+block_params: 
+comment: 
+full_name: Folio::Prompt#rmdir
+is_singleton: false
+name: rmdir
+params: (dir, options)
+visibility: public

data/doc/ri/Folio/Prompt/to_s-i.yaml

@@ -0,0 +1,10 @@
+--- !ruby/object:RI::MethodDescription 
+aliases: []
+
+block_params: 
+comment: 
+full_name: Folio::Prompt#to_s
+is_singleton: false
+name: to_s
+params: ()
+visibility: public

data/doc/ri/Folio/Prompt/touch-i.yaml

@@ -0,0 +1,12 @@
+--- !ruby/object:RI::MethodDescription 
+aliases: []
+
+block_params: 
+comment: 
+- !ruby/struct:SM::Flow::P 
+  body: alias_method :chown_R, :chown_r
+full_name: Folio::Prompt#touch
+is_singleton: false
+name: touch
+params: (list, options)
+visibility: public

data/doc/ri/Folio/Socket/cdesc-Socket.yaml

@@ -0,0 +1,16 @@
+--- !ruby/object:RI::ClassDescription 
+attributes: []
+
+class_methods: 
+- !ruby/object:RI::MethodSummary 
+  name: new
+comment: 
+constants: []
+
+full_name: Folio::Socket
+includes: []
+
+instance_methods: []
+
+name: Socket
+superclass: FileObject

data/doc/ri/Folio/Socket/new-c.yaml

@@ -0,0 +1,10 @@
+--- !ruby/object:RI::MethodDescription 
+aliases: []
+
+block_params: 
+comment: 
+full_name: Folio::Socket::new
+is_singleton: true
+name: new
+params: (path)
+visibility: public

data/doc/ri/Folio/cdesc-Folio.yaml

@@ -0,0 +1,15 @@
+--- !ruby/object:RI::ClassDescription 
+attributes: []
+
+class_methods: []
+
+comment: 
+constants: []
+
+full_name: Folio
+includes: []
+
+instance_methods: []
+
+name: Folio
+superclass: 

data/doc/ri/created.rid

@@ -0,0 +1 @@
+Thu, 21 Aug 2008 15:20:49 -0400

data/lib/folio/device.rb

@@ -0,0 +1,29 @@
+require 'folio/fileobject'
+
+module Folio
+
+  # Device base class
+  class Device < FileObject
+
+    def initialize(path)
+      raise 'Devices not yet supported.'
+    end
+
+  end
+
+  # Character device
+  class CharacterDevice < Device
+
+    def chardev? ; true ; end
+
+  end
+
+  # Block device
+  class BlockDevice < Device
+
+    def blockdev? ; true ; end
+
+  end
+
+end
+

data/lib/folio/directory.rb

@@ -0,0 +1,83 @@
+require 'folio/fileobject'
+
+module Folio
+
+  class Directory < FileObject
+
+    def initialize(path=nil)
+      super(path || Dir.pwd)
+      raise FileNotFound unless ::File.directory?(@path)
+    end
+
+    def directory?   ; true  ; end
+
+    # We have to use FileUtils here b/c of some obscure
+    # secutiry issue.
+
+    # Copy recursively.
+    def cp_r(dest)
+      util.cp_r(path, dest)
+    end
+
+    def rmdir
+      util.rmdir(path)
+    end
+    alias_method :unlink, :rmdir
+    alias_method :delete, :rmdir
+    undef_method :rm
+
+    def rm_r
+      util.rm_r(path)
+    end
+
+    def rm_rf(list)
+      util.rm_rf(path)
+    end
+
+    def chmod_r(mode)
+      util.chmod_r(mode, path)
+    end
+    #alias_method :chmod_R, :chmod_r
+
+    def chown_r(user, group)
+      util.chown_r(user, group, path)
+    end
+    #alias_method :chown_R, :chown_r
+
+    #--
+    # ::Dir
+    #++
+
+    def chdir(&block)
+      ::Dir.chdir(path, &block)
+    end
+    alias_method :cd, :chdir
+
+    def chroot(&block)
+      ::Dir.chroot(path, &block)
+    end
+
+    # Directory entries. This returns a list of file names.
+    def entries
+      ::Dir.entries(path)
+    end
+
+    def foreach(&block)
+      ::Dir.foreach(path, &block)
+    end
+
+    # TODO: use enumerator (?)
+    def paths
+      (::Dir.entries(path) - ['.', '..']).collect{ |f| FileObject[path, f] }
+    end
+
+    # Join paths.
+    def /(fname)
+      FileObject[path, fname]
+    end
+    alias_method :+, :/
+
+  end
+
+end
+

data/lib/folio/document.rb

@@ -0,0 +1,66 @@
+require 'folio/fileobject'
+
+module Folio
+
+  class Document < FileObject
+
+    def intialize(path)
+      super
+      raise FileNotFound unless ::File.file?(@path)
+      raise FileNotFound if ::File.symlink?(@path)
+    end
+
+    #--
+    # Polymorphism
+    #++
+
+    def file? ; true ; end
+
+    #--
+    # FileTest::
+    #++
+
+    def executable?       ; ::FileTest.executable?(path)       ; end
+    def executable_real?  ; ::FileTest.executable_real?(path)  ; end
+
+    #--
+    # File::
+    #++
+
+    def read              ; ::File.read(path)                  ; end
+
+    def readlines         ; ::File.readlines(path)             ; end
+
+    # TODO: how to handle unkinking (b/c file no longer exists)
+    def unlink            ; ::File.unlink(path)                ; end
+    def delete            ; ::File.delete(path)                ; end
+
+    #--
+    # File.open
+    #++
+
+    def open(mode, &block)
+      ::File.open(path, mode, &block)
+    end
+
+    def truncate(size)
+      ::File.open(path, 'w'){|f| f.truncate(size)}
+    end
+
+    #--  
+    # Can we handle other modes besides read this way?
+    #++
+
+    #flock(mode)       ; _file.flock(mode)                   ; end
+
+    #def method_missing(s, *a, &b)
+    #  _file.send(s, *a, &b)
+    #end
+
+    #private
+
+    #def _file         ; @_file ||= ::File.new(path)           ; end
+  end
+
+end
+

data/lib/folio/errors.rb

@@ -0,0 +1,7 @@
+module Folio
+
+  class FileNotFound < ::IOError
+  end
+
+end
+

data/lib/folio/fileobject.rb

@@ -0,0 +1,242 @@
+
+module Folio
+
+  # = File Object
+  #
+  # Base class for all folio objects.
+  #
+  class FileObject
+
+    Separator = ::File::Separator
+
+    # Factory method.
+    def self.[](*path)
+      path = ::File.join(*path)
+
+      raise FileNotFound unless ::File.exist?(path)
+
+      case ::File.ftype(path)
+      when 'file'
+        Document.new(path)
+      when 'directory'
+        Directory.new(path)
+      when 'link'
+        Link.new(path)
+      when 'characterSpecial'
+        CharacterDevice.new(path)
+      when 'blockSpecial'
+        BlockDevice.new(path)
+      when 'socket'
+        raise TypeError # Socket.new(path) ?
+      when 'fifo'
+        raise TypeError # Pipe?
+      else # 'unknown'
+        raise TypeError
+      end
+    end
+
+  private
+
+    def initialize(path)
+      raise FileNotFound unless ::File.exist?(path)
+      @relpath = path
+      @path    = ::File.expand_path(path)
+    end
+
+  public
+
+    attr :path
+    attr :relpath
+
+    # This will alwasy be true, EXCEPT when
+    # #rm, #delete or #unlink have been used.
+    def exist?
+      ::FileTest.exist?(path)
+    end
+    alias_method :exists?, :exist?
+
+    #--
+    # File Manipulation
+    #++
+
+    def link(new)
+      ::File.ln(path, new)
+    end
+    alias_method :ln, :link
+
+    def link_force(new)
+      ::File.remove(new)
+      link(new)
+    end
+    alias_method :ln_f, :link_force
+
+    def symlink(new)
+      ::File.symlink(path, new)
+    end
+    alias_method :ln_s, :symlink
+
+    def symlink_force(new)
+      ::File.remove(new)
+      symlink(new)
+    end
+    alias_method :ln_sf, :symlink_force
+
+    def rename(dest)
+      ::File.rename(path, dest)
+      @relpath = dest
+      @path = ::File.expand_path(dest)
+    end
+    alias_method :mv, :rename
+
+    # how to handle --b/c it disappears?
+    def unlink
+      ::File.delete(path)
+    end
+    alias_method :delete, :unlink
+    alias_method :rm, :unlink
+
+    def unlink_force
+      ::File.remove(new)
+      unlink(path)
+    end
+    alias_method :delete_force, :unlink_force
+    alias_method :rm_f, :unlink_force
+
+    def chmod(mode)
+      ::File.chmod(mode, path)
+    end
+
+    def chown(user, group)
+      ::File.chown(user, group, path)
+    end
+
+    def utime(atime, mtime)
+      ::File.utime(atime, mtime, path)
+    end
+
+    # Wherever possible we have tried to avoid using
+    # FileUtils. Hoever there are a few methods that
+    # require it's use becuase of the complications
+    # in their implementation. Evenutlly we might port
+    # these methods.
+
+    # Copy file to destination path.
+    def cp(dest)
+      util.cp(path, dest)
+    end
+
+    # Install file to destination path.
+    def install(dest, mode=nil)
+      util.install(path, dest, mode)
+    end
+
+    def touch
+      util.touch(path)
+    end
+
+    # Status methods. These methods all access a cached
+    # ::File::Stat object. You can use #stat! to refresh
+    # the status cache.
+
+    # Get stat and cache it.
+    def stat
+      @stat ||= File.stat(path)
+    end
+
+    # Refresh status cache.
+    def restat
+      @stat = File.stat(path)
+    end
+    alias_method :stat!, :restat
+
+    def file?               ; stat.file?             ; end
+    def directory?          ; stat.directory?        ; end
+    def blockdev?           ; stat.blockdev?         ; end
+    def chardev?            ; stat.chardev?          ; end
+    def socket?             ; stat.socket?           ; end
+    def pipe?               ; stat.pipe?             ; end
+
+    def atime               ; stat.atime             ; end
+    def ctime               ; stat.ctime             ; end
+    def grpowned?           ; stat.grpowned?         ; end
+    def identical?          ; stat.identical?        ; end
+    def mtime               ; stat.mtime             ; end
+    def owned?              ; stat.owned?            ; end
+    def readable?           ; stat.readable?         ; end
+    def readable_real?      ; stat.readable_real     ; end
+    def setgid?             ; stat.setgid?           ; end
+    def setuid?             ; stat.setuid?           ; end
+    def size                ; stat.size              ; end
+    def size?               ; stat.size?             ; end
+    def sticky?             ; stat.sticky?           ; end
+    def writable?           ; stat.writable?         ; end
+    def writable_real?      ; stat.writable_real?    ; end
+    def zero?               ; stat.zero?             ; end
+
+    #--
+    # Pathname Methods
+    #++
+
+    def basename            ; ::File.basename(path)              ; end
+    def dirname             ; ::File.dirname(path)               ; end
+    def extname             ; ::File.extname(path)               ; end
+
+    # TODO: I don't like the name of this.
+    def split               ; ::File.split(path)                 ; end
+
+    # Gives path relative to current working directory.
+    # If current is below path one step then it uses '..',
+    # further below and it returns the full path.
+    def relative
+      pwd = Dir.pwd
+      pth = path
+      if pth.index(pwd) == 0
+        r = pth[pwd.size+1..-1]
+        r = '.' unless r
+        return r
+      else
+        pwd = File.dirname(pwd)
+        if pth.index(pwd) == 0
+          r = pth[pwd.size+1..-1]
+          return '..' unless r
+          return File.join('..', r)
+        else
+          pth
+        end
+      end
+    end
+
+    def fnmatch(pattern, flags=0)
+      ::File.fnmatch(path, pattern, flags)
+    end
+    alias_method :fnmatch?, :fnmatch
+
+    #--
+    # Standard Object Methods
+    #++
+
+    # Inspect returns the path string relative to
+    # the current working directory.
+    def inspect; "#{relative}"; end
+
+    # Returns the path string.
+    def to_s ; path ; end
+
+    def <=>(other)
+      path <=> other.to_s
+    end
+
+    def ==(other)
+      path == other.path
+    end
+
+  private
+
+    def util
+      ::FileUtils
+    end
+
+  end
+
+end
+

data/lib/folio/link.rb

@@ -0,0 +1,49 @@
+require 'folio/fileobject'
+
+module Folio
+
+  class Link < FileObject
+
+    def initialize(path)
+      super
+      raise FileNotFound unless ::File.symlink?(@path)
+
+      @folio = Folio.new(::File.readlink(path))
+    end
+
+    #--
+    # Am I write to think any file object can be linked?
+    #++
+
+    def symlink?
+      ::File.symlink(path)
+    end
+
+    def link?
+      ::File.link?(path)
+    end
+    
+    def readlink
+      ::File.readlink(path)
+    end
+
+    def lchmod(mode)
+      ::File.lchmod(mode, path)
+    end
+
+    def lchown(own, grp)
+      ::File.lchown(own, grp, path)
+    end
+
+    def lstat
+      ::File.lstat(path)
+    end
+
+    #    
+    def method_missing(s, *a, &b)
+      @folio.send(s, *a, &b)
+    end
+
+  end
+
+end

data/lib/folio/pipe.rb

@@ -0,0 +1,16 @@
+require 'folio/fileobject'
+
+module Folio
+
+  class Pipe < FileObject
+
+    def initialize(path)
+      raise 'Pipes not yet supported.'
+    end
+
+    def pipe? ; true ; end
+
+  end
+
+end
+