org.torquebox.vfs 1.0.0.Beta22

data/lib/vfs/dir.rb

@@ -0,0 +1,54 @@
+
+
+module VFS
+  class Dir
+    attr_reader :path
+    attr_reader :pos
+    alias_method :tell, :pos
+
+    def initialize(path)
+      @path         = path
+      begin
+        @virtual_file = org.jboss.vfs.VFS.child( path )
+      rescue Java::JavaLang::NullPointerException 
+        raise Errno::ENOENT.new
+      end
+      @pos          = 0
+      @closed       = false
+    end
+
+    def close
+      @closed = true
+    end
+
+    def each
+      @virtual_file.children.each do |child|
+        yield child.name
+      end
+    end
+
+    def rewind
+      @pos = 0
+    end
+
+    def read
+      children = @virtual_file.children
+      return nil unless ( @pos < children.size )
+      child = children[@pos]
+      @pos += 1
+      child.name
+    end
+    
+    def seek(i)
+      @pos = i
+      self
+    end
+
+    def pos=(i)
+      @pos = i
+    end
+
+  end
+
+end 
+

data/lib/vfs/ext/dir.rb

@@ -0,0 +1,113 @@
+
+class Dir
+
+  class << self
+
+    alias_method :open_before_vfs, :open
+    alias_method :glob_before_vfs, :glob
+    alias_method :mkdir_before_vfs, :mkdir
+
+    def open(str,&block)
+      #if ( ::File.exist_without_vfs?( str.to_str ) && ! Java::OrgJbossVirtualPluginsContextJar::JarUtils.isArchive( str.to_str ) )
+      if ( ::File.exist_without_vfs?( str.to_str ) )
+        return open_before_vfs(str,&block)
+      end
+      #puts "open(#{str})"
+      result = dir = VFS::Dir.new( str.to_str )
+      #puts "  result = #{result}"
+      if block
+        begin
+          result = block.call(dir)
+        ensure
+          dir.close 
+        end
+      end
+      #puts "open(#{str}) return #{result}"
+      result
+    end
+
+    def [](pattern)
+      self.glob( pattern )
+    end
+
+    def glob(pattern,flags=0, &block)
+      is_absolute_vfs = false
+
+      str_pattern = pattern.to_str
+      #puts "glob(#{str_pattern})"
+
+      segments = str_pattern.split( '/' )
+
+      base_segments = []
+      for segment in segments
+        if ( segment =~ /[\*\?\[\{\}]/ )
+          break
+        end
+        base_segments << segment
+      end
+
+      base = base_segments.join( '/' )
+
+      base.gsub!( /\\(.)/, '\1' )
+
+      #if ( base.empty? || ( ::File.exist_without_vfs?( base ) && ! Java::OrgJbossVirtualPluginsContextJar::JarUtils.isArchive( base ) ) )
+      #if ( base.empty? || ( ::File.exist_without_vfs?( base ) ) )
+        #puts "doing FS glob"
+        #paths = glob_before_vfs( str_pattern, flags, &block )
+        #return paths
+      #end
+
+      #puts "base= #{base}"
+      
+      vfs_url, child_path = VFS.resolve_within_archive( base )
+      #puts "vfs_url=#{vfs_url}"
+      #puts "child_path=#{child_path}"
+
+      return []       if vfs_url.nil?
+      #puts "segments.size==base_segments.size? #{segments.size == base_segments.size}"
+      return [ base ] if segments.size == base_segments.size
+
+      matcher_segments = segments - base_segments
+      matcher = matcher_segments.join( '/' )
+      #puts "matcher [#{matcher}]"
+
+      begin
+        #puts "0 vfs_url=#{vfs_url}"
+        starting_point = root = org.jboss.vfs::VFS.child( vfs_url )
+        #puts "A starting_point=#{starting_point.path_name}"
+        starting_point = root.get_child( child_path ) unless ( child_path.nil? || child_path == '' )
+        #puts "B starting_point=#{starting_point.path_name}"
+        return [] if ( starting_point.nil? || ! starting_point.exists? )
+        child_path = starting_point.path_name
+        #puts "child- #{child_path}"
+        unless ( child_path =~ %r(/$) )
+          child_path = "#{child_path}/"
+        end
+        child_path = "" if child_path == "/"
+        #puts "child_path=#{child_path}"
+        #puts "base=#{base}"
+        filter = VFS::GlobFilter.new( child_path, matcher )
+        #puts "filter is #{filter}"
+        paths = starting_point.getChildrenRecursively( filter ).collect{|e| 
+          #path_name = e.path_name
+          path_name = e.getPathNameRelativeTo( starting_point )
+          #puts "(collect) path_name=#{path_name}"
+          result = ::File.join( base, path_name )
+          #puts "(collect) result=#{result}"
+          result
+        }
+        paths.each{|p| block.call(p)} if block
+        #puts "Path=#{paths.inspect}"
+        paths
+      rescue Java::JavaIo::IOException => e
+        return []
+      end
+    end
+
+    def mkdir(path, mode=0777)
+      real_path = path =~ /^vfs:/ ? path[4..-1] : path
+      mkdir_before_vfs( real_path, mode )
+    end
+  end
+end 
+

data/lib/vfs/ext/file.rb

@@ -0,0 +1,178 @@
+
+
+class File
+
+  class << self
+
+    alias_method :open_without_vfs,        :open
+    alias_method :mtime_without_vfs,       :mtime
+    alias_method :stat_without_vfs,        :stat
+    alias_method :exist_without_vfs?,      :exist?
+    alias_method :directory_without_vfs?,  :directory?
+    alias_method :dirname_without_vfs,     :dirname
+    alias_method :file_without_vfs?,       :file?
+    alias_method :expand_path_without_vfs, :expand_path
+    alias_method :unlink_without_vfs,      :unlink
+    alias_method :readable_without_vfs?,   :readable?
+    alias_method :chmod_without_vfs,       :chmod
+    alias_method :new_without_vfs,         :new
+
+    def open(fname,mode_str='r', flags=nil, &block)
+      if ( Fixnum === fname )
+        return File.open_without_vfs( fname, mode_str, &block )
+      end
+      unless ( vfs_path?(fname) )
+        return File.open_without_vfs(fname, mode_str, flags, &block )
+      end
+      if ( File.exist_without_vfs?( name_without_vfs(fname) ) )
+        return File.open_without_vfs( name_without_vfs(fname), mode_str, flags, &block )
+      end
+      self.vfs_open( fname.to_s, mode_str, &block )
+    end
+
+    def expand_path(*args)
+      if ( vfs_path?(args[1]) )
+        return expand_path_without_vfs(args[0], name_without_vfs(args[1].to_s))
+      end
+      return args[0].to_s.dup if ( vfs_path?(args[0]) )
+      expand_path_without_vfs(*args)
+    end
+
+    def readable?(filename)
+      readable_without_vfs? name_without_vfs(filename)
+    end
+
+    def unlink(*file_names)
+      file_names.each do |file_name|
+        if ( vfs_path?(file_name) )
+          virtual_file = org.jboss.vfs::VFS.child( file_name.to_s )
+          raise Errno::ENOENT.new unless virtual_file.exists()
+          virtual_file.delete
+        else
+          unlink_without_vfs( file_name )
+        end
+      end
+      file_names.size
+    end
+
+    alias_method :delete, :unlink
+
+    def mtime(filename)
+      return mtime_without_vfs(filename) if ( File.exist_without_vfs?( filename ) )
+
+      vfs_url, child_path = VFS.resolve_within_archive(filename)
+      raise Errno::ENOENT.new unless vfs_url
+
+      virtual_file = Java::org.jboss.vfs.VFS.child( vfs_url )
+      virtual_file = virtual_file.get_child( child_path ) if child_path
+
+      Time.at( virtual_file.getLastModified() / 1000 )
+    end
+
+    def stat(filename)
+      return stat_without_vfs(filename) if ( File.exist_without_vfs?( filename ) )
+
+      vfs_url, child_path = VFS.resolve_within_archive(filename)
+      raise Errno::ENOENT.new nil unless vfs_url
+
+      virtual_file = Java::org.jboss.vfs.VFS.child( vfs_url )
+      virtual_file = virtual_file.get_child( child_path ) if child_path
+
+      VFS::File::Stat.new( virtual_file )
+    end
+
+    def exists?(filename)
+      exist?(filename)
+    end
+
+    def exist?(filename)
+      return true if exist_without_vfs?( filename )
+
+      vfs_url, child_path = VFS.resolve_within_archive(filename)
+      return false unless vfs_url
+
+      begin
+        virtual_file = Java::org.jboss.vfs.VFS.child( vfs_url )
+        virtual_file = virtual_file.get_child( child_path ) if child_path
+
+        return ( ( ! virtual_file.nil? ) && virtual_file.exists() )
+      rescue Java::JavaIo::IOException => e
+        return false
+      end
+    end
+
+    def writable?(filename)
+      stat = stat(filename)
+      return stat.writable? if stat
+      false
+    end
+
+    def directory?(filename)
+      return true if directory_without_vfs?( filename )
+
+      vfs_url, child_path = VFS.resolve_within_archive(filename)
+      return false unless vfs_url
+
+      begin
+        virtual_file = Java::org.jboss.vfs.VFS.child( vfs_url )
+        virtual_file = virtual_file.get_child( child_path ) if child_path
+
+        return ( ( ! virtual_file.nil? ) && ( virtual_file.isDirectory() ) )
+      rescue Java::JavaIo::IOException => e
+        return false
+      end
+    end
+
+    def file?(filename)
+      return true if file_without_vfs?( filename )
+
+      vfs_url, child_path = VFS.resolve_within_archive(filename)
+      return false unless vfs_url
+
+      begin
+        virtual_file = Java::org.jboss.vfs.VFS.child( vfs_url )
+        virtual_file = virtual_file.get_child( child_path ) if child_path
+
+        return ( ( ! virtual_file.nil? ) && ( virtual_file.isLeaf() ) )
+      rescue Java::JavaIo::IOException => e
+        return false
+      end
+    end
+
+    def chmod(mode_int, *files)
+      files.each do |name|
+        chmod_without_vfs( mode_int, name_without_vfs(name) )
+      end
+    end
+
+    def new(*args, &block)
+      fname = args.size > 0 ? args[0] : nil
+      if ( Fixnum === fname )
+        return self.new_without_vfs( *args, &block )
+      end
+      unless ( vfs_path?(fname) )
+        return self.new_without_vfs( *args, &block )
+      end
+      if ( File.exist_without_vfs?( name_without_vfs(fname) ) )
+        args[0] = name_without_vfs(fname)
+        return File.new_without_vfs( *args, &block )
+      end
+      # File.new doesn't pass a block through to the opened file
+      IO.vfs_open( *args )
+    end
+
+    def dirname(filename)
+      dirname = dirname_without_vfs(name_without_vfs(filename))
+      vfs_path?(filename) ? "vfs:#{dirname}" : dirname
+    end
+
+    def name_without_vfs(filename)
+      vfs_path?(filename) ? filename[4..-1] : filename
+    end
+
+    def vfs_path?(path)
+      path.to_s =~ /^vfs:/
+    end
+  end
+
+end

data/lib/vfs/ext/io.rb

@@ -0,0 +1,123 @@
+
+class IO
+
+  class << self
+
+    #alias_method :open_without_vfs, :open
+    alias_method :read_without_vfs, :read
+
+    def vfs_open(fd,mode_str='r', &block)
+      append   = false
+      truncate = false
+      write    = false
+      read     = false
+      create   = false
+      case ( mode_str )
+        when /r/
+          read   = true
+          write  = false
+          append = false
+          create = false
+        when /r\+/
+          read   = true
+          write  = true
+          create = false
+          append = false
+        when /w/
+          read     = false
+          write    = true
+          create   = true
+          append   = false
+          truncate = true
+        when /w\+/
+          read   = false
+          write  = true
+          create = true
+          append = false
+          truncate = true
+        when /a/
+          read   = false
+          write  = true
+          create = true
+          append = true
+        when /a\+/
+          read   = true
+          write  = true
+          create = true
+        when Fixnum
+          if ( mode_str & File::RDONLY != 0 )
+            read  = true
+            write = false
+          end
+          if ( mode_str & File::WRONLY != 0  )
+            read  = false
+            write = true
+          end
+          if ( mode_str & File::RDWR  != 0)
+            read  = true
+            write = true
+          end
+          if ( mode_str & File::APPEND  != 0)
+            append = true
+          end
+          if ( mode_str & File::TRUNC  != 0)
+            append = false
+            truncate = true
+          end
+          if ( mode_str & File::CREAT  != 0)
+            create = true
+          end
+      end
+
+      virtual_file = org.jboss.vfs.VFS.child( fd )
+
+      if ( ! create && ! virtual_file.exists )
+        raise Errno::ENOENT
+      end
+
+      if ( read && ! write )
+        java_in = virtual_file.open_stream()
+        ruby_io = java_in.to_io
+      elsif ( write && ! read )
+        physical_file = virtual_file.physical_file
+        java_out = java.io::FileOutputStream.new( physical_file, append )
+        ruby_io = java_out.to_io
+      elsif ( read && write )
+        raise Error.new( "Random-access on VFS not supported" ) 
+      end
+     
+      if ( block )
+        begin
+          block.call( ruby_io )
+        ensure
+          ruby_io.close
+        end
+      else
+        return ruby_io
+      end
+
+    end
+
+    def read(name, length=nil, offset=nil)
+      return read_without_vfs(name, length, offset) if ::File.exist_without_vfs?( name )
+
+      if ( name =~ /^\// || name =~ /^vfs:\// ) 
+        full_path = name
+      else
+        full_path = File.join( Dir.pwd, name )
+      end
+      virtual_file = org.jboss.vfs.VFS.child( full_path )
+      raise ::Errno::ENOENT.new( "#{name} (#{virtual_file})" ) unless virtual_file.exists()
+
+      stream = virtual_file.openStream()
+      io = stream.to_io 
+      begin
+        s = io.read
+      ensure
+        io.close()
+      end
+      s
+    end
+  end
+
+end

data/lib/vfs/ext/kernel.rb

@@ -0,0 +1,14 @@
+
+module Kernel
+
+  private
+  alias_method :open_without_vfs, :open
+
+  def open(name, *rest, &block)
+    if ( name =~ /^vfs:/ )
+      return IO.vfs_open( name, *rest, &block )
+    end
+    open_without_vfs( name, *rest, &block )
+  end
+
+end

data/lib/vfs/ext/vfs.rb

@@ -0,0 +1,8 @@
+
+class Java::org.jboss.vfs::VFS
+  def self.child(uri_str)
+    uri = java.net.URI.new( uri_str.gsub('#', '%23') )
+    child = self.getChild( uri )
+    child
+  end
+end

data/lib/vfs/file.rb

@@ -0,0 +1,170 @@
+
+module VFS
+  module File
+    class Stat 
+      def initialize(virtual_file)
+        @virtual_file = virtual_file
+      end
+
+      def cmp(other)
+        @virtual_file.last_modified <=> other.last_modified
+      end
+
+      def atime()
+        Time.at( @virtual_file.last_modified )
+      end
+
+      def blksize
+        nil
+      end
+
+      def blockdev?
+        false
+      end
+
+      def blocks
+        nil
+      end
+
+      def chardev?
+        true
+      end
+
+      def ctime
+        Time.at( @virtual_file.last_modified )
+      end
+
+      def dev
+        nil
+      end
+
+      def dev_major
+        nil
+      end
+
+      def dev_minor
+        nil
+      end
+
+      def directory?
+        @virtual_file.eixsts && ! @virtual_file.is_leaf 
+      end
+
+      def executable?
+        false
+      end
+
+      def executable_real?
+        false
+      end
+
+      def file?
+        true
+      end
+
+      def ftype
+        return 'file' if @virtual_file.is_leaf
+        'directory'
+      end
+
+      def gid
+        nil
+      end
+
+      def grpowned?
+        false
+      end
+
+      def ino
+        nil
+      end
+
+      def mode
+        0x444
+      end
+
+      def mtime
+        Time.at( @virtual_file.getLastModified() / 1000 )
+      end
+
+      def nlink
+        1
+      end
+
+      def owned?
+        false
+      end
+
+      def pipe?
+        false
+      end
+
+      def rdev
+        nil
+      end
+
+      def rdev_major
+        nil
+      end
+
+      def rdev_minor
+        nil
+      end
+
+      def readable?
+        true
+      end
+
+      def readable_real?
+        true
+      end
+
+      def setgid?
+        false
+      end
+
+      def setuid?
+        false
+      end
+
+      def size
+        @virtual_file.size
+      end
+
+      def socket?
+        false
+      end
+
+      def sticky?
+        false
+      end
+
+      def symlink?
+        false
+      end
+
+      def uid
+        nil
+      end
+
+      def writable?
+        begin
+          physical_file = @virtual_file.physical_file
+          physical_file.canWrite
+        rescue => e
+          false
+        end
+      end
+
+      def writable_real?
+        writable?
+      end
+
+      def zero?
+        self.size == 0
+      end
+
+    end
+
+  end
+end

data/lib/vfs/glob_filter.rb

@@ -0,0 +1,50 @@
+
+
+module VFS
+  class GlobFilter
+    include Java::org.jboss.vfs.VirtualFileFilter
+  
+    def initialize(child_path, glob)
+      #puts "init #{child_path} #{glob}"
+      @child_path = child_path
+      glob_segments = glob.split( '/' )
+      regexp_segments = []
+  
+      glob_segments.each_with_index do |gs,i|
+        if ( gs == '**' )
+          regexp_segments << '(.*)'
+        else
+          gs.gsub!( /\*/, '[^\/]*')
+          gs.gsub!( /\?/, '.')
+          gs.gsub!( /\{[^\}]+\}/ ) do |m|
+            options = m[1..-2].split(',', -1)
+            options = options.collect{|e| "(#{e})"}
+            "(#{options.join('|')})"
+          end
+          if ( i < (glob_segments.size()-1))
+            gs = "#{gs}/"
+          end
+          regexp_segments << gs
+        end
+      end
+      
+      regexp_str = regexp_segments.join
+      #puts "regexp_str(1) [#{regexp_str}]"
+      if ( @child_path && @child_path != '' )
+        regexp_str = ::File.join( "^#{@child_path}", "#{regexp_str}$" )
+      else
+        regexp_str = "^#{regexp_str}$"
+      end
+      #puts "regexp_str(2) [#{regexp_str}]"
+      @regexp = Regexp.new( regexp_str )
+    end
+  
+    def accepts(file)
+      #puts "accepts(#{file.path_name}) vs #{@regexp}"
+      acceptable = ( !!( file.path_name =~ @regexp ) )
+      #puts "   -> #{acceptable}"
+      !!( file.path_name =~ @regexp )
+    end
+  end
+end
+