ruby2java 0.0.1

data/History.txt

@@ -0,0 +1,9 @@
+=== 0.0.1 / 2009-05-20
+
+* First experimental version
+* Basic compilation of a Ruby class to a Java class
+* public instance and static methods and public constructors
+* interface implementation
+* package specification
+* basic method annotations
+

data/LICENSE.txt

@@ -0,0 +1 @@
+

data/Manifest.txt

@@ -0,0 +1,21 @@
+bin/ruby2java
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+LICENSE.txt
+lib/compilable.rb
+lib/compiler.rb
+lib/ruby2java.rb
+lib/compilable/annotation.rb
+lib/compilable/interface.rb
+lib/compilable/package.rb
+lib/compilable/signature.rb
+examples/MyObjectTest.java
+examples/MyObjectTest2.java
+examples/annotations.rb
+examples/interface_example.rb
+examples/metaprogramming.rb
+examples/package_example.rb
+examples/ruby_main.rb
+examples/simple_signatures.rb

data/README.txt

@@ -0,0 +1,57 @@
+The Ruby2Java compiler inspects the *runtime* definition of classes
+to produce a normal-looking Java class. All metaprogrammed methods
+are reflected on the Java class, as are runtime modifications to
+those methods.
+
+== Installation
+
+  gem install ruby2java
+
+== How do I use it?
+
+To create a Java class from a Ruby class, use the following command:
+
+  ruby2java RubyClass file1.rb [file2.rb ...]
+
+The compiler will then:
+
+1. Require in all specified files. Watch those load-time side-effects!
+2. Retrieve the named Ruby class
+3. Inspect the Ruby class object for "signatures" and "annotations"
+   methods, from which it gathers Java signature/annotation info
+3a. Inspect the Ruby class object for "static_signatures" and
+    "static_annotations" methods, for static (class) methods
+4. Generate a Java .class file for the new same-named Java class
+
+The resulting Java class will have normal constructors and methods
+and will be constructible and callable lke any other Java class.
+
+== What do I need?
+
+* JRuby 1.3.0RC2 or higher
+
+== Features
+
+* Public instance methods, static methods, and constructors
+* Interface implementation
+* Package specification
+* Basic method annotation
+
+== Known Issues
+
+* All Java dependencies must be compiled and available on JRuby's
+  classpath for the compiler to work (since it must be able to see
+  those classes when generating the Java signatures/annotations).
+* There is no dependency tracking between compiled Ruby classes.
+  If two Ruby2Java-compiled Ruby classes depend on each other for
+  their Java signatures, you will need them to use "Object" or some
+  common supertype.
+* Circular dependencies are not yet supported. (implied by above)
+* Extending an existing Java class is not yet supported.
+* Annotations have only been cursorily tested, and may not work for
+  nontrivial cases.
+* Because the .rb files specified are embedded in the .class, it will
+  be larger than the sum of all those file sizes. It also does not
+  provide much of an obfuscation boundary.
+* There are no optimizations in place to speed the dynamic dispatch
+  performed by each of the generated Java methods.

data/Rakefile

@@ -0,0 +1,50 @@
+#TODO Remove all unnecessary code.
+
+require 'rake'
+require 'rake/testtask'
+
+MANIFEST = FileList['bin/*', 'History.txt', 'Manifest.txt', 'README.txt', 
+  'Rakefile', 'LICENSE.txt', 'lib/**/*.rb', "examples/**/*.{java,rb}"]
+
+task :default do
+  puts 'We\'re coming!'
+end
+
+task :spec do
+  require 'spec/rake/spectask'
+  desc 'Runs Specs'
+  
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_opts ||= []
+    t.spec_files =  if ENV['class'].nil?
+                      FileList['spec/**_spec.rb']
+                    else
+                      File.join('spec', ENV['class']+'_spec.rb')
+                    end
+  end
+end
+
+file 'Manifest.txt' => :manifest
+task :manifest do
+  File.open('Manifest.txt', 'w') {|f| MANIFEST.each {|n| f << "#{n}\n"} }
+end
+Rake::Task['manifest'].invoke # Always regen manifest, so Hoe has up-to-date list of files
+
+require File.dirname(__FILE__) + '/lib/ruby2java'
+begin
+  require 'hoe'
+  Hoe.new('ruby2java', Ruby2Java::VERSION) do |p| # TODO: Final name: compiler2, ruby2java, r2j2?
+    p.rubyforge_name = "jruby-extras"
+    p.url = 'http://kenai.com/projects/ruby2java/pages/Home'
+    p.developer 'Thomas E. Enebo', 'tom.enebo@gmail.com'
+    p.developer 'Charles O. Nutter', 'charles.nutter@sun.com'
+    p.developer 'Sergio Rodríguez Arbeo', 'serabe@gmail.com'
+    p.summary = 'Tool for JRuby to turn Ruby code into Java classes'
+    p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+    p.description = p.paragraphs_of('README.txt', 0...1).join
+  end.spec.dependencies.delete_if { |dep| dep.name == 'hoe' }
+rescue LoadError
+  puts 'You really need Hoe installed to be able to package this gem'
+rescue => e
+  puts "ignoring error while loading hoe: #{e.to_s}"
+end

data/bin/ruby2java

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), '..', 'lib', 'ruby2java')
+
+if ARGV.length < 2
+  puts "usage: ruby2java <ruby class> <embed1.rb> [<embed2.rb> ...]"
+  exit 1
+end
+
+ruby_class_name = ARGV.shift
+embed_files = ARGV.dup
+
+embed_files.each do |file|
+  require file
+end
+
+ruby_class = eval(ruby_class_name)
+
+java_compiler = Ruby2Java::JavaCompiler.new(embed_files[0])
+java_compiler.process_class(ruby_class_name, ruby_class, ruby_class_name, *embed_files)
+
+java_compiler.write_files

data/examples/MyObjectTest.java

@@ -0,0 +1,7 @@
+public class MyObjectTest {
+  public static void main(String[] args) {
+    MyObject obj = new MyObject();
+    obj.helloWorld();
+    obj.goodbyeWorld("hello");
+  }
+}

data/examples/MyObjectTest2.java

@@ -0,0 +1,13 @@
+public class MyObjectTest2 {
+  public static void main(String[] args) {
+    MyObject2 obj = new MyObject2();
+    obj.booleanMethod(false);
+    obj.byteMethod((byte)1);
+    obj.shortMethod((short)1);
+    obj.charMethod((char)1);
+    obj.intMethod(1);
+    obj.longMethod(1L);
+    obj.floatMethod(1.0f);
+    obj.doubleMethod(1.0);
+  }
+}

data/examples/annotations.rb

@@ -0,0 +1,17 @@
+class TestSomething
+  def test_jruby_rocks
+    fail unless "JRuby rocks" == "JRuby" + " " + "rocks"
+  end
+
+  def test_jruby_will_never_support_annotations
+    fail("JRuby does support annotations!") if "JRuby supports annotations"
+  end
+end
+
+# Anywhere else in your project, you can turn this into a Java class
+if defined? Ruby2Java
+  TestSomething.signature 'test_jruby_rocks', [] => nil
+  TestSomething.signature 'test_jruby_will_never_support_annotations', [] => nil
+  TestSomething.annotation 'test_jruby_rocks', org.junit.Test => nil
+  TestSomething.annotation 'test_jruby_will_never_support_annotations', org.junit.Test => nil
+end

data/examples/interface_example.rb

@@ -0,0 +1,3 @@
+class RubyClass
+  interface java.lang.Cloneable if defined? Ruby2Java
+end

data/examples/metaprogramming.rb

@@ -0,0 +1,10 @@
+require 'rbconfig'
+require 'java'
+
+class Metaprogramming
+  %w[boolean byte short char int long float double].each do |type|
+    java_type = Java.send type
+    eval "def #{type}Method(a); a; end"
+    signature "#{type}Method", [java_type] => java_type if defined? Ruby2Java
+  end
+end

data/examples/package_example.rb

@@ -0,0 +1,3 @@
+class RubyClass
+  package "org.jruby.ruby2java" if defined? Ruby2Java
+end

data/examples/ruby_main.rb

@@ -0,0 +1,9 @@
+class RubyMain
+  def self.main(args)
+    args.each {|arg| puts arg}
+  end
+end
+
+if defined? Ruby2Java
+  RubyMain.static_signature :main, [java.lang.String[]] => Java::void
+end

data/examples/simple_signatures.rb

@@ -0,0 +1,15 @@
+require 'rbconfig'
+
+class SimpleSignatures
+  def helloWorld
+    puts "Hello from Ruby"
+  end
+  def goodbyeWorld(a)
+    puts a
+  end
+
+  if defined? Ruby2Java
+    signature :helloWorld, [] => Java::void
+    signature :goodbyeWorld, [java.lang.String] => Java::void
+  end
+end

data/lib/compilable.rb

@@ -0,0 +1,5 @@
+dir = File.join( File.dirname(__FILE__), 'compilable')
+require File.join(dir,'interface')
+require File.join(dir,'package')
+require File.join(dir,'signature')
+require File.join(dir,'annotation')

data/lib/compilable/annotation.rb

@@ -0,0 +1,26 @@
+class Class
+  def annotation(name, anno_hash = {})
+    name = name.to_s
+    annotations[name] ||= {}
+    anno_hash.each do |k,v|
+      annotations[name][k] = v
+    end
+  end
+
+  def annotations
+    @annotations ||= {}
+  end
+
+  def static_annotation(name, anno_hash = {})
+    name = name.to_s
+    annotations[name] ||= {}
+    anno_hash.each do |k,v|
+      static_annotations[name][k] = v
+    end
+  end
+
+  def static_annotations
+    @static_annotations ||= {}
+  end
+end
+

data/lib/compilable/interface.rb

@@ -0,0 +1,12 @@
+class Class
+
+  def interface(*list)
+    raise ArgumentError, "at least 1 interface needed" if list.empty?
+    interfaces.push *list
+    interfaces.uniq!
+  end
+
+  def interfaces
+    @interfaces ||= []
+  end
+end

data/lib/compilable/package.rb

@@ -0,0 +1,11 @@
+class Class
+
+  def package(*package_name)
+    raise ArgumentError, 'too few arguments' if package_name.empty?
+    # Should we raise an exception?
+    # Only first called is considered.
+    @package_name = package_name.map!{|x| x.split('.')}.flatten unless @package_name
+  end
+
+  attr_reader :package_name
+end

data/lib/compilable/signature.rb

@@ -0,0 +1,61 @@
+require 'jruby/ext'
+
+class Class
+
+  def signature(name, signature)
+    name = name.to_s
+    params = signature.keys.first
+    sig = Signature.new(params, signature[params])
+    sig_method = instance_method(name) || method(name)
+    if sig.fit? *(sig_method.args)
+      signatures[name] = [sig]
+    else
+      raise ArgumentError, "java signature does not fit ruby signature"
+    end
+  end
+
+  def signatures
+    @signatures ||= {}
+  end
+
+  def static_signature(name, signature)
+    name = name.to_s
+    params = signature.keys.first
+    sig = Signature.new(params, signature[params])
+    sig_method = begin
+      instance_method(name)
+    rescue NameError
+      method(name)
+    end
+    if sig.fit? *(sig_method.args)
+      static_signatures[name] = [sig]
+    else
+      raise ArgumentError, "java signature does not fit ruby signature"
+    end
+  end
+
+  def static_signatures
+    @static_signatures ||= {}
+  end
+end
+
+class Signature
+  attr_accessor :params, :retval
+
+  def initialize(params, retval)
+    @params, @retval = params.dup, retval
+  end
+
+  # Check if a signature fits in the "arity" of a method
+  # should be called sig.fit? *args
+  # where args come from instance_method(:foo).args
+  def fit?(compulsory, optional, rest, block)     # TODO: Check for blocks
+    compulsory.size <= params.size && compulsory.size + optional.size >= params.size #|| !rest.nil?
+  end
+
+  def self.undefined_for_arity(arity)
+    params = (arity < 0) ? [IRubyObject[]] : [IRubyObject] * arity
+
+    [Signature.new(params, IRubyObject)]
+  end
+end

data/lib/compiler.rb

@@ -0,0 +1,263 @@
+require 'rubygems'
+require 'bitescript'
+require File.join( File.dirname(__FILE__), 'compilable.rb')
+require 'fileutils'
+
+module Ruby2Java
+  class JavaCompiler
+    RubyObject = org.jruby.RubyObject
+    RubyBasicObject = org.jruby.RubyBasicObject
+    Ruby = org.jruby.Ruby
+    RubyClass = org.jruby.RubyClass
+    IRubyObject = org.jruby.runtime.builtin.IRubyObject
+    ThreadContext = org.jruby.runtime.ThreadContext
+    LoadService = org.jruby.runtime.load.LoadService
+    JClass = java.lang.Class
+    JavaUtil = org.jruby.javasupport.JavaUtil
+    JObject = java.lang.Object
+
+    def initialize(source_name)
+      @file_builder = BiteScript::FileBuilder.new(source_name)
+    end
+
+    def write_files
+      @file_builder.generate do |name, builder|
+        FileUtils.mkdir_p File.dirname(name)
+        File.open(name, 'w') do |f|
+          f.write(builder.generate)
+        end
+      end
+    end
+
+    def process_class(ruby_class_path, ruby_class, java_name, *require_files)
+      @file_builder.package = ruby_class.package_name if ruby_class.package_name
+
+      cb = @file_builder.public_class(java_name, RubyObject, *ruby_class.interfaces);
+
+      # field to hold the RubyClass reference
+      cb.private_static_field "__ruby_class__", RubyClass
+
+      # If a require file is specified, load it in static initializer
+      cb.static_init do
+        invokestatic Ruby, "getGlobalRuntime", [Ruby]
+        require_files.each do |require_file|
+          dup
+          ldc File.read(require_file)
+          ldc require_file
+          invokevirtual Ruby, "executeScript", [IRubyObject, cb.string, cb.string]
+          pop
+        end
+        ldc ruby_class_path
+        invokevirtual Ruby, "getClass", [RubyClass, cb.string]
+        dup
+        putstatic this, "__ruby_class__", RubyClass
+        ldc this.name
+        invokestatic JClass, "forName", [JClass, string]
+        invokevirtual RubyClass, "setClassAllocator", [void, JClass]
+        # load the script contents into the class file
+        returnvoid
+      end
+
+      cb.public_constructor do
+        aload 0
+        invokestatic Ruby, "getGlobalRuntime", [Ruby]
+        getstatic this, "__ruby_class__", RubyClass
+        invokespecial RubyObject, "<init>", [cb.void, Ruby, RubyClass]
+        returnvoid
+      end
+
+      for method_name in ruby_class.public_instance_methods(false) do
+        method = ruby_class.instance_method(method_name)
+        signatures = if ruby_class.respond_to? :signatures
+          ruby_class.signatures[method_name]
+        else
+          nil
+        end
+        annotations = if ruby_class.respond_to? :annotations
+          ruby_class.annotations[method_name]
+        else
+          nil
+        end
+
+        create_method(cb, method_name, method, signatures, annotations)
+      end
+
+      for method_name in ruby_class.public_methods(false) do
+        method = ruby_class.method(method_name)
+        signatures = if ruby_class.respond_to? :static_signatures
+          ruby_class.static_signatures[method_name]
+        else
+          nil
+        end
+        annotations = if ruby_class.respond_to? :static_annotations
+          ruby_class.static_annotations[method_name]
+        else
+          nil
+        end
+
+        create_method(cb, method_name, method, signatures, annotations, :static => true)
+      end
+    end
+
+    def create_method(cb, method_name, method, signatures = nil, annotations = nil, options = {})
+      java_signature = true
+
+      unless signatures
+        signatures = Signature.undefined_for_arity(method.arity)
+        java_signature = false
+      end
+
+      for s in signatures do
+        if options[:static]
+          mb = cb.public_static_method method_name, s.retval, *(s.params)
+        else
+          mb = cb.public_method method_name, s.retval, *(s.params)
+        end
+
+        mb.start
+
+        if annotations && annotations.size > 0
+          # define annotations
+          annotations.each do |anno_cls, anno_data|
+            mb.annotate(anno_cls, true) do |anno|
+              anno_data.each {|k,v| anno.send(k + "=", v)} if anno_data
+            end
+          end
+        end
+
+        # prepare receiver, context, and method name for callMethod later
+        options[:static] ? mb.getstatic(mb.this, "__ruby_class__", RubyClass) : mb.aload(0)
+        mb.dup
+        mb.invokeinterface IRubyObject, "getRuntime", [Ruby]
+        ruby_index = first_local(s.params, !options[:static])
+        mb.dup; mb.astore ruby_index
+        mb.invokevirtual Ruby, "getCurrentContext", [ThreadContext]
+        mb.ldc method_name
+
+        # TODO: arity-specific calling
+        if java_signature
+          java_args(mb, method, s.params, ruby_index, options)
+        else
+          ruby_args(mb, method, ruby_index, options)
+        end
+
+        # invoke the method dynamically
+        # TODO: this could have a simple inline cache
+        mb.invokevirtual RubyBasicObject, "callMethod", [IRubyObject, ThreadContext, mb.string, IRubyObject[]]
+
+        # return the result
+        if java_signature
+          java_return(mb, s.retval)
+        else
+          ruby_return(mb, s.retval)
+        end
+
+        mb.stop
+      end
+    end
+
+    def first_local(params, instance = true)
+      i = instance ? 1 : 0
+      params.each do |param|
+        if param == Java::long || param == Java::double
+          i += 2
+        else
+          i += 1
+        end
+      end
+      i
+    end
+
+    def java_args(mb, method, params, ruby_index, options = {})
+      # We have a signature and need to use java integration logic
+      mb.ldc params.size
+      mb.anewarray IRubyObject
+      base = options[:static] ? 0 : 1
+      index = base
+      0.upto(params.size - 1) do |i|
+        mb.dup
+        mb.ldc i 
+        mb.aload ruby_index
+        param_type = params[i - 1]
+        if [mb.boolean, mb.byte, mb.short, mb.char, mb.int].include? param_type
+          mb.iload index + base
+          mb.invokestatic JavaUtil, "convertJavaToRuby", [IRubyObject, Ruby, mb.int]
+        elsif mb.long == param_type
+          mb.lload index + base
+          mb.invokestatic JavaUtil, "convertJavaToRuby", [IRubyObject, Ruby, mb.long]
+          index += 1
+        elsif mb.float == param_type
+          mb.fload index + base
+          mb.invokestatic JavaUtil, "convertJavaToRuby", [IRubyObject, Ruby, mb.float]
+        elsif mb.double == param_type
+          mb.dload index + base
+          mb.invokestatic JavaUtil, "convertJavaToRuby", [IRubyObject, Ruby, mb.double]
+          index += 1
+        else
+          mb.aload index + base
+          mb.invokestatic JavaUtil, "convertJavaToUsableRubyObject", [IRubyObject, Ruby, mb.object]
+        end
+        mb.aastore
+        index += 1
+      end
+    end
+
+    def ruby_args(mb, method, ruby_index, options = {})
+      if method.arity < 0
+        # restarg or optarg, just pass array through
+        mb.aload options[:static] ? 0 : 1
+      else
+        # all normal args, box them up
+        mb.ldc method.arity
+        mb.anewarray IRubyObject
+        i = ruby_index;
+        base = options[:static] ? 0 : 1
+        0.upto(method.arity - 1) do |i|
+          mb.dup
+          mb.ldc i
+          mb.aload i + base
+          mb.aastore
+        end
+      end
+    end
+
+    def ruby_return(mb, retval)
+      mb.areturn
+    end
+
+    def java_return(mb, retval)
+      if mb.boolean == retval
+        mb.invokestatic JavaUtil, "convertRubyToJavaBoolean", [mb.boolean, IRubyObject]
+        mb.ireturn
+      elsif mb.byte == retval
+        mb.invokestatic JavaUtil, "convertRubyToJavaByte", [mb.byte, IRubyObject]
+        mb.ireturn
+      elsif mb.short == retval
+        mb.invokestatic JavaUtil, "convertRubyToJavaShort", [mb.short, IRubyObject]
+        mb.ireturn
+      elsif mb.char == retval
+        mb.invokestatic JavaUtil, "convertRubyToJavaChar", [mb.char, IRubyObject]
+        mb.ireturn
+      elsif mb.int == retval
+        mb.invokestatic JavaUtil, "convertRubyToJavaInt", [mb.int, IRubyObject]
+        mb.ireturn
+      elsif mb.long == retval
+        mb.invokestatic JavaUtil, "convertRubyToJavaLong", [mb.long, IRubyObject]
+        mb.lreturn
+      elsif mb.float == retval
+        mb.invokestatic JavaUtil, "convertRubyToJavaFloat", [mb.float, IRubyObject]
+        mb.freturn
+      elsif mb.double == retval
+        mb.invokestatic JavaUtil, "convertRubyToJavaDouble", [mb.double, IRubyObject]
+        mb.dreturn
+      elsif retval == mb.void || retval == nil
+        mb.pop
+        mb.returnvoid
+      else
+        mb.ldc retval
+        mb.invokestatic JavaUtil, "convertRubyToJava", [JObject, IRubyObject, JClass]
+        mb.areturn
+      end
+    end
+  end
+end

data/lib/ruby2java.rb

@@ -0,0 +1,6 @@
+require File.join(File.dirname(__FILE__), 'compiler')
+require File.join(File.dirname(__FILE__), 'compilable')
+
+module Ruby2Java
+  VERSION='0.0.1'
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - '>='
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+email: 
+- tom.enebo@gmail.com
+- charles.nutter@sun.com
+- serabe@gmail.com
+cert_chain: []
+
+summary: Tool for JRuby to turn Ruby code into Java classes
+post_install_message: 
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- LICENSE.txt
+homepage: http://kenai.com/projects/ruby2java/pages/Home
+signing_key: 
+name: ruby2java
+rdoc_options: 
+- --main
+- README.txt
+rubyforge_project: jruby-extras
+autorequire: 
+licenses: []
+
+executables: 
+- ruby2java
+description: |-
+  The Ruby2Java compiler inspects the *runtime* definition of classes
+  to produce a normal-looking Java class. All metaprogrammed methods
+  are reflected on the Java class, as are runtime modifications to
+  those methods.
+specification_version: 3
+default_executable: 
+files: 
+- bin/ruby2java
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- LICENSE.txt
+- lib/compilable.rb
+- lib/compiler.rb
+- lib/ruby2java.rb
+- lib/compilable/annotation.rb
+- lib/compilable/interface.rb
+- lib/compilable/package.rb
+- lib/compilable/signature.rb
+- examples/MyObjectTest.java
+- examples/MyObjectTest2.java
+- examples/annotations.rb
+- examples/interface_example.rb
+- examples/metaprogramming.rb
+- examples/package_example.rb
+- examples/ruby_main.rb
+- examples/simple_signatures.rb
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - '>='
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+extensions: []
+
+rubygems_version: 1.3.3
+requirements: []
+
+authors: 
+- Thomas E. Enebo
+- Charles O. Nutter
+- "Sergio Rodr\xc3\xadguez Arbeo"
+date: 2009-05-22 05:00:00 +00:00
+platform: ruby
+test_files: []
+
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+require_paths: 
+- lib
+dependencies: []
+
+bindir: bin
+has_rdoc: true