therubyrhino 1.73.0 → 1.73.1

data/lib/rhino/ruby/access.rb

@@ -0,0 +1,8 @@
+module Rhino
+  module Ruby
+    
+    autoload :DefaultAccess, "rhino/ruby/default_access"
+    autoload :AttributeAccess, "rhino/ruby/attribute_access"
+    
+  end
+end

data/lib/rhino/ruby/attribute_access.rb

@@ -0,0 +1,55 @@
+module Rhino
+  module Ruby
+    module AttributeAccess
+      
+      def self.has(object, name, scope)
+        if object.respond_to?(name.to_s) || 
+           object.respond_to?("#{name}=") # might have a writer but no reader
+          return true
+        end
+        # try [](name) method :
+        if object.respond_to?(:'[]') && object.method(:'[]').arity == 1
+          return true if object[name]
+        end
+        yield
+      end
+      
+      def self.get(object, name, scope)
+        if object.respond_to?(name_s = name.to_s)
+          method = object.method(name_s)
+          if method.arity == 0 && # check if it is an attr_reader
+            ( object.respond_to?("#{name}=") || object.instance_variables.include?("@#{name}") )
+            begin
+              return Rhino.to_javascript(method.call, scope)
+            rescue => e
+              raise Rhino::Ruby.wrap_error(e)
+            end
+          else
+            return Function.wrap(method.unbind)
+          end
+        elsif object.respond_to?("#{name}=")
+          return nil # it does have the property but is non readable
+        end
+        # try [](name) method :
+        if object.respond_to?(:'[]') && object.method(:'[]').arity == 1
+          if value = object[name]
+            return Rhino.to_javascript(value, scope)
+          end
+        end
+        yield
+      end
+      
+      def self.put(object, name, value)
+        if object.respond_to?(set_name = "#{name}=")
+          return object.send(set_name, Rhino.to_ruby(value))
+        end
+        # try []=(name, value) method :
+        if object.respond_to?(:'[]=') && object.method(:'[]=').arity == 2
+          return object[name] = Rhino.to_ruby(value)
+        end
+        yield
+      end
+      
+    end
+  end
+end

data/lib/rhino/ruby/default_access.rb

@@ -0,0 +1,54 @@
+module Rhino
+  module Ruby
+    module DefaultAccess
+      
+      def self.has(object, name, scope)
+        if object.respond_to?(name.to_s) || 
+           object.respond_to?("#{name}=")
+          return true
+        end
+        # try [](name) method :
+        if object.respond_to?(:'[]') && object.method(:'[]').arity == 1
+          return true if object[name]
+        end
+        yield
+      end
+      
+      def self.get(object, name, scope)
+        if object.respond_to?(name_s = name.to_s)
+          method = object.method(name_s)
+          if method.arity == 0
+            begin
+              return Rhino.to_javascript(method.call, scope)
+            rescue => e
+              raise Rhino::Ruby.wrap_error(e)
+            end
+          else
+            return Function.wrap(method.unbind)
+          end
+        elsif object.respond_to?("#{name}=")
+          return nil
+        end
+        # try [](name) method :
+        if object.respond_to?(:'[]') && object.method(:'[]').arity == 1
+          if value = object[name]
+            return Rhino.to_javascript(value, scope)
+          end
+        end
+        yield
+      end
+      
+      def self.put(object, name, value)
+        if object.respond_to?(set_name = "#{name}=")
+          return object.send(set_name, Rhino.to_ruby(value))
+        end
+        # try []=(name, value) method :
+        if object.respond_to?(:'[]=') && object.method(:'[]=').arity == 2
+          return object[name] = Rhino.to_ruby(value)
+        end
+        yield
+      end
+      
+    end
+  end
+end

data/lib/rhino/version.rb

@@ -1,4 +1,4 @@
 
 module Rhino
-  VERSION = "1.73.0"
+  VERSION = "1.73.1"
 end

data/lib/rhino/wormhole.rb

@@ -1,81 +1,87 @@
 
 module Rhino
   module To
-    JS_UNDEF = [J::Scriptable::NOT_FOUND, J::Undefined]
 
-    module_function
-
-    def ruby(object)
+    def to_ruby(object)
       case object
-      when *JS_UNDEF                then nil
-      when J::Wrapper               then object.unwrap
-      when J::NativeArray           then array(object)
-      when J::NativeDate            then Time.at(object.getJSTimeValue() / 1000)
-      when J::Regexp::NativeRegExp  then object
-      when J::Function              then j2r(object) {|o| NativeFunction.new(o)}
-      when J::Scriptable            then j2r(object) {|o| NativeObject.new(o)}
-      else  object
+      when JS::Scriptable::NOT_FOUND, JS::Undefined then nil
+      when JS::Wrapper           then object.unwrap
+      when JS::NativeArray       then array_to_ruby(object)
+      when JS::NativeDate        then Time.at(object.getJSTimeValue / 1000)
+      else object
       end
     end
 
-    def javascript(object)
+    def to_javascript(object, scope = nil)
       case object
-      when String,Numeric       then object
-      when TrueClass,FalseClass then object
-      when Array                then J::NativeArray.new(object.to_java)
-      when Hash                 then ruby_hash_to_native(object)
-      when Proc,Method          then r2j(object, object.to_s) {|o| RubyFunction.new(o)}
-      when NativeObject         then object.j
-      when J::Scriptable        then object
-      else r2j(object) {|o| RubyObject.new(o)}
+      when NilClass              then object
+      when String, Numeric       then object
+      when TrueClass, FalseClass then object
+      when JS::Scriptable        then object
+      when Array                 then array_to_javascript(object, scope)
+      when Hash                  then hash_to_javascript(object, scope)
+      when Time                  then time_to_javascript(object, scope)
+      when Method, UnboundMethod then Ruby::Function.wrap(object, scope)
+      when Proc                  then Ruby::Function.wrap(object, scope)
+      when Class                 then Ruby::Constructor.wrap(object, scope)
+      else RubyObject.wrap(object, scope)
       end
     end
 
-    def array(native)
-      native.length.times.map {|i| ruby(native.get(i,native))}
+    def args_to_ruby(args)
+      args.map { |arg| to_ruby(arg) }
     end
-
-    def ruby_hash_to_native(ruby_object)
-      native_object = NativeObject.new
-
-      ruby_object.each_pair do |k, v|
-        native_object[k] = v
+    
+    def args_to_javascript(args, scope = nil)
+      args.map { |arg| to_javascript(arg, scope) }.to_java
+    end
+    
+    private
+    
+      def array_to_ruby(js_array)
+        js_array.length.times.map { |i| to_ruby( js_array.get(i, js_array) ) }
       end
 
-      native_object.j
-		end
-
-    @@j2r = {}
-		def j2r(value)
-		  key = value.object_id
-      if ref = @@j2r[key]
-        if peer = ref.get()
-          return peer
+      def array_to_javascript(rb_array, scope = nil)
+        if scope && context = JS::Context.getCurrentContext
+          context.newArray(scope, rb_array.to_java)
         else
-          @@j2r.delete(key)
-          return j2r(value) {|o| yield o}
-        end
-      else
-        yield(value).tap do |peer|
-          @@j2r[key] = java.lang.ref.WeakReference.new(peer)
+          JS::NativeArray.new(rb_array.to_java)
         end
       end
-    end
 
-    @@r2j = {}
-    def r2j(value, key = value.object_id)
-      if ref = @@r2j[key]
-        if peer = ref.get()
-          return peer
-        else
-          @@r2j.delete(key)
-          return r2j(value, key) {|o| yield o}
+      def hash_to_javascript(rb_hash, scope = nil)
+        js_object = 
+          if scope && context = JS::Context.getCurrentContext
+            context.newObject(scope)
+          else
+            JS::NativeObject.new
+          end
+        # JS::NativeObject implements Map put it's #put does :
+        # throw new UnsupportedOperationException(); thus no []=
+        rb_hash.each_pair do |key, val| 
+          js_val = to_javascript(val, scope)
+          JS::ScriptableObject.putProperty(js_object, key.to_s, js_val)
         end
-      else
-        yield(value).tap do |peer|
-          @@r2j[key] = java.lang.ref.WeakReference.new(peer)
+        js_object
+      end
+    
+      def time_to_javascript(time, scope = nil)
+        millis = time.to_f * 1000
+        if scope && context = JS::Context.getCurrentContext
+          JS::ScriptRuntime.newObject(context, scope, 'Date', [ millis ].to_java)
+        else
+          # the pure reflection way - god I love Java's private :
+          js_klass = JS::NativeObject.java_class
+          new = js_klass.getDeclaredConstructor
+          new.setAccessible(true)
+          js_date = new.newInstance
+          date = js_klass.getDeclaredField(:date)
+          date.setAccessible(true)
+          date.setDouble(js_date, millis)
+          js_date
         end
       end
-    end
+      
   end
 end

data/spec/rhino/access_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+describe Rhino::Ruby::AttributeAccess do
+  
+  before(:all) do
+    Rhino::Ruby::Scriptable.access = Rhino::Ruby::AttributeAccess
+  end
+  
+  after(:all) do
+    Rhino::Ruby::Scriptable.access = nil
+  end
+  
+  class Meh
+    
+    attr_reader :anAttr0
+    attr_accessor :the_attr_1
+    
+    def initialize
+      @anAttr0 = nil
+      @the_attr_1 = 'attr_1'
+      @an_attr_2 = 'attr_2'
+    end
+    
+    def theMethod0; @theMethod0; end
+    
+    def a_method1; 1; end
+    
+    def the_method_2; '2'; end
+    
+  end
+  
+  it "gets methods and instance variables" do
+    rb_object = Rhino::Ruby::Object.wrap Meh.new
+    
+    rb_object.get('anAttr0', nil).should be_nil
+    rb_object.get('the_attr_1', nil).should == 'attr_1'
+    rb_object.get('an_attr_2', nil).should be(Rhino::JS::Scriptable::NOT_FOUND) # no reader
+    
+    [ 'theMethod0', 'a_method1', 'the_method_2' ].each do |name|
+      rb_object.get(name, nil).should be_a(Rhino::Ruby::Function)
+    end
+    
+    rb_object.get('non-existent-method', nil).should be(Rhino::JS::Scriptable::NOT_FOUND)
+  end
+
+  it "has methods and instance variables" do
+    rb_object = Rhino::Ruby::Object.wrap Meh.new
+    
+    rb_object.has('anAttr0', nil).should be_true
+    rb_object.has('the_attr_1', nil).should be_true
+    rb_object.has('an_attr_2', nil).should be_false # no reader nor writer
+    
+    [ 'theMethod0', 'a_method1', 'the_method_2' ].each do |name|
+      rb_object.has(name, nil).should be_true
+    end
+    
+    rb_object.has('non-existent-method', nil).should be_false
+  end
+  
+  it "puts using attr writer" do
+    start = mock('start')
+    start.expects(:put).never
+    rb_object = Rhino::Ruby::Object.wrap Meh.new
+    
+    rb_object.put('the_attr_1', start, 42)
+    rb_object.the_attr_1.should == 42
+  end
+  
+end

data/spec/rhino/context_spec.rb

@@ -1,12 +1,10 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-include Rhino
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
 
 describe Rhino::Context do
 
   describe "Initalizing Standard Javascript Objects" do
     it "provides the standard objects without java integration by default" do
-      Context.open do |cxt|
+      Rhino::Context.open do |cxt|
         cxt["Object"].should_not be_nil
         cxt["Math"].should_not be_nil
         cxt["String"].should_not be_nil
@@ -19,7 +17,7 @@ describe Rhino::Context do
     end
 
     it "provides unsealed standard object by default" do
-      Context.open do |cxt|
+      Rhino::Context.open do |cxt|
         cxt.eval("Object.foop = 'blort'")
         cxt["Object"]['foop'].should == 'blort'
       end
@@ -27,15 +25,15 @@ describe Rhino::Context do
 
     it "allows you to scope the context to an object" do
       class MyScope
-        def foo; proc { 'bar' }; end
+        def foo(*args); args && 'bar'; end
       end
-      Context.open(:with => MyScope.new) do |ctx|
+      Rhino::Context.open(:with => MyScope.new) do |ctx|
         ctx.eval("foo()").should == 'bar'
       end
     end
 
     it "allows you to seal the standard objects so that they cannot be modified" do
-      Context.open(:sealed => true) do |cxt|
+      Rhino::Context.open(:sealed => true) do |cxt|
         lambda {
           cxt.eval("Object.foop = 'blort'")
         }.should raise_error(Rhino::JSError)
@@ -47,9 +45,25 @@ describe Rhino::Context do
     end
 
     it "allows java integration to be turned on when initializing standard objects" do
-      Context.open(:java => true) do |cxt|
-          cxt["Packages"].should_not be_nil
+      Rhino::Context.open(:java => true) do |cxt|
+        cxt["Packages"].should_not be_nil
       end
     end
   end
+
+  it "should get default interpreter version" do
+    context = Rhino::Context.new
+    
+    context.version.should == 0
+  end
+  
+  it "should set interpreter version" do
+    context = Rhino::Context.new
+    context.version = 1.6
+    context.version.should == 1.6
+    
+    context.version = '1.7'
+    context.version.should == 1.7
+  end
+  
 end

data/spec/rhino/deprecations_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+require 'stringio'
+
+describe 'deprecations' do
+  
+  stderr = $stderr
+  
+  before do
+    $stderr = StringIO.new
+  end
+  
+  after do
+    $stderr = stderr
+  end
+  
+  it "To ruby 42" do
+    Rhino::To.ruby(42).should == 42
+  end
+
+  it "To javascript 42" do
+    Rhino::To.javascript(42).should == 42
+  end
+
+  it "J constant still works" do
+    lambda { Rhino::J::Scriptable }.should_not raise_error
+  end
+  
+  it "NativeObject constant exists" do
+    lambda { Rhino::NativeObject }.should_not raise_error
+  end
+
+  it "NativeFunction constant exists" do
+    lambda { Rhino::NativeFunction }.should_not raise_error
+  end
+
+  it "JavascriptError returns JSError" do
+    lambda { Rhino::JavascriptError.should be(Rhino::JSError) }.should_not raise_error
+  end
+  
+end