javaobjs 0.3

data/install.rb

@@ -0,0 +1,42 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+$ruby = CONFIG['ruby_install_name']
+
+$sitedir = CONFIG["sitelibdir"]
+unless $sitedir
+  version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
+  $libdir = File.join(CONFIG["libdir"], "ruby", version)
+  $sitedir = $:.find {|x| x =~ /site_ruby/}
+  if !$sitedir
+    $sitedir = File.join($libdir, "site_ruby")
+  elsif $sitedir !~ Regexp.quote(version)
+    $sitedir = File.join($sitedir, version)
+  end
+end
+
+if (destdir = ENV['DESTDIR'])
+  $sitedir = destdir + $sitedir
+  File::makedirs($sitedir)
+end
+
+rake_dest = File.join($sitedir, "rake")
+File::makedirs(rake_dest, true)
+File::chmod(0755, rake_dest)
+
+# The library files
+
+files = Dir.chdir('lib') { Dir['**/*.rb'] }
+
+for fn in files
+  fn_dir = File.dirname(fn)
+  target_dir = File.join($sitedir, fn_dir)
+  if ! File.exist?(target_dir)
+    File.makedirs(target_dir)
+  end
+  File::install(File.join('lib', fn), File.join($sitedir, fn), 0644, true)
+end
+

data/lib/CVS/Entries

@@ -0,0 +1,2 @@
+/javaobs.rb/1.2/Sun Apr 16 22:41:16 2006//
+D

data/lib/CVS/Repository

@@ -0,0 +1 @@
+trunk/lib

data/lib/CVS/Root

@@ -0,0 +1 @@
+:ext:wsobel@rubyforge.org:/var/cvs/javaobs

data/lib/javaobs.rb

@@ -0,0 +1,686 @@
+ 
+require 'delegate'
+
+# Java Objects namespace to read and write Java serialized objects to streams. 
+# Any Java serialized object can be read from a stream. To write a Java object,
+# the meta class must be primed with a sample input serialized object. The is 
+# required because Java uses a UUID to identify classes and it is generated using
+# a complex hashing scheme of data and method signatures. Since this system does
+# not have access to that information, it needs to get it from a serialized object.
+#
+# Objects that have custom serialization methods can be read and written by 
+# creating a class as we have for the Date class:
+#    module Java
+#      module Util
+#        class Date < SimpleDelegator
+#          extend JavaObject
+#
+#          def initialize
+#            super(Time)
+#          end
+#
+#          # Set the time with a Time object.
+#          def time=(time)
+#            __setobj__(time)
+#          end
+#
+#          def _readJavaData(stream)
+#            data = stream.readBlockData
+#            t, = data.unpack("Q")
+#            __setobj__(Time.at(t / 1000, (t % 1000) * 1000))
+#          end
+#
+#          # Get the data in the form needed for the Java date serialization.
+#          def _writeJavaData(stream)
+#            t = __getobj__.tv_sec * 1000 + __getobj__.tv_usec / 1000
+#            stream.writeBlockData([t].pack("Q"))
+#          end
+#        end
+#      end
+#    end
+#
+# The important methods are the data method that is used for writing the 
+# the object to a stream.
+#
+# All other classes will be auto-generated when the stream is read and persisted. 
+# A Java Meta Class is added to the Ruby Class that contains all the Java field
+# information needed to serialize the objects. 
+
+module Java
+  
+  # An error thrown when a serialization error occurs.
+  class SerializationError < RuntimeError
+  end
+  
+  # An representation of a Java instance variable used to serialize
+  # data to and from a stream.
+  class JavaField
+    attr_reader :name, :type
+    attr_accessor :subtype
+    
+    # Create a java instance variable with a name and data type.
+    def initialize(name, type)
+      @name = name
+      @type = type
+      @subtype = nil
+    end
+    
+    def inspect
+      "<JavaField: #{@name}:#{@type.chr}:#{@subtype}>"
+    end
+  end
+  
+  # The Java meta class with all the information needed for 
+  # serialization of the Ruby class to the stream. This class
+  # is attached to the Ruby class.
+  class JavaClass
+    attr_accessor :superClass, :rubyClass
+    attr_reader :name, :uid, :fields, :javaName, :flags, :arrayType
+    
+    def initialize(name, uid, flags)
+      @name = @javaName = name
+      ind = name.rindex('.')
+      @name = name.slice(ind + 1..name.length) if ind
+      @flags = flags
+      @uid = uid
+      @fields = []
+      @arrayType = name[1] if name[0] == ?[
+    end
+      
+    # Add a field to the class.
+    def addField(field)
+      @fields << field
+    end
+    
+    def to_s
+      @name
+    end
+  end
+  
+  # A small mixin to extend a Ruby class with the associated
+  # JavaClass.
+  module JavaObject
+    def javaClass
+      @javaClass
+    end
+  end
+  
+  # The custom serialization of the Java Date class
+  module Util
+    class Date < SimpleDelegator
+      extend JavaObject
+    
+      def initialize
+        super(Time)
+      end
+
+      # Set the time with a Time object.
+      def time=(time)
+        __setobj__(time)
+      end
+    
+      def _readJavaData(stream)
+        data = stream.readBlockData
+        t, = data.unpack("Q")
+        __setobj__(Time.at(t / 1000, (t % 1000) * 1000))
+      end
+
+      # Get the data in the form needed for the Java date serialization.
+      def _writeJavaData(stream)
+        t = __getobj__.tv_sec * 1000 + __getobj__.tv_usec / 1000
+        stream.writeBlockData([t].pack("Q"))
+      end
+    end
+    
+    class HashMap < SimpleDelegator
+      extend JavaObject
+    
+      def initialize
+        super(Hash)
+        @loadFactor = 0.75
+        @threshold = 12
+      end
+
+      def _readJavaData(stream)
+        # Read loadFactor and threshold.
+        stream.defaultReadObject(self)
+        stream.readBlockStart
+        len = stream.readInt
+        size = stream.readInt
+        
+        h = Hash.new
+        size.times do 
+          k = stream.readObject
+          v = stream.readObject
+          h[k] = v
+        end
+        stream.readBlockEnd
+        __setobj__(h)
+      end
+
+      def _writeJavaData(stream)
+        obj = __getobj__;
+        stream.defaultWriteObject(self)
+        stream.writeBlockStart(8)
+        l = 16
+        len = obj.length
+        while l < len
+          l << 1
+        end
+        stream.writeInt(l)
+        stream.writeInt(len)
+        obj.each do |k, v|
+          stream.writeObject(k)
+          stream.writeObject(v)
+        end
+        stream.writeBlockEnd
+      end      
+    end
+  end
+
+  # The Java Array wrapper using an Ruby Array.
+  class JavaArray < Array
+    extend JavaObject
+  end
+
+  # Container for the Java serialization constants.
+  module ObjectStream
+    STREAM_MAGIC = 0xACED
+    STREAM_VERSION = 5
+    
+    TC_NULL      = 0x70
+    TC_REFERENCE = 0x71
+    TC_CLASSDESC = 0x72
+    TC_OBJECT    = 0x73
+    TC_STRING    = 0x74
+    TC_ARRAY     = 0x75
+    TC_CLASS     = 0x76
+    TC_BLOCKDATA = 0x77
+    TC_ENDBLOCKDATA = 0x78
+    TC_RESET     = 0x79
+    TC_BLOCKDATALONG = 0x7A
+    TC_EXCEPTION = 0x7B
+    TC_LONGSTRING = 0x7C
+    TC_PROXYCLASSDESC = 0x7D
+    
+    SC_WRITE_METHOD   = 0x01
+    SC_SERIALIZABLE   = 0x02
+    SC_EXTERNALIZABLE = 0x04
+    SC_BLOCKDATA      = 0x08
+    
+    PRIM_BYTE   = 66 # 'B'
+    PRIM_CHAR   = 67 # 'C'
+    PRIM_DOUBLE = 68 # 'D'
+    PRIM_FLOAT  = 70 # 'F'
+    PRIM_INT    = 73 # 'I'
+    PRIM_LONG   = 74 # 'J'
+    PRIM_SHORT  = 83 # 'S'
+    PRIM_BOOL   = 90 # 'Z'
+    
+    PRIM_ARRAY   = 91 # '['
+    PRIM_OBJECT  = 76 # 'L'
+  end
+  
+  # The Ruby version of the Java ObjectInputStream. Creates a Ruby 
+  # proxy class for each Java Class.
+  class ObjectInputStream
+    include ObjectStream
+    
+    def readByte; @str.read(1)[0]; end
+    def readUShort; @str.read(2).unpack("n")[0]; end
+    def readShort; @str.read(2).unpack("s")[0]; end
+    def readInt; @str.read(4).unpack("i")[0]; end
+    def readDouble; @str.read(8).unpack("G")[0]; end
+    def readFloat; @str.read(4).unpack("g")[0]; end
+    def readString; @str.read(readShort); end
+    def readBool; @str.read(1)[0] != 0; end
+    def readUID; @str.read(8); end
+    def readLong; @str.read(8).unpack("Q").first; end
+  
+    def readBlockStart
+      byte = readByte
+      size = nil
+      case byte
+      when TC_BLOCKDATA
+        size = readByte
+        
+      when TC_BLOCKDATALONG
+        size = readInt
+        
+      else
+        raise SerializationError, "Expecting TC_BLOCKDATA, got #{'0x%X' % byte}" unless byte == TC_BLOCKDATA
+      end
+      size
+    end
+    
+    def readBlockEnd
+      byte = readByte
+      raise SerializationError, "Unexpected byte #{byte}" unless byte == TC_ENDBLOCKDATA
+    end
+  
+    # Read a Java block of data with a size and then the following data.
+    def readBlockData
+      size = readBlockStart
+      data = @str.read(size)
+      readBlockEnd
+      data
+    end
+    
+    
+    # Read all the fields from the stream and add them to the class.
+    def readFields(klass)
+      fieldCount = readShort
+      1.upto(fieldCount) do
+        type = readByte
+        name = readString
+        field = JavaField.new(name, type)
+        
+        # Check for array and object types
+        if type == PRIM_OBJECT || type == PRIM_ARRAY
+          field.subtype = readObject
+        end
+        klass.addField(field)
+      end
+    end
+    
+    # Read the class annotation. We do not currently handle annotations.
+    def readClassAnnotation
+      ebd = readByte
+      raise SerializationError, "We do not handle annotations!" unless ebd == TC_ENDBLOCKDATA
+    end
+
+    # Gets or creates a corresponding Ruby class for the Java class. This
+    # will drop leading com or java and transform the rest of the dotted
+    # names to modules.
+    def rubyClassFor(name, super_name)
+      context = name.split('.')
+      f, = context
+      context.shift if f == 'java' or f == 'com'
+      context.map! { |n| n.capitalize! if n !~ /^[A-Z]/o; n }
+      kname = context.pop
+      
+      mod = Java
+      context.each do |m|
+        unless mod.constants.include?(m)
+          mod = mod.module_eval "#{m} = Module.new"
+        else
+          mod = mod.const_get(m)
+        end
+      end
+      
+      unless mod.constants.include?(kname)
+        rclass = mod.module_eval "#{kname} = Class.new(#{super_name})"
+      else
+        rclass = mod.const_get(kname)
+      end
+      rclass
+    end
+    
+    # Read the Java class description and create a Ruby class to proxy it 
+    # in this name-space. Added special handling for the Date class.
+    def readClassDesc
+      name = readString
+      uid = readUID
+      flags = readByte
+      klass = JavaClass.new(name, uid, flags)
+      
+      @objects << klass
+      
+      readFields(klass)
+      readClassAnnotation
+      
+      klass.superClass = readObject
+
+      # Create Ruby object representing class
+      if name =~ /^[A-Z.]+/i
+        # Create the class within the correct module.
+        rclass = rubyClassFor(name, klass.superClass.to_s)
+
+        unless rclass.methods.index('javaClass')
+          rclass.class_eval "extend JavaObject"
+        end
+        
+        rclass.class_eval "@javaClass = klass"
+        vars = klass.fields.map do |f|
+          ':' + f.name
+        end
+        rclass.class_eval "attr_accessor #{vars.join(',')}"
+        klass.rubyClass = rclass
+      else
+        # Arrays
+        newName = 'JavaArray' + klass.name[1..klass.name.length]
+        unless Java.constants.index(newName)
+          rclass = Java.module_eval "#{newName} = Class.new(JavaArray)"
+        else
+          rclass = Java.const_get(newName)
+        end
+        rclass.class_eval "@javaClass = klass"
+        klass.rubyClass = rclass
+      end
+      
+      klass
+    end
+
+    # Read an array of objects.
+    def readArray(klass)
+      size = readInt
+      a = klass.rubyClass.new
+      type = klass.arrayType
+      1.upto(size) do
+        a << readType(type)
+      end
+      a
+    end
+
+    # Read a primitive data type.
+    def readType(type, arrayType = nil, field = nil)
+      case type
+      when PRIM_BYTE
+        readByte
+        
+      when PRIM_CHAR
+        readByte
+        
+      when PRIM_DOUBLE
+        readDouble
+        
+      when PRIM_FLOAT
+        readFloat
+        
+      when PRIM_INT
+        readInt
+        
+      when PRIM_LONG
+        readLong
+        
+      when PRIM_SHORT
+        readShort
+        
+      when PRIM_BOOL
+        readBool
+        
+      when PRIM_OBJECT, PRIM_ARRAY
+        readObject
+        
+      else
+        raise SerializationError, "Unknown type #{type}"
+      end
+    end
+    
+    # Cover method for java method. 
+    def defaultReadObject(object)
+      readObjectFields(object.class.javaClass, object)
+    end
+
+    # Reads the object fields from the stream.
+    def readObjectFields(klass, object)
+      klass.fields.each do |f|
+        v = readType(f.type, f.subtype, f)
+        object.send((f.name + '=').intern, v)
+      end
+    end
+    
+    # Read class data and recursively read parent classes.
+    def readClassData(klass, object = nil)
+      if object == nil
+        object = klass.rubyClass.new()
+        @objects << object
+      end
+      
+      readClassData(klass.superClass, object) if (klass.superClass)
+      
+      if klass.flags == SC_SERIALIZABLE
+        readObjectFields(klass, object)
+      else
+        object._readJavaData(self)
+      end
+      
+      object
+    end
+    
+    # Read an object from the stream.
+    def readObject
+      object = nil
+      byte = readByte
+      case byte
+      when TC_OBJECT
+        klass = readObject
+        object = readClassData(klass)
+        
+      when TC_REFERENCE
+        readShort
+        object = @objects[readShort]
+        
+      when TC_ARRAY
+        klass = readObject
+        object = readArray(klass)
+        @objects << object
+        
+      when TC_STRING
+        object = readString
+        @objects << object
+
+      when TC_CLASSDESC
+        object = readClassDesc
+
+      when TC_NULL
+        object = nil
+        
+      else
+        raise SerializationError, "Unexpected byte #{byte} at #{@str.pos}"
+      end
+
+      object
+    end
+
+    # Initialize from a stream.
+    def initialize(str)
+      @str = str
+      magic =  readUShort
+      streamVersion = readShort
+      @objects = []
+
+      raise "Bad stream #{magic.to_s(16)}:#{streamVersion.to_s(16)}" if magic != STREAM_MAGIC ||
+      streamVersion != STREAM_VERSION
+
+    end
+
+    # Read all objects in the stream. Calls readObject until the stream
+    # eof is reached.
+    def readObjects
+      objs = []
+      until (@str.eof)
+        objs << readObject
+      end
+      objs
+    end
+  end
+
+  # A Ruby version of the Java ObjectOutputStream. The Ruby classes must 
+  # have attached Java meta classes to attach UUID.
+  class ObjectOutputStream
+    include ObjectStream
+
+    def writeByte(b); @str.putc b; end
+    def writeUShort(s); @str.write [s].pack("n"); end
+    def writeShort(s); @str.write [s].pack("s"); end
+    def writeInt(i); @str.write [i].pack("i"); end
+    def writeDouble(d); @str.write [d].pack("G"); end
+    def writeFloat(f); @str.write [f].pack("g"); end
+    def writeString(s); writeShort(s.length); @str.write s; end
+    def writeBool(b); writeByte(b ? 1 : 0); end
+    def writeUID(u); @str.write u; end
+    def writeLong(l); @str.write [l].pack("Q"); end
+
+    # Creates object reference handles.
+    def nextHandle
+      h = @nextHandle
+      @nextHandle += 1
+      h
+    end
+
+    # Write an array of objects.
+    def writeArray(klass, v)
+      type = klass.arrayType
+      writeInt(v.length)
+      v.each do |e|
+        writeType(type, e)
+      end
+    end
+    
+    def writeBlockStart(size)
+      if (size <= 255)
+        writeByte(TC_BLOCKDATA)
+        writeByte(size)
+      else
+        writeByte(TC_BLOCKDATALONG)
+        writeInt(size)
+      end
+    end
+    
+    def writeBlockEnd
+      writeByte(TC_ENDBLOCKDATA)
+    end
+
+    # Writes a block of data to the stream.
+    def writeBlockData(data)
+      writeBlockStart(data.length)
+      @str.write data
+      writeBlockEnd
+    end
+
+    # Reads a Java primitive type.
+    def writeType(type, v)
+      case type
+      when PRIM_BYTE
+        writeByte(v)
+
+      when PRIM_CHAR
+        writeByte(v)
+
+      when PRIM_DOUBLE
+        writeDouble(v)
+
+      when PRIM_FLOAT
+        writeFloat(v)
+
+      when PRIM_INT
+        writeInt(v)
+
+      when PRIM_LONG
+        writeLong(v)
+
+      when PRIM_SHORT
+        writeShort(v)
+
+      when PRIM_BOOL
+        writeBool(v)
+
+      when PRIM_OBJECT, PRIM_ARRAY
+        writeObject(v)
+
+      else
+        raise SerializationError, "Unknown type #{type}"
+      end
+    end
+    
+    # Writes the class description to the stream.
+    def writeClassDesc(klass)
+      @handles[klass] = nextHandle
+
+      writeString klass.javaName
+      writeUID klass.uid
+      writeByte klass.flags
+
+      writeShort(klass.fields.length)
+      klass.fields.each do |f|
+        writeByte(f.type)
+        writeString(f.name)
+        writeObject(f.subtype) if f.subtype
+      end
+
+      writeByte(TC_ENDBLOCKDATA) # Annotations
+      writeObject(klass.superClass)
+    end
+    
+    def defaultWriteObject(object)
+      writeObjectFields(object.class.javaClass, object)
+    end
+    
+    def writeObjectFields(klass, object)
+      klass.fields.each do |f|
+        v = object.send(f.name.intern)
+        writeType(f.type, v)
+      end
+    end
+
+    # Write the object and class to the stream.
+    def writeObjectData(klass, obj)
+      writeObjectData(klass.superClass, obj) if klass.superClass
+
+      if klass.flags == SC_SERIALIZABLE
+        writeObjectFields(klass, obj)
+      else
+        obj._writeJavaData(self)
+      end
+    end
+   
+    # Writes the object and class data to the stream. Will 
+    # write a reference if the object has already been written 
+    # once.
+    def writeObject(obj)
+     unless obj
+       writeByte(TC_NULL)
+     else
+       handle = @handles[obj]
+       if (handle)
+         writeByte(TC_REFERENCE)
+         writeShort(0x007E)
+         writeShort(handle)
+       else
+         case obj
+         when JavaClass
+           writeByte(TC_CLASSDESC)
+           writeClassDesc(obj)
+
+         when JavaArray
+           writeByte(TC_ARRAY)
+           writeObject(obj.class.javaClass)
+           writeArray(obj.class.javaClass, obj)
+           @handles[obj] = nextHandle
+       
+         when String
+           writeByte(TC_STRING)
+           writeString(obj)
+           @handles[obj] = nextHandle
+       
+         else
+           writeByte(TC_OBJECT)
+           klass = obj.class.javaClass
+           writeObject(klass)
+           @handles[obj] = nextHandle
+           writeObjectData(klass, obj)
+         end
+       end
+     end
+    end
+
+    # Write an array of objects to the stream.
+    def writeObjects(objs)
+      objs.each do |o|
+        writeObject o
+      end
+    end
+
+    # Create an o writer on with a stream.
+    def initialize(str)
+      @str = str
+      @handles = {}
+      @nextHandle = 0
+
+      writeUShort(STREAM_MAGIC)
+      writeShort(STREAM_VERSION)
+    end
+  end
+end
+

data/rakefile

@@ -0,0 +1,176 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+PKG_BUILD     = '3'
+PKG_NAME      = 'javaobjs'
+PKG_VERSION   = '0.3'
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+RUBY_FORGE_PROJECT = "javaobs"
+RUBY_FORGE_USER    = "wsobel"
+
+desc "Default Task"
+task :default => [ :test ]
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = Dir.glob( "test/test.rb" )
+  t.verbose = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Java Objects"
+  rdoc.main = 'README.rdoc'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README.rdoc', 'lib/**/*.rb')
+end
+  
+dist_dirs = [ "lib", "test", "examples" ]
+
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = "Decode Java Serialized Objects to Ruby Objects."
+  s.description = %q{Takes Java serialized objects in a file or stream and creates Ruby wrapper objects and decodes. The package can also write Java objects once UUID is read from sample.}
+
+  s.author = "William Sobel"
+  s.email = "willsobel@mac.com"
+  s.rubyforge_project = "javaobj"
+  s.homepage = "http://www.rubyforge.org"
+
+  s.has_rdoc = true
+  s.requirements << 'none'
+
+  s.require_path = 'lib'
+
+  s.files = [ "rakefile", "install.rb" ]
+  dist_dirs.each do |dir|
+    s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+  end
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+task :release => [:repackage] do
+  files = ["gem", "zip", "tgz"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }
+  
+  if RUBY_FORGE_PROJECT then
+    require 'net/http'
+    require 'open-uri'
+
+    project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"
+    project_data = open(project_uri) { |data| data.read }
+    puts project_data
+    group_id = project_data[/[?&]group_id=(\d+)/, 1]
+    raise "Couldn't get group id" unless group_id
+
+    # This echos password to shell which is a bit sucky
+    if ENV["RUBY_FORGE_PASSWORD"]
+      password = ENV["RUBY_FORGE_PASSWORD"]
+    else
+      print "#{RUBY_FORGE_USER}@rubyforge.org's password: "
+      password = STDIN.gets.chomp
+    end
+    
+    login_response = Net::HTTP.post_form(URI.parse('http://rubyforge.org/account/login.php'),
+                               {'form_loginname'=> RUBY_FORGE_USER, 
+                                'form_pw'=> password, 'login' => 1})
+
+    cookie = login_response["set-cookie"]
+    raise "Login failed" unless cookie
+    headers = { "Cookie" => cookie }
+
+    release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
+    release_data = open(release_uri, headers) { |data| data.read }
+    package_id = release_data[/[?&]package_id=(\d+)/, 1]
+    raise "Couldn't get package id" unless package_id
+
+    first_file = true
+    release_id = ""
+
+    
+    files.each do |filename|
+      basename  = File.basename(filename)
+      file_ext  = File.extname(filename)
+      file_data = File.open(filename, "rb") { |file| file.read }
+
+      puts "Releasing #{basename}..."
+
+      release_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+        release_date = Time.now.strftime("%Y-%m-%d %H:%M")
+        type_map = {
+          ".zip"    => "3000",
+          ".tgz"    => "3110",
+          ".gz"     => "3110",
+          ".gem"    => "1400"
+        }; type_map.default = "9999"
+        type = type_map[file_ext]
+        boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"
+
+        query_hash = if first_file then
+          {
+            "group_id" => group_id,
+            "package_id" => package_id,
+            "release_name" => RELEASE_NAME,
+            "release_date" => release_date,
+            "type_id" => type,
+            "processor_id" => "8000", # Any
+            "release_notes" => "",
+            "release_changes" => "",
+            "preformatted" => "1",
+            "submit" => "1"
+          }
+        else
+          {
+            "group_id" => group_id,
+            "release_id" => release_id,
+            "package_id" => package_id,
+            "step2" => "1",
+            "type_id" => type,
+            "processor_id" => "8000", # Any
+            "submit" => "Add This File"
+          }
+        end
+
+        query = "?" + query_hash.map do |(name, value)|
+          [name, URI.encode(value)].join("=")
+        end.join("&")
+
+        data = [
+          "--" + boundary,
+          "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
+          "Content-Type: application/octet-stream",
+          "Content-Transfer-Encoding: binary",
+          "", file_data, ""
+          ].join("\x0D\x0A")
+
+        release_headers = headers.merge(
+          "Content-Type" => "multipart/form-data; boundary=#{boundary}"
+        )
+
+        target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"
+        http.post(target + query, data, release_headers)
+      end
+
+      if first_file then
+        release_id = release_response.body[/release_id=(\d+)/, 1]
+        raise("Couldn't get release id") unless release_id
+      end
+
+      first_file = false
+    end
+  end
+end

data/test/CVS/Entries

@@ -0,0 +1,4 @@
+/Test.java/1.2/Sun Apr 16 22:42:34 2006//
+/Test2.java/1.1/Sun Apr 16 22:48:25 2006//
+/test.rb/1.2/Sun Apr 16 22:56:39 2006//
+D

data/test/CVS/Repository

@@ -0,0 +1 @@
+trunk/test

data/test/CVS/Root

@@ -0,0 +1 @@
+:ext:wsobel@rubyforge.org:/var/cvs/javaobs

data/test/Test.java

@@ -0,0 +1,62 @@
+import java.io.*;
+import java.util.Date;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Test implements Serializable
+{
+    int a;
+    int b;
+    long c;
+    String d;
+    int e[];
+    Date date;
+    Map map;
+    
+
+    public void setA(int x) { a = x; }
+    public void setB(int x) { b = x; }
+    public void setC(long l) { c = l; }
+    public void setD(String s) { d = s; }
+    public void setE(int x[]) { e = x; }
+    public void setDate(Date d) { date = d; }
+    public void setMap(Map m) { map = m; }
+    
+    public static void main(String args[])
+    {
+        Test t = new Test();
+        t.setA(1);
+        t.setB(2);
+        t.setC(1000000000000000L);
+        t.setD("Hello");
+        int a[] = new int[20];
+        for (int i = 0; i < 20; i++) 
+        {
+            a[i] = i;
+        }
+        
+        t.setE(a);
+        Calendar cal = Calendar.getInstance();
+        cal.set(2006, 5, 5, 13, 20, 00);
+        cal.set(Calendar.MILLISECOND, 0);
+        t.setDate(cal.getTime());
+        
+        try
+        {
+            FileOutputStream fos = new FileOutputStream("t.tmp");
+            ObjectOutputStream oos = new ObjectOutputStream(fos);
+            
+            oos.writeObject(t);
+            oos.writeObject(new Date());
+            oos.close();
+        }
+
+        catch (Throwable x)
+        {
+            System.err.println(x);
+        }
+
+        System.exit(0);
+    }
+}

data/test/Test2.java

@@ -0,0 +1,40 @@
+import java.io.*;
+import java.util.Date;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Test2 implements Serializable
+{
+    Map map;
+    public void setMap(Map m) { map = m; }
+    
+    public static void main(String args[])
+    {
+        Test2 t = new Test2();
+        t.map = new HashMap();
+        t.map.put("One", new Integer(1));
+        t.map.put("Two", new Integer(2));
+        t.map.put("Three", new Integer(3));
+        t.map.put("Four", new Integer(4));
+        t.map.put("Five", new Integer(5));
+        t.map.put("Six", new Integer(6));
+        t.map.put("Seven", new Integer(7));
+        
+        try
+        {
+            FileOutputStream fos = new FileOutputStream("t2.tmp");
+            ObjectOutputStream oos = new ObjectOutputStream(fos);
+            
+            oos.writeObject(t);
+            oos.close();
+        }
+
+        catch (Throwable x)
+        {
+            System.err.println(x);
+        }
+
+        System.exit(0);
+    }
+}

data/test/test.rb

@@ -0,0 +1,111 @@
+
+$testdir  = File.dirname(__FILE__)
+$: << "#{$testdir}/../lib"
+
+require 'javaobs'
+require 'test/unit'
+
+class JavaTest < Test::Unit::TestCase
+
+  def setup
+    system("javac #{$testdir}/Test.java")
+    system("java -classpath #{$testdir} Test")
+    system("javac #{$testdir}/Test2.java")
+    system("java -classpath #{$testdir} Test2")
+  end
+  
+  def teardown
+    File.unlink('t.tmp') rescue nil
+    File.unlink('t2.tmp') rescue nil
+    File.unlink('t.tmp.new') rescue nil
+    File.unlink("#{$testdir}/Test.class") rescue nil
+    File.unlink("#{$testdir}/Test2.class") rescue nil    
+  end
+  
+  def test_read
+    orig = ''
+    objs = nil
+    File.open("t.tmp") do |f|
+      f.binmode
+      
+      orig = f.read
+      f.seek(0)
+      
+      os = Java::ObjectInputStream.new(f)
+      assert os
+      objs = os.readObjects
+      assert objs
+    end
+
+    obj1, obj2 = objs
+    assert_equal obj1.a, 1
+    assert_equal obj1.b, 2
+    assert_equal obj1.c, 1000000000000000
+    assert_equal obj1.d, "Hello"
+    obj1.e.each_with_index { |v, i| assert_equal v, i }
+    assert_kind_of Java::Util::Date, obj1.date
+    assert_equal obj1.date, Time.local(2006, 06, 05, 13, 20, 0)
+    
+    assert_equal obj2.class, Java::Util::Date
+  end
+  
+  def test_read_map
+    orig = ''
+    objs = nil
+    File.open("t2.tmp") do |f|
+      f.binmode
+      
+      orig = f.read
+      f.seek(0)
+      
+      os = Java::ObjectInputStream.new(f)
+      assert os
+      objs = os.readObjects
+      assert objs
+    end
+
+    obj1, = objs
+    map = obj1.map
+    assert_equal ["Five", "Four", "One", "Seven", "Six", "Three", "Two"], map.keys.sort
+    {"One" => 1, "Two" => 2, "Three" => 3, "Four" => 4, 
+      "Five" => 5, "Six" => 6, "Seven" => 7}.each do |k, v|
+        assert_equal v, map[k].value
+    end
+  end
+
+  def test_write
+        orig = ''
+    objs = nil
+    File.open("t.tmp") do |f|
+      f.binmode
+      
+      orig = f.read
+      f.seek(0)
+      
+      os = Java::ObjectInputStream.new(f)
+      assert os
+      objs = os.readObjects
+      assert objs
+    end
+    
+    File.open('t.tmp.new', 'w') do |f|
+      f.binmode
+      
+      os = Java::ObjectOutputStream.new(f)
+      os.writeObjects(objs)
+    end
+    
+    mine = File.open('t.tmp.new').read
+    assert_equal mine, orig
+  end
+end
+    
+
+if $0 == __FILE__
+    suite = Test::Unit::TestSuite.new('DataSource')
+    ObjectSpace.each_object(Class) do |klass|
+        suite << klass.suite if (Test::Unit::TestCase > klass)
+    end
+    require 'test/unit/ui/console/testrunner'
+    Test::Unit::UI::Console::TestRunner.run(suite).passed?
+end

metadata

@@ -0,0 +1,58 @@
+!ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: javaobjs
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+date: 2006-04-16 00:00:00 -07:00
+summary: Decode Java Serialized Objects to Ruby Objects.
+require_paths: 
+- lib
+email: willsobel@mac.com
+homepage: http://www.rubyforge.org
+rubyforge_project: javaobj
+description: Takes Java serialized objects in a file or stream and creates Ruby wrapper objects and decodes. The package can also write Java objects once UUID is read from sample.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- William Sobel
+files: 
+- rakefile
+- install.rb
+- lib/CVS
+- lib/javaobs.rb
+- lib/CVS/Entries
+- lib/CVS/Repository
+- lib/CVS/Root
+- test/CVS
+- test/Test.java
+- test/test.rb
+- test/Test2.java
+- test/CVS/Entries
+- test/CVS/Repository
+- test/CVS/Root
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: 
+- none
+dependencies: []
+