org.torquebox.vfs 1.0.0.Beta22 → 1.0.0.Beta23

data/lib/vfs/dir.rb

@@ -10,7 +10,7 @@ module VFS
       @path         = path
       begin
         @virtual_file = org.jboss.vfs.VFS.child( path )
-      rescue Java::JavaLang::NullPointerException 
+      rescue Java::JavaLang::NullPointerException
         raise Errno::ENOENT.new
       end
       @pos          = 0
@@ -38,7 +38,7 @@ module VFS
       @pos += 1
       child.name
     end
-    
+
     def seek(i)
       @pos = i
       self
@@ -48,7 +48,11 @@ module VFS
       @pos = i
     end
 
+    def entries
+      @virtual_file.children.map(&:name)
+    end
+
   end
 
-end 
+end
 

data/lib/vfs/ext/dir.rb

@@ -6,6 +6,7 @@ class Dir
     alias_method :open_before_vfs, :open
     alias_method :glob_before_vfs, :glob
     alias_method :mkdir_before_vfs, :mkdir
+    alias_method :new_before_vfs, :new
 
     def open(str,&block)
       #if ( ::File.exist_without_vfs?( str.to_str ) && ! Java::OrgJbossVirtualPluginsContextJar::JarUtils.isArchive( str.to_str ) )
@@ -19,7 +20,7 @@ class Dir
         begin
           result = block.call(dir)
         ensure
-          dir.close 
+          dir.close
         end
       end
       #puts "open(#{str}) return #{result}"
@@ -58,7 +59,7 @@ class Dir
       #end
 
       #puts "base= #{base}"
-      
+
       vfs_url, child_path = VFS.resolve_within_archive( base )
       #puts "vfs_url=#{vfs_url}"
       #puts "child_path=#{child_path}"
@@ -88,7 +89,7 @@ class Dir
         #puts "base=#{base}"
         filter = VFS::GlobFilter.new( child_path, matcher )
         #puts "filter is #{filter}"
-        paths = starting_point.getChildrenRecursively( filter ).collect{|e| 
+        paths = starting_point.getChildrenRecursively( filter ).collect{|e|
           #path_name = e.path_name
           path_name = e.getPathNameRelativeTo( starting_point )
           #puts "(collect) path_name=#{path_name}"
@@ -107,7 +108,17 @@ class Dir
     def mkdir(path, mode=0777)
       real_path = path =~ /^vfs:/ ? path[4..-1] : path
       mkdir_before_vfs( real_path, mode )
+    rescue Errno::ENOTDIR => e
+      path = VFS.writable_path_or_error( path, e )
+      mkdir_before_vfs( path, mode )
+    end
+
+    def new(string)
+      if ( ::File.exist_without_vfs?( string.to_s ) )
+        return new_before_vfs( string )
+      end
+      VFS::Dir.new( string.to_s )
     end
   end
-end 
+end
 

data/lib/vfs/ext/file.rb

@@ -6,6 +6,8 @@ class File
 
     alias_method :open_without_vfs,        :open
     alias_method :mtime_without_vfs,       :mtime
+    alias_method :size_without_vfs,        :size
+    alias_method :size_without_vfs?,       :size?
     alias_method :stat_without_vfs,        :stat
     alias_method :exist_without_vfs?,      :exist?
     alias_method :directory_without_vfs?,  :directory?
@@ -31,15 +33,20 @@ class File
     end
 
     def expand_path(*args)
+      return args[0].to_s.dup if ( vfs_path?(args[0]) )
       if ( vfs_path?(args[1]) )
-        return expand_path_without_vfs(args[0], name_without_vfs(args[1].to_s))
+        expanded = expand_path_without_vfs(args[0], name_without_vfs(args[1].to_s))
+        return VFS.resolve_path_url(expanded)
       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)
+      return true if readable_without_vfs?( name_without_vfs( filename ) )
+
+      virtual_file = virtual_file( filename )
+      # VirtualFile has no readable? so assume we can read it if it exists
+      !virtual_file.nil? && virtual_file.exists?
     end
 
     def unlink(*file_names)
@@ -69,6 +76,35 @@ class File
       Time.at( virtual_file.getLastModified() / 1000 )
     end
 
+    def size(filename)
+      return size_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
+
+      raise Errno::ENOENT.new unless virtual_file.exists
+
+      virtual_file.size
+    end
+
+    def size?(filename)
+      return size_without_vfs?(filename) if ( File.exist_without_vfs?( filename ) )
+
+      vfs_url, child_path = VFS.resolve_within_archive(filename)
+      return 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
+
+      return nil unless virtual_file.exists
+
+      virtual_file.size
+    end
+
+
     def stat(filename)
       return stat_without_vfs(filename) if ( File.exist_without_vfs?( filename ) )
 
@@ -88,17 +124,8 @@ class File
     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
+      virtual_file = virtual_file(filename)
+      !virtual_file.nil? && virtual_file.exists?
     end
 
     def writable?(filename)
@@ -110,38 +137,25 @@ class File
     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
+      virtual_file = virtual_file(filename)
+      !virtual_file.nil? && virtual_file.is_directory?
     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
+      virtual_file = virtual_file(filename)
+      !virtual_file.nil? && virtual_file.is_leaf?
     end
 
     def chmod(mode_int, *files)
       files.each do |name|
-        chmod_without_vfs( mode_int, name_without_vfs(name) )
+        begin
+          chmod_without_vfs( mode_int, name_without_vfs(name) )
+        rescue Errno::ENOENT => e
+          name = VFS.writable_path_or_error( name, e )
+          chmod_without_vfs( mode_int, name )
+        end
       end
     end
 
@@ -163,16 +177,21 @@ class File
 
     def dirname(filename)
       dirname = dirname_without_vfs(name_without_vfs(filename))
-      vfs_path?(filename) ? "vfs:#{dirname}" : dirname
+      vfs_path?(filename) ? VFS.resolve_path_url(dirname) : dirname
     end
 
     def name_without_vfs(filename)
-      vfs_path?(filename) ? filename[4..-1] : filename
+      name = filename.to_s.gsub("\\", "/")
+      vfs_path?(name) ? name[4..-1] : name
     end
 
     def vfs_path?(path)
       path.to_s =~ /^vfs:/
     end
+
+    def virtual_file(filename)
+      VFS.virtual_file(filename)
+    end
   end
 
 end

data/lib/vfs/ext/file_test.rb

@@ -0,0 +1,32 @@
+
+module FileTest
+
+  class << self
+
+    def directory?(filename)
+      File.directory?(filename)
+    end
+
+    def exist?(filename)
+      File.exist?(filename)
+    end
+
+    def exists?(filename)
+      File.exists?(filename)
+    end
+
+    def file?(filename)
+      File.file?(filename)
+    end
+
+    def readable?(filename)
+      File.readable?(filename)
+    end
+
+    def writable?(filename)
+      File.writable?(filename)
+    end
+
+  end
+
+end

data/lib/vfs/ext/io.rb

@@ -69,6 +69,9 @@ class IO
           end
       end
 
+      # VFS doesn't correctly handle relative paths when
+      # retrieving the physical file so expand it
+      fd = File.expand_path( fd )
       virtual_file = org.jboss.vfs.VFS.child( fd )
 
       if ( ! create && ! virtual_file.exists )
@@ -83,9 +86,9 @@ class IO
         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" ) 
+        raise Error.new( "Random-access on VFS not supported" )
       end
-     
+
       if ( block )
         begin
           block.call( ruby_io )
@@ -101,7 +104,7 @@ class IO
     def read(name, length=nil, offset=nil)
       return read_without_vfs(name, length, offset) if ::File.exist_without_vfs?( name )
 
-      if ( name =~ /^\// || name =~ /^vfs:\// ) 
+      if ( name =~ /^\// || name =~ /^vfs:\// )
         full_path = name
       else
         full_path = File.join( Dir.pwd, name )
@@ -110,7 +113,7 @@ class IO
       raise ::Errno::ENOENT.new( "#{name} (#{virtual_file})" ) unless virtual_file.exists()
 
       stream = virtual_file.openStream()
-      io = stream.to_io 
+      io = stream.to_io
       begin
         s = io.read
       ensure

data/lib/vfs/ext/jdbc.rb

@@ -0,0 +1,23 @@
+class Java::java.sql::DriverManager
+  class << self
+    alias_method :get_connection_without_vfs, :getConnection
+    alias_method :register_driver_without_vfs, :registerDriver
+
+    def getConnection(url, user, pass)
+      url = url.sub(':vfs:', ':')
+      get_connection_without_vfs(url, user, pass)
+    rescue => e
+      # If we didn't register a driver, throw the exception
+      raise e unless @driver
+      # If we did register a driver, try to connection using it directly
+      props = java.util.Properties.new
+      props.setProperty("user", user)
+      props.setProperty("password", pass)
+      @driver.connect(url, props)
+    end
+
+    def registerDriver(driver)
+      @driver = driver
+    end
+  end
+end

data/lib/vfs/ext/pathname.rb

@@ -0,0 +1,14 @@
+require 'pathname'
+
+class Pathname
+
+  alias_method :realpath_without_vfs, :realpath
+
+  def realpath
+    vfs_path? ? expand_path : realpath_without_vfs
+  end
+
+  def vfs_path?
+    @path.to_s =~ /^vfs:/
+  end
+end

data/lib/vfs/ext/vfs.rb

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

data/lib/vfs/file.rb

@@ -47,7 +47,7 @@ module VFS
       end
 
       def directory?
-        @virtual_file.eixsts && ! @virtual_file.is_leaf 
+        @virtual_file.exists && ! @virtual_file.is_leaf 
       end
 
       def executable?

data/lib/vfs/glob_filter.rb

@@ -5,7 +5,6 @@ module VFS
     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 = []
@@ -14,7 +13,14 @@ module VFS
         if ( gs == '**' )
           regexp_segments << '(.*)'
         else
-          gs.gsub!( /\*/, '[^\/]*')
+          gs.gsub!( /\./, '\.')
+          gs.gsub!( /\*/ ) do |m|
+            if ( $` == '' )
+              '([^\/\.][^\/]*)?'
+            else
+              '[^\/]*'
+            end
+          end
           gs.gsub!( /\?/, '.')
           gs.gsub!( /\{[^\}]+\}/ ) do |m|
             options = m[1..-2].split(',', -1)
@@ -29,20 +35,21 @@ module VFS
       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}$" )
+        #regexp_str = ::File.join( "^#{@child_path}", "#{regexp_str}$" )
+        if ( @child_path[-1,1] == '/' )
+          regexp_str = "^#{@child_path}#{regexp_str}$"
+        else
+          regexp_str = "^#{@child_path}/#{regexp_str}$"
+        end
       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

data/lib/vfs.rb

@@ -10,18 +10,21 @@ require 'vfs/glob_filter'
 require 'vfs/ext/vfs'
 require 'vfs/ext/io'
 require 'vfs/ext/file'
+require 'vfs/ext/file_test'
 require 'vfs/ext/dir'
+require 'vfs/ext/pathname'
 require 'vfs/ext/kernel'
+require 'vfs/ext/jdbc'
 
 
 module ::VFS
   def self.resolve_within_archive(path)
-    return path if ( path =~ %r(^vfs:) )
     path = path.to_s
+    return path if ( path =~ %r(^vfs:) )
     cur = path
     while ( cur != '.' && cur != '/' )
       if ( ::File.exist_without_vfs?( cur ) )
-         
+
         child_path = path[cur.length..-1]
 
         if ( cur[-1,1] == '/' )
@@ -35,7 +38,7 @@ module ::VFS
   end
 
   def self.resolve_path_url(path)
-    prefix = case 
+    prefix = case
              when path =~ /^\//            # unix absolute
                "vfs:"
              when path =~ /^[[:alpha:]]:/  # windows absolute
@@ -46,4 +49,31 @@ module ::VFS
     "#{prefix}#{path}"
   end
 
+  def self.virtual_file(filename)
+    vfs_url, child_path = VFS.resolve_within_archive( filename )
+    return nil 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
+      virtual_file
+    rescue Java::JavaIo::IOException => e
+      nil
+    end
+  end
+
+  def self.writable_path_or_error(path, e)
+    virtual_file = VFS.virtual_file( path )
+    raise e if virtual_file.nil?
+    mount = Java::org.jboss.vfs::VFS.get_mount(virtual_file)
+    # TODO: Replace with a better error stating the issue, which is
+    # the user is trying to write to a filesystem inside an archive
+    # that is mounted as readonly
+    #
+    # HACK: For some reason mount.file_system doesn't work inside TB
+    # but does in tests
+    # raise e if mount.file_system.read_only?
+    virtual_file.physical_file.path
+  end
+
 end

data/spec/dir_spec.rb

@@ -1,4 +1,5 @@
 
+require 'fileutils'
 require File.dirname(__FILE__) +  '/spec_helper.rb'
 
 describe "Dir extensions for VFS" do
@@ -33,16 +34,23 @@ describe "Dir extensions for VFS" do
       items.should include File.join( "vfs:#{@archive1_path}", 'web.xml' )
       items.should include File.join( "vfs:#{@archive1_path}", 'lib' )
     end
- 
+
     it "should allow globbing within nested archives with explicit vfs" do
       pattern = "vfs:#{@archive2_path}/*"
       items = Dir.glob( pattern )
       items.should_not be_empty
       items.should include "vfs:#{@archive2_path}/manifest.txt"
     end
+
+    it "should create new Dirs" do
+      lambda {
+        Dir.new("vfs:#{@archive2_path}")
+      }.should_not raise_error
+    end
   end
-  
-  [ :absolute, :relative ].each do |style|
+
+  [ :absolute, :relative, :vfs ].each do |style|
+  #[ :relative ].each do |style|
     describe "with #{style} paths" do
 
       case ( style )
@@ -50,6 +58,25 @@ describe "Dir extensions for VFS" do
           prefix = "./#{TEST_DATA_BASE}"
         when :absolute
           prefix = File.expand_path( File.join( File.dirname( __FILE__ ), '..', TEST_DATA_BASE ) )
+        when :vfs
+          prefix = "vfs:" + File.expand_path( File.join( File.dirname( __FILE__ ), '..', TEST_DATA_BASE ) )
+      end
+
+      it "should ignore dotfiles by default" do
+        items = Dir.glob( "#{prefix}/dotfiles/*" )
+        items.should_not be_empty
+        items.size.should eql(3)
+        items.should include( "#{prefix}/dotfiles/one" )
+        items.should include( "#{prefix}/dotfiles/three" )
+        items.should include( "#{prefix}/dotfiles/foo.txt" )
+      end
+
+      it "should match dotfiles if explicitly asked" do
+        items = Dir.glob( "#{prefix}/dotfiles/.*" )
+        items.should_not be_empty
+        items.size.should eql(2)
+        items.should include( "#{prefix}/dotfiles/.two" )
+        items.should include( "#{prefix}/dotfiles/.four" )
       end
 
       it "should allow globbing without any special globbing characters on normal files" do
@@ -57,7 +84,7 @@ describe "Dir extensions for VFS" do
         items.should_not be_empty
         items.should include( "#{prefix}/home/larry" )
       end
-      
+
       it "should allow globbing without any special globbing characters on a single normal file" do
         items = Dir.glob( "#{prefix}/home/larry/file1.txt" )
         items.should_not be_empty
@@ -91,7 +118,7 @@ describe "Dir extensions for VFS" do
       it "should allow appropriate globbing of normal files" do
         items = Dir.glob( "#{prefix}/home/larry/*" )
         items.should_not be_empty
-        items.should include( "#{prefix}/home/larry/file1.txt" ) 
+        items.should include( "#{prefix}/home/larry/file1.txt" )
         items.should include( "#{prefix}/home/larry/file2.txt" )
         items.should include( "#{prefix}/home/larry/archive1.jar" )
       end
@@ -100,14 +127,14 @@ describe "Dir extensions for VFS" do
         items = Dir.glob( "#{@archive1_path}/*" )
         items.should_not be_empty
       end
-  
+
       it "should determine if VFS is needed for nested archives" do
         base = "#{prefix}/home/larry/archive1.jar/lib/archive2.jar"
         items = Dir.glob( "#{base}/*" )
         items.should_not be_empty
         items.should include( "#{base}/manifest.txt" )
       end
-  
+
       it "should determine if VFS is needed with relative paths" do
         base = "#{prefix}/home/larry/archive1.jar/lib/archive2.jar"
         items = Dir.glob( "#{base}/*" )
@@ -153,6 +180,31 @@ describe "Dir extensions for VFS" do
         items.should_not include( "#{prefix}/home/larry/archive1.jar/lib/archive4.txt" )
       end
 
+      it "should create new Dirs" do
+        lambda {
+          Dir.new(prefix)
+        }.should_not raise_error
+      end
+
+    end
+  end
+
+  describe "mkdir" do
+    it "should mkdir inside vfs archive when directory mounted on filesystem" do
+      FileUtils.rm_rf "target/mnt"
+      archive = org.jboss.vfs::VFS.child( @archive1_path )
+      logical = archive.getChild( "lib" )
+      physical = java.io::File.new( "target/mnt" )
+      physical.mkdirs
+      mount = org.jboss.vfs::VFS.mountReal( physical, logical )
+      begin
+        lambda {
+          Dir.mkdir("#{@archive1_path}/lib/should_mkdir_inside_vfs_archive")
+          File.directory?("target/mnt/should_mkdir_inside_vfs_archive").should be_true
+        }.should_not raise_error
+      ensure
+        mount.close
+      end
     end
   end
 

data/spec/file_spec.rb

@@ -40,19 +40,33 @@ describe "File extensions for VFS" do
     File.writable?( url ).should be_true
   end
 
-  it "should expand paths relative to VFS urls as absolute" do
-    absolute = File.expand_path("db/development.sqlite3", "vfs:/path/to/app")
-    absolute.should eql("/path/to/app/db/development.sqlite3")
-  end
+  describe "expand_path" do
+    it "should handle relative non-vfs path" do
+      File.expand_path("../foo", "/tmp/bar").should == "/tmp/foo"
+    end
 
-  it "should expand paths relative to VFS pathnames as absolute" do
-    absolute = File.expand_path("db/development.sqlite3", Pathname.new("vfs:/path/to/app"))
-    absolute.should eql("/path/to/app/db/development.sqlite3")
-  end
+    it "should handle relative to vfs path" do
+      File.expand_path("../foo", "vfs:/tmp/bar").should == "vfs:/tmp/foo"
+    end
+
+    it "should expand paths relative to VFS urls as VFS" do
+      absolute = File.expand_path("db/development.sqlite3", "vfs:/path/to/app")
+      absolute.should eql("vfs:/path/to/app/db/development.sqlite3")
+    end
 
-  it "should expand absolute Pathname objects correctly" do
-    File.expand_path("vfs:/foo").should eql("vfs:/foo")
-    File.expand_path(Pathname.new("vfs:/foo")).should eql("vfs:/foo")
+    it "should expand paths relative to VFS pathnames as VFS" do
+      absolute = File.expand_path("db/development.sqlite3", Pathname.new("vfs:/path/to/app"))
+      absolute.should eql("vfs:/path/to/app/db/development.sqlite3")
+    end
+
+    it "should expand absolute Pathname objects correctly" do
+      File.expand_path("vfs:/foo").should eql("vfs:/foo")
+      File.expand_path(Pathname.new("vfs:/foo")).should eql("vfs:/foo")
+    end
+
+    it "should return first path when given two vfs paths" do
+      File.expand_path("vfs:/tmp/foo", "vfs:/tmp/bar").should == "vfs:/tmp/foo"
+    end
   end
 
   it "should handle vfs urls as readable" do
@@ -60,6 +74,16 @@ describe "File extensions for VFS" do
     File.readable?( "vfs:#{__FILE__}" ).should be_true
   end
 
+  it "should report readable-ness for files inside vfs archives" do
+    path = "vfs:#{@archive1_path}/web.xml"
+    File.readable?( path ).should be_true
+  end
+
+  it "should report readable-ness for non-existent files inside vfs archives" do
+    path = "vfs:#{@archive1_path}/file_that_does_not_exist.txt"
+    File.readable?( path ).should be_false
+  end
+
   it "should handle #'s in filenames properly" do
     prefix = File.expand_path( File.join( File.dirname( __FILE__ ), '..', TEST_COPY_BASE ) )
     File.file?( "#{prefix}/#bad-uri#" ).should be_true
@@ -67,13 +91,26 @@ describe "File extensions for VFS" do
     File.file?( "vfs:#{prefix}/#missing#" ).should be_false
   end
 
+  it "should handle spaces in filenames properly" do
+    prefix = File.expand_path( File.join( File.dirname( __FILE__ ), '..', TEST_COPY_BASE ) )
+    File.file?( "#{prefix}/sound of music/flibbity jibbit" ).should be_true
+    File.file?( "vfs:#{prefix}/sound of music/flibbity jibbit" ).should be_true
+    File.file?( "vfs:#{prefix}/sound of music/flibberty gibbet" ).should be_false
+  end
+
+  it "should handle backslashes in filenames even though there's no good reason to use them regardless of platform" do
+    filename = __FILE__.gsub("/","\\")
+    File.readable?( filename ).should be_true
+    File.readable?( "vfs:#{filename}" ).should be_true
+  end
+
   it "should be able to chmod real files with vfs urls" do
     path = File.expand_path("foo")
     begin
       f = File.new(path, "w")
-      FileUtils.chmod( 666, "vfs:#{path}")
+      FileUtils.chmod( 0666, "vfs:#{path}")
       m1 = f.stat.mode
-      FileUtils.chmod( 644, "vfs:#{path}")
+      FileUtils.chmod( 0644, "vfs:#{path}")
       m2 = f.stat.mode
       m1.should_not eql(m2)
     ensure
@@ -81,6 +118,28 @@ describe "File extensions for VFS" do
     end
   end
 
+  it "should chmod inside vfs archive when directory mounted on filesystem" do
+    FileUtils.rm_rf "target/mnt"
+    archive = org.jboss.vfs::VFS.child( @archive1_path )
+    logical = archive.getChild( "lib" )
+    physical = java.io::File.new( "target/mnt" )
+    physical.mkdirs
+    mount = org.jboss.vfs::VFS.mountReal( physical, logical )
+    path = "#{@archive1_path}/lib/chmod_test"
+    begin
+      lambda {
+        f = File.new ("target/mnt/chmod_test", "w" )
+        FileUtils.chmod( 0666, path )
+        m1 = f.stat.mode
+        FileUtils.chmod( 0755, path )
+        m2 = f.stat.mode
+        m1.should_not eql(m2)
+      }.should_not raise_error
+    ensure
+      mount.close
+    end
+  end
+
   it "should be able to create new files with vfs urls" do
     lambda {
       File.new("vfs:#{__FILE__}", 'r')
@@ -95,13 +154,18 @@ describe "File extensions for VFS" do
 
   describe "open" do
     it "should return File when called on File with VFS url" do
-      puts @archive1_path
       File.open("vfs:#{@archive1_path}", 'r').should be_an_instance_of(File)
     end
 
     it "should return File when called on File without VFS url" do
       File.open(@archive1_path, 'r').should be_an_instance_of(File)
     end
+
+    it "should find files by pathnames" do
+      lambda {
+        File.open(Pathname.new(@archive1_path), 'r')
+      }.should_not raise_error
+    end
   end
 
   describe "new" do
@@ -112,6 +176,11 @@ describe "File extensions for VFS" do
     it "should return File when called on File without VFS url" do
       File.new(@archive1_path, 'r').should be_an_instance_of(File)
     end
+
+    xit "should create objects that respond to lstat for files in an archive" do
+      file = File.new( "vfs:#{@archive1_path}/web.xml")
+      file.lstat.should_not be_nil
+    end
   end
 
   [ :absolute, :relative, :vfs ].each do |style|
@@ -125,6 +194,31 @@ describe "File extensions for VFS" do
           prefix = "vfs:#{File.expand_path( File.join( File.dirname( __FILE__ ), '..', TEST_COPY_BASE ) )}"
       end
 
+      it "should provide size for normal files" do
+        s = File.size( "#{prefix}/home/larry/file1.txt" )
+        s.should_not be_nil
+        s.should be > 0
+      end
+
+      it "should throw NOENT for size of non-existant files" do
+        lambda {
+          File.size( "#{prefix}/home/larry/NOT_REALLY_file1.txt" )
+        }.should raise_error
+      end
+
+      it "should provide size? for normal files" do
+        s = File.size?( "#{prefix}/home/larry/file1.txt" )
+        s.should_not be_nil
+        s.should be > 0
+      end
+
+      it "should not throw NOENT for size? of non-existant files" do
+        lambda {
+          s = File.size?( "#{prefix}/home/larry/NOT_REALLY_file1.txt" )
+          s.should be_nil
+        }.should_not raise_error
+      end
+
       it "should provide mtime for normal files" do
         mtime = File.mtime( "#{prefix}/home/larry/file1.txt" )
         mtime.should_not be_nil
@@ -152,11 +246,18 @@ describe "File extensions for VFS" do
         contents.should eql( "This is file 1\nhowdy\n" )
 
         fs_file = File.join( File.dirname(__FILE__), '..', TEST_COPY_BASE, 'home/larry/file1.txt' )
-        puts "confirm from #{fs_file}"
         fs_contents = File.read( fs_file )
         fs_contents.should eql( "This is file 1\nhowdy\n" )
       end
 
+      it "should allow writing new files via File.open" do
+        File.open( "#{prefix}/home/larry/new_file.txt", 'w' ) do |file|
+          file.puts "howdy"
+        end
+        contents = File.read( "#{prefix}/home/larry/new_file.txt" )
+        contents.should eql( "howdy\n")
+      end
+
       it "should allow stat for normal files" do
         file = "#{prefix}/home/larry/file1.txt"
         stat = File.stat( file )

data/spec/file_test_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe "File extensions for VFS" do
+
+  it "should delegate to File.directory?" do
+    delegate_to_file(:directory?, 'file')
+  end
+
+  it "should delegate to File.exist?" do
+    delegate_to_file(:exist?, 'file')
+  end
+
+  it "should delegate to File.exists?" do
+    delegate_to_file(:exists?, 'file')
+  end
+
+  it "should delegate to File.file?" do
+    delegate_to_file(:file?, 'file')
+  end
+
+  it "should delegate to File.readable?" do
+    delegate_to_file(:readable?, 'file')
+  end
+
+  it "should delegate to File.writable?" do
+    delegate_to_file(:writable?, 'file')
+  end
+
+  def delegate_to_file(*args)
+    method = args.shift
+    File.should_receive(method).with(*args).and_return('value')
+    FileTest.send(method, *args).should == 'value'
+  end
+end

data/spec/pathname_spec.rb

@@ -0,0 +1,20 @@
+
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'pathname'
+
+describe "Pathname extensions for VFS" do
+
+  describe "realpath" do
+    it "should expand VFS paths" do
+      pathname = Pathname.new("vfs:/tmp/test")
+      pathname.should_receive(:expand_path).and_return(Pathname.new("/expanded/path"))
+      pathname.realpath.to_s.should == "/expanded/path"
+    end
+
+    it "should find real path for non-VFS paths" do
+      pathname = Pathname.new("/tmp/test")
+      pathname.should_receive(:realpath_without_vfs).and_return(Pathname.new("/real/path"))
+      pathname.realpath.to_s.should == "/real/path"
+    end
+  end
+end

data/spec/vfs_dir_spec.rb

@@ -0,0 +1,32 @@
+
+require File.dirname(__FILE__) +  '/spec_helper.rb'
+
+describe "VFS::Dir" do
+
+  before(:each) do
+    @executor = java.util.concurrent::Executors.newScheduledThreadPool( 1 )
+    @temp_file_provider = org.jboss.vfs::TempFileProvider.create( "vfs-test", @executor )
+    @archive1_path = File.expand_path( "#{TEST_DATA_DIR}/home/larry/archive1.jar" )
+    @archive1_file = org.jboss.vfs::VFS.child( @archive1_path )
+    @archive1_mount_point = org.jboss.vfs::VFS.child( @archive1_path )
+    @archive1_handle = org.jboss.vfs::VFS.mountZip( @archive1_file, @archive1_mount_point, @temp_file_provider )
+  end
+
+  after(:each) do
+    @archive1_handle.close
+  end
+
+  describe "entries" do
+    it "should find vfs entries outside of archives" do
+      path = "#{@archive1_path}/.."
+      ::Dir.new( path ).entries.should == VFS::Dir.new( "vfs:#{path}" ).entries
+    end
+
+    it "should find vfs entries inside of archives" do
+      path = "vfs:#{@archive1_path}/other_lib/subdir"
+      entries = VFS::Dir.new( path ).entries
+      entries.size.should == 1
+      entries.first.should == "archive6.jar"
+    end
+  end
+end

data/spec/vfs_spec.rb

@@ -1,20 +1,31 @@
+require 'pathname'
 
 describe "VFS path resolution" do
 
-  it "should prefix relative paths with the current dir" do
-    cwd = Dir.pwd
-    path = VFS.resolve_path_url( "foo/bar" )
-    path.should match /^vfs:#{cwd}\/foo\/bar$/
+  describe "resolve_within_archive" do
+    it "should return pathnames with vfs: prefix unmodified" do
+      pathname = Pathname.new("vfs:/tmp/foo")
+      path = VFS.resolve_within_archive(pathname)
+      path.should == pathname.to_s
+    end
   end
 
-  it "should not prefix absolute paths with the current dir" do
-    path = VFS.resolve_path_url( "/foo/bar" )
-    path.should match /^vfs:\/foo\/bar$/
-  end
+  describe "resolve_path_url" do
+    it "should prefix relative paths with the current dir" do
+      cwd = Dir.pwd
+      path = VFS.resolve_path_url( "foo/bar" )
+      path.should match /^vfs:#{cwd}\/foo\/bar$/
+    end
+
+    it "should not prefix absolute paths with the current dir" do
+      path = VFS.resolve_path_url( "/foo/bar" )
+      path.should match /^vfs:\/foo\/bar$/
+    end
 
-  it "should treat paths with windows drive letters as absolute" do
-    path = VFS.resolve_path_url( "C:/foo/bar" )
-    path.should match /^vfs:\/C:\/foo\/bar$/
+    it "should treat paths with windows drive letters as absolute" do
+      path = VFS.resolve_path_url( "C:/foo/bar" )
+      path.should match /^vfs:\/C:\/foo\/bar$/
+    end
   end
 
 end

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
     - 1
     - 0
     - 0
-    - Beta22
-  version: 1.0.0.Beta22
+    - Beta23
+  version: 1.0.0.Beta23
 platform: ruby
 authors: []
 
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-30 00:00:00 -05:00
+date: 2010-12-06 00:00:00 -06:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -62,13 +62,19 @@ files:
   - lib/vfs/glob_filter.rb
   - lib/vfs/ext/dir.rb
   - lib/vfs/ext/file.rb
+  - lib/vfs/ext/file_test.rb
   - lib/vfs/ext/io.rb
+  - lib/vfs/ext/jdbc.rb
   - lib/vfs/ext/kernel.rb
+  - lib/vfs/ext/pathname.rb
   - lib/vfs/ext/vfs.rb
   - spec/dir_spec.rb
   - spec/file_spec.rb
+  - spec/file_test_spec.rb
   - spec/io_spec.rb
+  - spec/pathname_spec.rb
   - spec/spec_helper.rb
+  - spec/vfs_dir_spec.rb
   - spec/vfs_spec.rb
 has_rdoc: true
 homepage: http://www.torquebox.org/vfs/
@@ -105,5 +111,8 @@ summary: TorqueBox VFS
 test_files: 
   - spec/dir_spec.rb
   - spec/file_spec.rb
+  - spec/file_test_spec.rb
   - spec/io_spec.rb
+  - spec/pathname_spec.rb
+  - spec/vfs_dir_spec.rb
   - spec/vfs_spec.rb