torquebox-vfs 1.0.0.CR1-java

data/lib/gem_hook.rb

@@ -0,0 +1,18 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+#
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'torquebox/vfs'

data/lib/org.torquebox.vfs.rb

@@ -0,0 +1,20 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+# Backwards-compatibility
+$stderr.puts "Usage of 'org.torquebox.vfs' is deprecated.  Please use 'torquebox-vfs'."
+require 'torquebox-vfs'

data/lib/torquebox/vfs/debug_filter.rb

@@ -0,0 +1,37 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'torquebox/vfs/glob_translator'
+
+
+module TorqueBox
+  module VFS
+    class DebugFilter
+      include Java::org.jboss.vfs.VirtualFileFilter
+  
+      def initialize()
+      end
+  
+      def accepts(file)
+        puts "visit #{file}"
+        true
+      end
+
+    end
+  end
+end
+

data/lib/torquebox/vfs/dir.rb

@@ -0,0 +1,78 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+module TorqueBox
+  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
+
+      def entries
+        [ '.', '..' ] + @virtual_file.children.map(&:name)
+      end
+
+      def exists?
+        @virtual_file.exists?
+      end
+
+    end
+
+  end
+end

data/lib/torquebox/vfs/ext/dir.rb

@@ -0,0 +1,188 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+class Dir
+
+  class << self
+
+    alias_method :open_before_vfs, :open
+    alias_method :glob_before_vfs, :glob
+    alias_method :mkdir_before_vfs, :mkdir
+    alias_method :rmdir_before_vfs, :rmdir
+    alias_method :chdir_before_vfs, :chdir
+    alias_method :new_before_vfs, :new
+    alias_method :entries_before_vfs, :entries
+    alias_method :foreach_before_vfs, :foreach
+
+    # 1.8: open( dirname )
+    # 1.9: open( dirname, <, :encoding => enc> )
+    # We currently ignore the encoding.
+    def open(str, options = nil, &block)
+      if ( ::File.exist_without_vfs?( str ) )
+        return open_before_vfs(str,&block)
+      end
+      #puts "open(#{str})"
+      result = dir = TorqueBox::VFS::Dir.new( str )
+      #puts "  result = #{result}"
+      unless result.exists?
+        return open_before_vfs(str,&block)
+      end
+      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}"
+      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 = TorqueBox::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 = TorqueBox::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 chdir(*args, &block)
+      raise "You shouldn't use chdir, but if you must, pass a block!" unless block_given?
+      chdir_before_vfs( *args.map{ |x| File.name_without_vfs(x) }, &block )
+    end
+
+    def rmdir(path)
+      name = File.name_without_vfs(path)
+      rmdir_before_vfs(name)
+    end
+    alias_method :unlink, :rmdir
+    alias_method :delete, :rmdir
+
+    def mkdir(path, mode=0777)
+      mkdir_before_vfs( File.name_without_vfs(path), mode )
+    rescue Errno::ENOTDIR => e
+      path = TorqueBox::VFS.writable_path_or_error( File.path_to_str(path), e )
+      mkdir_before_vfs( path, mode )
+    rescue Errno::ENOENT => e
+      path = TorqueBox::VFS.writable_path_or_error( File.path_to_str(path), e )
+      mkdir_before_vfs( path, mode )
+    end
+
+    # 1.8: new( dirname )
+    # 1.9: new( dirname, <, :encoding => enc> )
+    # We currently ignore the encoding.
+    def new(string, options = nil)
+      if ( ::File.exist_without_vfs?( string ) )
+        return new_before_vfs( string )
+      end
+      TorqueBox::VFS::Dir.new( string )
+    end
+
+    # 1.9 has an optional, undocumented options arg that appears to be
+    # used for encoding. We'll ignore it for now, since JRuby does as
+    # well. (see org.jruby.RubyDir.java)
+    def entries(path, options = {})
+      if ( ::File.exist_without_vfs?( path ) )
+        return entries_before_vfs(path)
+      end
+      vfs_dir = org.jboss.vfs::VFS.child( File.path_to_str(path) )
+      # Delegate to original entries if passed a nonexistent file
+      unless vfs_dir.exists?
+        return entries_before_vfs( path )
+      end
+      [ '.', '..' ] + vfs_dir.children.collect{|e| e.name }
+    end
+
+    def foreach(path, &block)
+      enum = entries(path).each(&block)
+      block_given? ? nil : enum
+    end
+
+  end
+end
+

data/lib/torquebox/vfs/ext/file.rb

@@ -0,0 +1,278 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'torquebox/vfs/debug_filter'
+require 'torquebox/vfs/ext/tempfile'
+
+class File
+
+  class << self
+
+    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 :lstat_without_vfs,       :lstat
+    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 :chown_without_vfs,       :chown
+    alias_method :utime_without_vfs,       :utime
+    alias_method :new_without_vfs,         :new
+    alias_method :rename_without_vfs,      :rename
+    alias_method :join_without_vfs,        :join
+
+    def open(fname,mode_str='r', flags=nil, &block)
+      if ( Fixnum === fname )
+        return open_without_vfs( fname, mode_str, &block )
+      end
+      unless ( vfs_path?(fname) )
+        return open_without_vfs(fname, mode_str, flags, &block )
+      end
+      if ( File.exist_without_vfs?( name_without_vfs(fname) ) )
+        return 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)
+      return args[0].to_s.dup if ( vfs_path?(args[0]) )
+      if ( vfs_path?(args[1]) )
+        expanded = expand_path_without_vfs(args[0], name_without_vfs(args[1].to_s))
+        return TorqueBox::VFS.resolve_path_url(expanded)
+      end
+      expand_path_without_vfs(*args)
+    end
+
+    def readable?(filename)
+      real_name = name_without_vfs( filename )
+      return readable_without_vfs?( real_name ) if exist_without_vfs?( real_name )
+
+      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)
+      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(file_name) 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 = TorqueBox::VFS.resolve_within_archive(filename)
+      raise Errno::ENOENT.new(filename) 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(filename) unless virtual_file.exists?
+
+      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 = TorqueBox::VFS.resolve_within_archive(filename)
+      raise Errno::ENOENT.new(filename) unless vfs_url
+
+      virtual_file = Java::org.jboss.vfs.VFS.child( vfs_url )
+
+      raise Errno::ENOENT.new(filename) unless virtual_file.exists
+
+      virtual_file = virtual_file.get_child( child_path ) if child_path
+      raise Errno::ENOENT.new(filename) 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 = TorqueBox::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)
+      name = name_without_vfs(filename)
+      return stat_without_vfs(name) if ( File.exist_without_vfs?( name ) )
+
+      vfs_url, child_path = TorqueBox::VFS.resolve_within_archive(filename)
+      raise Errno::ENOENT.new(filename) 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(filename) unless virtual_file.exists?
+
+      TorqueBox::VFS::File::Stat.new( virtual_file )
+    end
+
+    def lstat(filename)
+      name = name_without_vfs(filename)
+      return lstat_without_vfs(name) if ( File.exist_without_vfs?( name ) )
+      stat(filename)
+    end
+
+    def rename(oldname, newname) 
+      rename_without_vfs( name_without_vfs(oldname), name_without_vfs(newname) )
+    end
+
+    def exist?(filename)
+      return true if exist_without_vfs?( filename )
+
+      virtual_file = virtual_file(filename)
+      !virtual_file.nil? && virtual_file.exists?
+    end
+    alias_method :exists?, :exist?
+    
+    def writable?(filename)
+      stat = stat(filename)
+      return stat.writable? if stat
+      false
+    rescue Errno::ENOENT
+      false
+    end
+
+    def directory?(filename)
+      return directory_without_vfs?( filename ) if exist_without_vfs?( filename )
+
+      virtual_file = virtual_file(filename)
+      !virtual_file.nil? && virtual_file.is_directory?
+    end
+
+    def file?(filename)
+      return true if file_without_vfs?( filename )
+
+      virtual_file = virtual_file(filename)
+      !virtual_file.nil? && virtual_file.is_leaf?
+    end
+
+    def dirname(filename)
+      dirname = dirname_without_vfs(name_without_vfs(filename))
+      vfs_path?(filename) ? TorqueBox::VFS.resolve_path_url(dirname) : dirname
+    end
+
+    def join(*args)
+      prefix = vfs_path?(args[0]) ? "vfs:" : ""
+      args = args.map do |arg|
+        if arg.is_a?(Array)
+          raise ArgumentError if arg.include?(arg)
+          join(*arg)
+        else
+          arg
+        end
+      end
+      prefix + join_without_vfs(*args.map{|x|name_without_vfs(x)})
+    end
+
+    def new(*args, &block)
+      fname = args.size > 0 ? args[0] : nil
+      if ( Fixnum === fname )
+        return new_without_vfs( *args, &block )
+      end
+      unless ( vfs_path?(fname) )
+        return new_without_vfs( *args, &block )
+      end
+      if ( File.exist_without_vfs?( name_without_vfs(fname) ) )
+        args[0] = name_without_vfs(fname)
+        return new_without_vfs( *args, &block )
+      end
+      # File.new doesn't pass a block through to the opened file
+      IO.vfs_open( *args )
+    end
+
+    def chmod(mode_int, *files)
+      writable_operation(*files) do |filename| 
+        chmod_without_vfs( mode_int, filename )
+      end
+    end
+
+    def chown(owner, group, *files)
+      writable_operation(*files) do |filename|
+        chown_without_vfs( owner, group, filename )
+      end
+    end
+
+    def utime(accesstime, modtime, *files)
+      writable_operation(*files) do |filename|
+        utime_without_vfs( accesstime, modtime, filename )
+      end
+    end
+    
+    def writable_operation(*files)
+      files.each do |name|
+        begin
+          yield name_without_vfs(name)
+        rescue Errno::ENOENT => e
+          yield TorqueBox::VFS.writable_path_or_error( name, e )
+        end
+      end
+      files.size
+    end
+
+    def name_without_vfs(filename)
+      name = path_to_str(filename).gsub("\\", "/")
+      if vfs_path?(name) 
+        result = name[4..-1]
+        result.size==0 ? "/" : result
+      else
+        name
+      end
+    end
+
+    def path_to_str(path)
+      # 1.9 - to_str became to_path for Pathnames
+      return path.to_path if path.respond_to?(:to_path) 
+      raise TypeError unless path.respond_to?(:to_str)
+      path.to_str
+    end
+    
+    def vfs_path?(path)
+      path.to_s =~ /^vfs:/
+    end
+
+    def virtual_file(filename)
+      TorqueBox::VFS.virtual_file(filename)
+    end
+  end
+
+end

data/lib/torquebox/vfs/ext/file_test.rb

@@ -0,0 +1,48 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+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