javaobj 0.1

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/javaobs.rb

@@ -0,0 +1,502 @@
+ 
+require 'delegate'
+
+module Java
+  class JavaField
+    attr_reader :name, :type
+    attr_accessor :subtype
+    
+    def initialize(name, type)
+      @name = name
+      @type = type
+      @subtype = nil
+    end
+    
+    def inspect
+      "<JavaField: #{@name}:#{@type.chr}:#{@subtype}>"
+    end
+  end
+  
+  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
+      
+    def addField(field)
+      @fields << field
+    end
+    
+    def to_s
+      @name
+    end
+  end
+  
+  module JavaObject
+    def javaClass
+      @javaClass
+    end
+  end
+  
+  class Date < SimpleDelegator
+    extend JavaObject
+    
+    def initialize
+      super(Time)
+    end
+    
+    def time=(time)
+      case time
+      when Time
+        __setobj__(time)
+        
+      when String
+        t, = time.unpack("Q")
+        __setobj__(Time.at(t / 1000, (t % 1000) * 1000))
+      end
+    end
+
+    def data
+      t = __getobj__.tv_sec * 1000 + __getobj__.tv_usec / 1000
+      [t].pack("Q")
+    end
+  end
+
+  class JavaArray < Array
+    extend JavaObject
+  end
+
+  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
+  
+  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 readBlockData
+      byte = readByte
+      size = nil
+      case byte
+      when TC_BLOCKDATA
+        size = readByte
+        
+      when TC_BLOCKDATALONG
+        size = readInt
+        
+      else
+        raise "Expecting TC_BLOCKDATA" unless byte == TC_BLOCKDATA
+      end
+      
+      data = @str.read(size)
+      byte = readByte
+      raise "Unexpected byte #{byte}" unless byte == TC_ENDBLOCKDATA
+      data
+    end
+    
+    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
+    
+    def readClassAnnotation
+      ebd = readByte
+      raise "We do not handle annotations!" unless ebd == TC_ENDBLOCKDATA
+    end
+    
+    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 == 'java.util.Date'
+        rclass = Java::Date
+        rclass.class_eval "@javaClass = klass"
+        klass.rubyClass = rclass
+      elsif name =~ /^[A-Z.]+/i
+        unless Java.constants.index(klass.name)
+          rclass = Java.module_eval "#{klass.name} = Class.new(#{klass.superClass.to_s})"
+        else
+          rclass = Java.const_get(klass.name)
+        end
+
+        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
+
+    def readArray(klass)
+      size = readInt
+      a = klass.rubyClass.new
+      type = klass.arrayType
+      1.upto(size) do
+        a << readType(type)
+      end
+      a
+    end
+
+    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 "Unknown type #{type}"
+      end
+    end
+
+    def readClassData(klass, object = nil)
+      # Handle special case for Date
+      if object == nil
+        if (klass.javaName == 'java.util.Date')
+          object = Java::Date.new
+        else
+          object = klass.rubyClass.new()
+        end
+        @objects << object
+      end
+      
+      readClassData(klass.superClass, object) if (klass.superClass)
+      
+      if klass.flags == SC_SERIALIZABLE
+        klass.fields.each do |f|
+          v = readType(f.type, f.subtype, f)
+          object.send((f.name + '=').intern, v)
+        end
+      else
+        data = readBlockData
+        object.time = data
+      end
+      
+      object
+    end
+    
+    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 "Unexpected byte #{byte} at #{@str.pos}"
+      end
+
+      object
+    end
+
+    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
+
+    def readObjects
+      objs = []
+      until (@str.eof)
+        objs << readObject
+      end
+      objs
+    end
+  end
+
+  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
+
+   def nextHandle
+     h = @nextHandle
+     @nextHandle += 1
+     h
+   end
+   
+   def writeArray(klass, v)
+     type = klass.arrayType
+     writeInt(v.length)
+     v.each do |e|
+       writeType(type, e)
+     end
+   end
+   
+   def writeBlockData(data)
+     if (data.length <= 255)
+       writeByte(TC_BLOCKDATA)
+       writeByte(data.length)
+     else
+       writeByte(TC_BLOCKDATALONG)
+       writeInt(data.length)
+     end
+
+     @str.write data
+     writeByte(TC_ENDBLOCKDATA)
+   end
+
+   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 "Unknown type #{type}"
+     end
+   end
+
+   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 writeObjectData(klass, obj)
+     writeObjectData(klass.superClass, obj) if klass.superClass
+     
+     if klass.flags == SC_SERIALIZABLE
+       klass.fields.each do |f|
+         v = obj.send(f.name.intern)
+         writeType(f.type, v)
+       end
+     else
+       writeBlockData(obj.data)
+     end
+   end
+   
+   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
+
+   def writeObjects(objs)
+     objs.each do |o|
+       writeObject o
+     end
+   end
+   
+   def initialize(str)
+     @str = str
+     @handles = {}
+     @nextHandle = 0
+     
+     writeUShort(STREAM_MAGIC)
+     writeShort(STREAM_VERSION)
+   end
+  end
+end
+

data/rakefile

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+PKG_BUILD     = '1'
+PKG_NAME      = 'javaobj'
+PKG_VERSION   = '0.1'
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+RUBY_FORGE_PROJECT = "javaobj"
+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.options << '--line-numbers' << '--inline-source'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('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

data/test/Test.java

@@ -0,0 +1,50 @@
+import java.io.*;
+import java.util.Date;
+
+public class Test implements Serializable
+{
+    int a;
+    int b;
+    long c;
+    String d;
+    int e[];
+
+    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 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);
+
+	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/test.rb

@@ -0,0 +1,79 @@
+
+$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")
+  end
+  
+  def teardown
+    File.unlink('t.tmp')
+    File.unlink('t.tmp.new')
+  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_equal obj2.class, Java::Date
+  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,50 @@
+!ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: javaobj
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+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/javaobs.rb
+- test/Test.class
+- test/Test.java
+- test/test.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: 
+- none
+dependencies: []
+