java_inline 0.0.4-java

data/README

@@ -0,0 +1,15 @@
+java-inline is a plugin for RubyInline that adds JVM language support. See the examples dir for a simple example of using it.
+
+java-inline adds support for Java
+
+scala-inline adds support for Scala.
+
+Running example
+-------------------
+
+gem install RubyInline
+
+and to run the example
+cd examples
+jruby fastmath.rb
+jruby -J-Dscala.home=<your scala home> scalamath.rb

data/examples/javamath.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'inline'
+require 'java_inline'
+require 'benchmark'
+
+class FastMath
+  def factorial_ruby(n)
+    f = 1
+    n.downto(2) { |x| f *= x }
+    return f
+  end
+
+  def fib_ruby(n)
+    if n < 2
+      n
+    else
+      fib_ruby(n - 2) + fib_ruby(n - 1)
+    end
+  end
+  
+  inline :Java do |builder|
+    builder.package "org.jruby.test"
+    builder.java "
+      public static long factorial_java(int max) {
+        int i=max, result=1;
+        while (i >= 2) { result *= i--; }
+        return result;
+      }
+      "
+
+    builder.java "
+      public static int fib_java(int n) {
+        if (n < 2) return n;
+
+        return fib_java(n - 2) + fib_java(n - 1); 
+      }
+      "
+  end
+end
+
+math = FastMath.new
+
+Benchmark.bmbm(30) {|bm|
+  5.times { bm.report("factorial_ruby") { 30000.times { math.factorial_ruby(30) } } }
+  5.times { bm.report("factorial_java") { 30000.times { math.factorial_java(30) } } }
+  5.times { bm.report("fib_ruby(35)") { math.fib_ruby(35) } }
+  5.times { bm.report("fib_java(35)") { math.fib_java(35) } }
+}
+

data/examples/mirahmath.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'inline'
+require 'mirah_inline'
+require 'benchmark'
+
+class FastMath
+  def factorial_ruby(n)
+    f = 1
+    n.downto(2) { |x| f *= x }
+    return f
+  end
+
+  def fib_ruby(n)
+    if n < 2
+      n
+    else
+      fib_ruby(n - 2) + fib_ruby(n - 1)
+    end
+  end
+  
+  inline :Mirah do |builder|
+    builder.mirah "
+      def factorial_mirah(max:int)
+        i = max
+        result = 1
+        while i >= 2; result *= i-=1; end
+        result
+      end
+      "
+
+    builder.mirah "
+      def fib_mirah(n:int)
+        if n < 2
+          n
+        else
+          fib_mirah(n - 2) + fib_mirah(n - 1)
+        end
+      end
+      "
+  end
+end
+
+math = FastMath.new
+
+Benchmark.bmbm(30) {|bm|
+  5.times { bm.report("factorial_ruby") { 30000.times { math.factorial_ruby(30) } } }
+  5.times { bm.report("factorial_mirah") { 30000.times { math.factorial_mirah(30) } } }
+  5.times { bm.report("fib_ruby(35)") { math.fib_ruby(35) } }
+  5.times { bm.report("fib_mirah(35)") { math.fib_mirah(35) } }
+}
+

data/examples/scalamath.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'inline'
+require '../lib/scala_inline'
+require 'benchmark'
+
+class FastMath
+  def factorial_ruby(n)
+    f = 1
+    n.downto(2) { |x| f *= x }
+    return f
+  end
+
+  def fib_ruby(n)
+    if n < 2
+      n
+    else
+      fib_ruby(n - 2) + fib_ruby(n - 1)
+    end
+  end
+  
+  inline :Scala do |builder|
+    builder.package "org.jruby.test"
+    builder.scala "
+      def factorial_scala(max:Int) = {
+        (1 /: 2.to(max)) { (accumulator, next) => accumulator * next }
+      }
+      "
+    builder.scala "
+      def fib_scala(n:Int):Int = {
+         if (n < 2) n
+         else fib_scala(n - 2) + fib_scala(n - 1)
+      }
+      " 
+  end
+end
+
+math = FastMath.new
+
+Benchmark.bmbm(30) {|bm|
+  5.times { bm.report("factorial_ruby") { 30000.times { math.factorial_ruby(30) } } }
+  5.times { bm.report("factorial_scala") { 30000.times { math.factorial_scala(30) } } }
+  5.times { bm.report("fib_ruby(35)") { math.fib_ruby(35) } }
+  5.times { bm.report("fib_scala(35)") { math.fib_scala(35) } }
+}
+

data/lib/java_inline.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+require 'inline'
+require 'java'
+
+# Add the inline cache dir to CLASSPATH
+$CLASSPATH << Inline.directory
+
+module Inline
+  
+  # A Java builder for RubyInline. Provides the basic methods needed to
+  # allow assembling a set of Java methods that compile into a class and
+  # get bound to the same names in the containing module.
+  class Java
+    JFile = java.io.File
+    import javax.tools.ToolProvider
+    import javax.tools.SimpleJavaFileObject
+    import javax.tools.StandardLocation
+
+    def initialize(mod)
+      @context = mod
+      @src = ""
+      @imports = []
+      @sigs = []
+    end
+    
+    def load_cache
+      false
+    end
+    
+    # Set the package to use for the Java class being generated, as in
+    # builder.package "org.foo.bar"
+    def package(pkg)
+      @pkg = pkg
+    end
+
+    # Add an "import" line with the given class, as in
+    # builder.import "java.util.ArrayList". The imports will be composed
+    # into an appropriate block of code and added to the top of the source.
+    def import(cls)
+      if cls.respond_to? :java_class
+        @imports << cls.java_class.name
+      else
+        @imports << cls.to_s
+      end
+    end
+
+    # Add a Java method to the built Java source. This expects the method to
+    # be public and static, so it can be called as a function.
+    def java(src)
+      @src << src << "\n"
+      signature = src.match(/public static\W+(\w+)\W+([a-zA-Z0-9_]+)\((.*)\)/)
+      raise "Could not parse method signature" unless signature
+      @sigs << [signature[1], signature[2], signature[3]]
+    end
+
+    def build
+      compiler = ToolProvider.system_java_compiler
+      file_mgr = compiler.get_standard_file_manager(nil, nil, nil)
+      file_mgr.set_location(StandardLocation::CLASS_OUTPUT, [JFile.new(Inline.directory)])
+      
+      if @pkg
+        directory = "#{Inline.directory}/#{@pkg.gsub('.', '/')}"
+        unless File.directory? directory then
+          $stderr.puts "NOTE: creating #{directory} for RubyInline" if $DEBUG
+          FileUtils.mkdir_p directory
+        end
+        
+        @name = "Java#{@src.hash.abs}"
+        @load_name = "#{@pkg}.#{@name}"
+        filename = "#{directory}/#{@name}.java"
+      
+        imports = "import " + @imports.join(";\nimport ") + ";" if @imports.size > 0
+        full_src = "
+          package #{@pkg};
+          #{imports}
+          public class #{@name} {
+          #{@src}
+          }
+        "
+      else
+        @load_name = @name = "Java#{@src.hash.abs}"
+        filename = "#{Inline.directory}/#{@name}.java"
+      
+        imports = "import " + @imports.join(";\nimport ") + ";" if @imports.size > 0
+        full_src = "
+          #{imports}
+          public class #{@name} {
+          #{@src}
+          }
+        "
+      end
+      
+      File.open(filename, "w") {|file| file.write(full_src)}
+      file_objs = file_mgr.get_java_file_objects_from_strings([filename])
+      
+      compiler.get_task(nil, file_mgr, nil, nil, nil, file_objs).call
+      file_mgr.close
+    end
+
+    def load
+      @context.module_eval "const_set :#{@name}, ::Java::#{@load_name}"
+      @sigs.each do |sig|
+        @context.module_eval "def #{sig[1]}(*args); #{@name}.#{sig[1]}(*args); end"
+      end
+    end
+  end
+end

data/lib/mirah_inline.rb

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'inline'
+require 'java'
+require 'mirah'
+
+# Add the inline cache dir to CLASSPATH
+$CLASSPATH << Inline.directory
+
+module Inline
+  
+  # A Mirah builder for RubyInline. Provides the basic methods needed to
+  # allow assembling a set of Mirah methods that compile into a class and
+  # get bound to the same names in the containing module.
+  class Mirah
+    def initialize(mod)
+      @context = mod
+      @src = ""
+      @imports = []
+      @sigs = []
+    end
+    
+    def load_cache
+      false
+    end
+
+    # Add an "import" line with the given class, as in
+    # builder.import "java.util.ArrayList". The imports will be composed
+    # into an appropriate block of code and added to the top of the source.
+    def import(cls)
+      if cls.respond_to? :java_class
+        @imports << cls.java_class.name
+      else
+        @imports << cls.to_s
+      end
+    end
+
+    # Add a Java method to the built Java source. This expects the method to
+    # be public and static, so it can be called as a function.
+    def duby(src)
+      @src << src << "\n"
+      signature = src.match(/def ([a-zA-Z0-9_]+)\((.*)\)/)
+      raise "Could not parse method signature" unless signature
+      @sigs << [nil, signature[1], signature[2]]
+    end
+
+    def build
+      @load_name = @name = "Mirah#{@src.hash.abs}"
+      filename = "#{@name}.mirah"
+
+      imports = "import " + @imports.join("\nimport ") if @imports.size > 0
+      full_src = "
+        #{imports}
+        class #{@name}
+        #{@src}
+        end
+      "
+
+      File.open(filename, "w") {|file| file.write(full_src)}
+      Dir.chdir(Inline.directory) do
+        ::Mirah.compile(filename)
+      end
+    end
+
+    def load
+      @context.module_eval "const_set :#{@name}, ::Java::#{@load_name}.new"
+      @sigs.each do |sig|
+        @context.module_eval "def #{sig[1]}(*args); #{@name}.#{sig[1]}(*args); end"
+      end
+    end
+  end
+end

data/lib/scala_inline.rb

@@ -0,0 +1,102 @@
+require 'rubygems'
+require 'inline'
+require 'java'
+include_class Java::java.lang.System
+
+# Add the inline cache dir to CLASSPATH
+$CLASSPATH << Inline.directory
+$CLASSPATH << "#{System.getProperty('scala.home')}/lib/scala-compiler.jar"
+$CLASSPATH << "#{System.getProperty('scala.home')}/lib/scala-library.jar"      
+
+module Inline
+  
+  # A Java builder for RubyInline. Provides the basic methods needed to
+  # allow assembling a set of Java methods that compile into a class and
+  # get bound to the same names in the containing module.
+  class Scala
+    JFile = java.io.File
+    include_class Java::scala.tools.nsc.Main
+    
+    def initialize(mod)
+      @context = mod
+      @src = ""
+      @imports = []
+      @sigs = []
+    end
+
+    def load_cache
+      false
+    end
+    
+    # Set the package to use for the Java class being generated, as in
+    # builder.package "org.foo.bar"
+    def package(pkg)
+      @pkg = pkg
+    end
+
+    # Add an "import" line with the given class, as in
+    # builder.import "java.util.ArrayList". The imports will be composed
+    # into an appropriate block of code and added to the top of the source.
+    def import(cls)
+      if cls.respond_to? :java_class
+        @imports << cls.java_class.name
+      else
+        @imports << cls.to_s
+      end
+    end
+
+    # Add a Scala method to the built Scala source. This expects the method to
+    # be public and static, so it can be called as a function.
+    def scala(src)
+      @src << src << "\n"
+      signature = src.match(/def\W+([a-zA-Z0-9_]+)\((.*)\)/)
+      raise "Could not parse method signature" unless signature
+      @sigs << [signature[1], signature[2]]
+    end
+
+    def build      
+      if @pkg
+        directory = "#{Inline.directory}/#{@pkg.gsub('.', '/')}"
+        unless File.directory? directory then
+          $stderr.puts "NOTE: creating #{directory} for RubyInline" if $DEBUG
+          FileUtils.mkdir_p directory
+        end
+        
+        @name = "Scala#{@src.hash.abs}"
+        @load_name = "#{@pkg}.#{@name}"
+        filename = "#{directory}/#{@name}.scala"
+      
+        imports = "import " + @imports.join("\nimport ") if @imports.size > 0
+        full_src = "
+          package #{@pkg}
+          #{imports}
+          object #{@name} {
+          #{@src}
+          }
+        "
+      else
+        @load_name = @name = "Java#{@src.hash.abs}"
+        filename = "#{Inline.directory}/#{@name}.scala"
+      
+        imports = "import " + @imports.join("\nimport ") if @imports.size > 0
+        full_src = "
+          #{imports}
+          object #{@name} {
+          #{@src}
+          }
+        "
+      end
+      
+      File.open(filename, "w") {|file| file.write(full_src)}
+      cmd_args = [filename, "-classpath", "#{System.getProperty('scala.home')}/lib/scala-library.jar", "-d", "#{Inline.directory}"]
+      Main.process(cmd_args.to_java(:string))
+    end
+
+    def load
+      @context.module_eval "const_set :#{@name}, ::Java::#{@load_name}"
+      @sigs.each do |sig|
+        @context.module_eval "def #{sig[0]}(*args); #{@name}.#{sig[0]}(*args); end"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: java_inline
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.4
+platform: java
+authors: 
+  - Charles Oliver Nutter
+  - Nilanjan Raychaudhuri
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-23 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: RubyInline
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id001
+description: A set of plugins for RubyInline to allow embedding JVM languages into Ruby code running on JRuby
+email: 
+  - headius@headius.com
+  - nraychaudhuri@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - README
+  - lib/java_inline.rb
+  - lib/mirah_inline.rb
+  - lib/scala_inline.rb
+  - examples/javamath.rb
+  - examples/mirahmath.rb
+  - examples/scalamath.rb
+homepage: http://github.com/jruby/java_inline
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: java_inline
+rubygems_version: 1.8.9
+signing_key: 
+specification_version: 3
+summary: JVM language support for RubyInline
+test_files: []
+