therubyrhino 1.72.3-jruby → 1.72.4-jruby

data/History.txt

@@ -1,5 +1,11 @@
-=== 1.72.3 2009 11-11
-* 1 major enhancement
+=== 1.72.4 2009-11-12
+* 3 major enhancements:
+  * automatically wrap/unwrap ruby and javascript arrays
+  * automatically convert ruby method objects and Proc objects into javascript functions
+  * Make functions defined in javascript callable from ruby
+  
+=== 1.72.3 2009-11-11
+* 4 major enhancements:
   * greatly simplified interface to context by unifying context and scope
   * remove Context#open_std()
   * remove Context#standard

data/Manifest.txt

@@ -5,8 +5,10 @@ Rakefile
 lib/rhino.rb
 lib/rhino/context.rb
 lib/rhino/java.rb
+lib/rhino/native_function.rb
 lib/rhino/native_object.rb
 lib/rhino/rhino-1.7R2.jar
+lib/rhino/ruby_function.rb
 lib/rhino/ruby_object.rb
 lib/rhino/wormhole.rb
 script/console
@@ -14,6 +16,7 @@ script/destroy
 script/generate
 spec/rhino/context_spec.rb
 spec/rhino/native_object_spec.rb
+spec/rhino/ruby_object_spec.rb
 spec/rhino/wormhole_spec.rb
 spec/spec.opts
 spec/spec_helper.rb

data/README.rdoc

@@ -17,33 +17,31 @@ Embed the Mozilla Rhino Javascript interpreter into Ruby
 1. Ruby Objects goes into Javascript
 1. Our shark's in the Javascript!
 
-
-  include Rhino
 # evaluate some simple javascript
 
   Rhino::Context.open do |context|
-    context.evaljs("7 * 6") #=> 42
+    context.eval("7 * 6") #=> 42
   end
 
 # evaluate a ruby function from javascript
   
   Rhino::Context.open do |context|
-    scope = context.init_standard_objects
-    scope["say"] = function {|word, times| word * times}
-    context.evaljs("say("Hello", 3)") #=> HelloHelloHello
+    context["say"] = lambda {|word, times| word * times}
+    context.eval("say("Hello", 3)") #=> HelloHelloHello
   end
 
 # Configure your embedding setup
 
-  Rhino::Context.open do |context|
-    # Make your standard objects (Object, String, etc...) immutable
-    scope = context.init_standard_objects(:sealed => true)
-    context.evaljs("Object.prototype.toString = function() {}") # this is an error!
-    
-    #Turn on Java integration from javascript (probably a bad idea)
-    scope = context.init_standard_objects(:java => true)
-    context.evaljs("java.lang.System.exit()") #it's dangerous!
+  # Make your standard objects (Object, String, etc...) immutable
+  Rhino::Context.open(:sealed => true) do |context|
+    context.eval("Object.prototype.toString = function() {}") # this is an error!
   end
+  
+  #Turn on Java integration from javascript (probably a bad idea)
+  Rhino::Context.open(:java => true) do |context|
+    context.eval("java.lang.System.exit()") #it's dangerous!
+  end
+  
 == REQUIREMENTS:
 
 * JRuby >= 1.3.0

data/lib/rhino.rb

@@ -3,10 +3,12 @@ $:.unshift(File.dirname(__FILE__)) unless
 
 
 module Rhino
-  VERSION = '1.72.3'
+  VERSION = '1.72.4'
   require 'rhino/java'
   require 'rhino/context'
   require 'rhino/wormhole'
-  require 'rhino/native_object'
   require 'rhino/ruby_object'
+  require 'rhino/ruby_function'
+  require 'rhino/native_object'
+  require 'rhino/native_function'
 end

data/lib/rhino/context.rb

@@ -1,10 +1,6 @@
 module Rhino
-  def function(&impl)
-    Function.new &impl
-  end
-  
-  class Context
-    
+
+  class Context    
     attr_reader :scope
 
     class << self
@@ -50,22 +46,7 @@ module Rhino
     end
         
   end
-    
-  class Function < J::BaseFunction
-    def initialize(callable = nil, &block)
-      super()
-      @block = callable || block
-    end
-    
-    def call(cxt, scope, this, args)
-      @block.call(*(args.map {|a| To.ruby(a)}))
-    end
-    
-    def to_json(*args)
-      '"[Native Function]"'
-    end
-  end
-  
+      
   class ContextFactory < J::ContextFactory
     
     def observeInstructionCount(cxt, count)

data/lib/rhino/native_function.rb

@@ -0,0 +1,14 @@
+
+module Rhino
+  class NativeFunction < NativeObject    
+    def call(*args)
+      begin        
+        cxt = J::Context.enter()
+        scope = @j.getParentScope() || cxt.initStandardObjects()
+        @j.call(cxt, scope, scope, args.map {|o| To.javascript(o)})
+      ensure
+        J::Context.exit()
+      end
+    end
+  end
+end

data/lib/rhino/ruby_function.rb

@@ -0,0 +1,14 @@
+
+module Rhino
+  class RubyFunction < J::BaseFunction
+    
+    def initialize(callable)
+      super()
+      @callable = callable
+    end
+    
+    def call(cxt, scope, this, args)
+      To.javascript @callable.call(*args.map {|a| To.ruby(a)})
+    end
+  end
+end

data/lib/rhino/ruby_object.rb

@@ -17,13 +17,7 @@ module Rhino
     end
     
     def getPrototype()
-      @prototype ||= J::NativeObject.new.tap do |p|
-        p.put("toString", p, Function.new {to_s})
-        for name in @ruby.public_methods(false).reject {|m| m == 'initialize'}
-          method = @ruby.method(name)                    
-          p.put(name.gsub(/_(\w)/) {$1.upcase}, p, Function.new(method) {})
-        end
-      end
+      Prototype::Generic
     end
     
     def to_s
@@ -31,5 +25,27 @@ module Rhino
     end
     
     alias_method :prototype, :getPrototype
+    
+    
+    class Prototype < J::ScriptableObject
+            
+      def get(name, start)
+        robject = To.ruby(start)
+        rb_name = name.gsub(/([a-z])([A-Z])/) {"#{$1}_#{$2.downcase}"}
+        if (robject.public_methods(false).include?(rb_name)) 
+          method = robject.method(rb_name)
+          RubyFunction.new(method)
+        else
+          super(name, start)
+        end
+      end
+      
+      def has(name, start)
+        rb_name = name.gsub(/([a-z])([A-Z])/) {"#{$1}_#{$2.downcase}"}
+        To.ruby(start).public_methods(false).respond_to?(rb_name) ? true : super(name,start)
+      end
+      
+      Generic = new                        
+    end
   end
 end

data/lib/rhino/wormhole.rb

@@ -7,6 +7,8 @@ module Rhino
       case object
       when *JS_UNDEF          then nil
       when J::Wrapper         then object.unwrap
+      when J::NativeArray     then array(object)
+      when J::Function        then NativeFunction.new(object)
       when J::Scriptable      then NativeObject.new(object)
       else  object
       end        
@@ -14,12 +16,20 @@ module Rhino
     
     def javascript(object)
       case object
-      when NativeObject then object.j
-      when J::Scriptable then object
+      when String,Numeric       then object
+      when TrueClass,FalseClass then object
+      when Array                then J::NativeArray.new(object.to_java)
+      when Proc,Method          then RubyFunction.new(object)
+      when NativeObject         then object.j      
+      when J::Scriptable        then object
       else RubyObject.new(object)
       end
     end
     
-    module_function :ruby, :javascript    
+    def array(native)
+      native.length.times.map {|i| native.get(i,native)}        
+    end
+    
+    module_function :ruby, :javascript, :array
   end
 end

data/spec/rhino/context_spec.rb

@@ -66,7 +66,7 @@ describe Rhino::Context do
   
   it "can call ruby functions from javascript" do
     Context.open do |cxt|
-      cxt["say"] = function {|word, times| word * times}
+      cxt["say"] = lambda {|word, times| word * times}
       cxt.eval("say('Hello',2)").should == "HelloHello"
     end
   end

data/spec/rhino/native_object_spec.rb

@@ -12,7 +12,7 @@ describe Rhino::NativeObject do
   
   it "wraps a native javascript object" do
     @o["foo"] = 'bar'
-    @j.get("foo", @j).unwrap.should == "bar"    
+    @j.get("foo", @j).should == "bar"    
     @j.put("blue",@j, "blam")
     @o["blue"].should == "blam"
   end

data/spec/rhino/ruby_object_spec.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Rhino::RubyObject do
+  
+  before(:each) do
+    @class = Class.new
+    @instance = @class.new
+  end
+  
+  it "can call public locally defined ruby methods" do
+    class_eval do
+      def voo
+        "doo"
+      end
+    end
+    eval("o.voo").should_not be_nil
+    eval("o.voo()").should == "doo"
+  end
+  
+  it "translates ruby naming conventions into javascript naming conventions, but you can still access them by their original names" do
+    class_eval do
+      def my_special_method
+        "hello"
+      end
+    end
+    eval("o.mySpecialMethod").should_not be_nil
+    eval("o.mySpecialMethod()").should == "hello"
+    eval("o.my_special_method").should_not be_nil
+    eval("o.my_special_method()").should == "hello"
+  end
+  
+  it "hides methods not defined directly on this instance's class" do
+    class_eval do
+      def bar
+      end
+    end
+    eval("o.to_s").should be_nil
+  end
+  
+  it "translated camel case properties are enumerated by default, but perl case are not"
+  
+  it "will see a method that appears after the wrapper was first created" do
+    Rhino::Context.open do |cxt|
+      cxt['o'] = @instance
+      class_eval do
+        def bar
+          "baz!"
+        end
+      end
+      cxt.eval("o.bar").should_not be_nil
+      cxt.eval("o.bar()").should == "baz!"
+    end
+  end
+  
+  it "allows you to specify which methods should be treated as properties"
+  
+  
+  def eval(str)
+    Rhino::Context.open do |cxt|
+      cxt['o'] = @instance
+      cxt.eval(str)
+    end
+  end
+  
+  def class_eval(&body)
+    @class.class_eval &body
+  end
+end

data/spec/rhino/wormhole_spec.rb

@@ -8,7 +8,7 @@ describe Rhino::To do
       To.ruby(J::Scriptable::NOT_FOUND).should be_nil
     end
   
-    it "wraps native javascript objects in a ruby NativeObject wrapper" do
+    it "converts javascript arrays to ruby arrays" do
       J::NativeObject.new.tap do |o|
         To.ruby(o).tap do |ruby_object|
           ruby_object.should respond_to(:j)
@@ -17,6 +17,33 @@ describe Rhino::To do
       end
     end
     
+    it "wraps native javascript arrays into a ruby NativeArray wrapper" do
+      J::NativeArray.new([1,2,4].to_java).tap do |a|
+        To.ruby(a).should == [1,2,4]
+      end
+    end
+    
+    it "wraps native javascript functions into a ruby NativeFunction wrapper" do
+      
+      c = Class.new(J::BaseFunction).class_eval do
+        self.tap do
+          def call(cxt, scope, this, args)
+            args.join(',')
+          end
+        end
+      end
+      
+      c.new.tap do |f|
+        To.ruby(f).tap do |o|
+          o.should_not be_nil
+          o.should be_kind_of(NativeObject)
+          o.should be_respond_to(:call)
+          o.call(1,2,3).should == "1,2,3"
+        end
+      end
+      
+    end
+    
     it "leaves native ruby objects alone" do
       Object.new.tap do |o|
         To.ruby(o).should be(o)
@@ -40,6 +67,15 @@ describe Rhino::To do
   end
   
   describe  "javascript translation" do
+    
+    it "passes primitives through to the js layer to let jruby and rhino do he thunking" do
+      to(1).should be(1)
+      to(2.5).should == 2.5
+      to("foo").should == "foo"
+      to(true).should be(true)
+      to(false).should be(false)      
+    end
+    
     it "unwraps wrapped ruby objects before passing them to the javascript runtime" do
       J::NativeObject.new.tap do |o|
         To.javascript(NativeObject.new(o)).should be(o)
@@ -51,6 +87,27 @@ describe Rhino::To do
         To.javascript(o).should be(o)
       end
     end
+    
+    it "converts ruby arrays into javascript arrays" do
+      To.javascript([1,2,3,4,5]).tap do |a|
+        a.should be_kind_of(J::NativeArray)
+        a.get(0,a).should be(1)
+        a.get(1,a).should be(2)
+        a.get(2,a).should be(3)
+        a.get(3,a).should be(4)
+      end
+    end
+    
+    it "converts procs and methods into native functions" do
+      to(lambda {|lhs,rhs| lhs * rhs}).tap do |f|
+        f.should be_kind_of(J::Function)
+        f.call(nil, nil, nil, [7,6]).should be(42)
+      end
+      to("foo,bar,baz".method(:split)).tap do |m|
+        m.should be_kind_of(J::Function)
+        To.ruby(m.call(nil, nil, nil, ',')).should == ['foo', 'bar', 'baz']
+      end
+    end
 
     it "creates a prototype for the object based on its class" do
       Class.new.tap do |c|
@@ -71,4 +128,8 @@ describe Rhino::To do
       end
     end    
   end
+  
+  def to(object)
+    To.javascript(object)
+  end
 end

data/therubyrhino.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{therubyrhino}
-  s.version = "1.72.3"
+  s.version = "1.72.4"
   s.platform = %q{jruby}
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.description = %q{Embed the Mozilla Rhino Javascript interpreter into Ruby}
   s.email = ["cowboyd@thefrontside.net"]
   s.extra_rdoc_files = ["History.txt", "Manifest.txt"]
-  s.files = ["History.txt", "Manifest.txt", "README.rdoc", "Rakefile", "lib/rhino.rb", "lib/rhino/context.rb", "lib/rhino/java.rb", "lib/rhino/native_object.rb", "lib/rhino/rhino-1.7R2.jar", "lib/rhino/ruby_object.rb", "lib/rhino/wormhole.rb", "push.sh", "script/console", "script/destroy", "script/generate", "spec/rhino/context_spec.rb", "spec/rhino/native_object_spec.rb", "spec/rhino/wormhole_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "tasks/jruby.rake", "tasks/rspec.rake", "therubyrhino.gemspec"]
+  s.files = ["History.txt", "Manifest.txt", "README.rdoc", "Rakefile", "lib/rhino.rb", "lib/rhino/context.rb", "lib/rhino/java.rb", "lib/rhino/native_function.rb", "lib/rhino/native_object.rb", "lib/rhino/rhino-1.7R2.jar", "lib/rhino/ruby_function.rb", "lib/rhino/ruby_object.rb", "lib/rhino/wormhole.rb", "script/console", "script/destroy", "script/generate", "spec/rhino/context_spec.rb", "spec/rhino/native_object_spec.rb", "spec/rhino/ruby_object_spec.rb", "spec/rhino/wormhole_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "tasks/jruby.rake", "tasks/rspec.rake", "therubyrhino.gemspec"]
   s.homepage = %q{http://github.com/cowboyd/therubyrhino}
   s.rdoc_options = ["--main", "README.rdoc"]
   s.require_paths = ["lib"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: therubyrhino
 version: !ruby/object:Gem::Version 
-  version: 1.72.3
+  version: 1.72.4
 platform: jruby
 authors: 
   - Charles Lowell
@@ -40,8 +40,10 @@ files:
   - lib/rhino.rb
   - lib/rhino/context.rb
   - lib/rhino/java.rb
+  - lib/rhino/native_function.rb
   - lib/rhino/native_object.rb
   - lib/rhino/rhino-1.7R2.jar
+  - lib/rhino/ruby_function.rb
   - lib/rhino/ruby_object.rb
   - lib/rhino/wormhole.rb
   - script/console
@@ -49,6 +51,7 @@ files:
   - script/generate
   - spec/rhino/context_spec.rb
   - spec/rhino/native_object_spec.rb
+  - spec/rhino/ruby_object_spec.rb
   - spec/rhino/wormhole_spec.rb
   - spec/spec.opts
   - spec/spec_helper.rb