therubyrhino 1.73.0 → 1.73.1

data/spec/rhino/error_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+describe Rhino::JSError do
+  
+  it "works as a StandardError with a message being passed" do
+    js_error = Rhino::JSError.new 'an error message'
+    lambda { js_error.to_s && js_error.inspect }.should_not raise_error
+    
+    js_error.cause.should be_nil
+    js_error.message.should == 'an error message'
+    js_error.javascript_backtrace.should be_nil
+  end
+  
+  it "might wrap a RhinoException wrapped in a NativeException like error" do
+    # JRuby's NativeException.new(rhino_e) does not work as it is
+    # intended to handle Java exceptions ... no new on the Ruby side
+    native_error_class = Class.new(RuntimeError) do
+      
+      def initialize(cause)
+        @cause = cause
+      end
+      
+      def cause
+        @cause
+      end
+      
+    end
+    
+    rhino_e = Rhino::JS::JavaScriptException.new("42".to_java)
+    js_error = Rhino::JSError.new native_error_class.new(rhino_e)
+    lambda { js_error.to_s && js_error.inspect }.should_not raise_error
+    
+    js_error.cause.should be(rhino_e)
+    js_error.message.should == '42'
+    js_error.javascript_backtrace.should_not be_nil
+  end
+  
+end

data/spec/rhino/rhino_ext_spec.rb

@@ -0,0 +1,234 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+shared_examples_for 'ScriptableObject', :shared => true do
+
+  it "acts like a hash" do
+    @object['foo'] = 'bar'
+    @object['foo'].should == 'bar'
+  end
+
+  it "might be converted to a hash with string keys" do
+    @object[42] = '42'
+    @object[:foo] = 'bar'
+    expect = @object.respond_to?(:to_h_properties) ? @object.to_h_properties : {}
+    @object.to_h.should == expect.merge('42' => '42', 'foo' => 'bar')
+  end
+  
+  it "yields properties with each" do
+    @object['1'] = 1
+    @object['3'] = 3
+    @object['2'] = 2
+    @object.each do |key, val|
+      case key
+        when '1' then val.should == 1
+        when '2' then val.should == 2
+        when '3' then val.should == 3
+      end
+    end
+  end
+  
+end
+
+describe "NativeObject" do
+  
+  before do
+    @object = Rhino::JS::NativeObject.new
+  end
+  
+  it_should_behave_like 'ScriptableObject'
+  
+end
+
+describe "FunctionObject" do
+      
+  before do
+    factory = Rhino::JS::ContextFactory.new
+    context, scope = nil, nil
+    factory.call do |ctx|
+      context = ctx
+      scope = context.initStandardObjects(nil, false)
+    end
+    factory.enterContext(context)
+    
+    to_string = java.lang.Object.new.getClass.getMethod(:toString)
+    @object = Rhino::JS::FunctionObject.new('to_string', to_string, scope)
+    @object.instance_eval do
+      def to_h_properties
+        { "arguments"=> nil, "prototype"=> {}, "name"=> "to_string", "arity"=> 0, "length"=> 0 }
+      end
+    end
+  end
+
+  after do
+    Rhino::JS::Context.exit
+  end
+  
+  it_should_behave_like 'ScriptableObject'
+  
+end
+
+describe "NativeObject (scoped)" do
+  
+  before do
+    factory = Rhino::JS::ContextFactory.new
+    context, scope = nil, nil
+    factory.call do |ctx|
+      context = ctx
+      scope = context.initStandardObjects(nil, false)
+    end
+    factory.enterContext(context)
+    
+    @object = context.newObject(scope)
+  end
+  
+  after do
+    Rhino::JS::Context.exit
+  end
+  
+  it_should_behave_like 'ScriptableObject'  
+  
+  it 'routes rhino methods' do
+    @object.prototype.should == {}
+    @object.getTypeOf.should == 'object'
+  end
+  
+  it 'raises on missing method' do
+    lambda { @object.aMissingMethod }.should raise_error(NoMethodError)
+  end
+  
+  it 'invokes JS function' do
+    @object.hasOwnProperty('foo').should == false
+    @object.toLocaleString.should == '[object Object]'
+  end
+
+  it 'puts JS property' do
+    @object.has('foo', @object).should == false
+    @object.foo = 'bar'
+    @object.has('foo', @object).should == true
+  end
+
+  it 'gets JS property' do
+    @object.put('foo', @object, 42)
+    @object.foo.should == 42
+  end
+  
+end
+
+describe "NativeFunction" do
+      
+  before do
+    factory = Rhino::JS::ContextFactory.new
+    @context, @scope = nil, nil
+    factory.call do |ctx|
+      @context = ctx
+      @scope = @context.initStandardObjects(nil, false)
+    end
+    factory.enterContext(@context)
+    
+    object = @context.newObject(@scope)
+    @object = Rhino::JS::ScriptableObject.getProperty(object, 'toString')
+    @object.instance_eval do
+      def to_h_properties
+        { "arguments"=> nil, "prototype"=> {}, "name"=> "toString", "arity"=> 0, "length"=> 0 }
+      end
+    end
+  end
+
+  after do
+    Rhino::JS::Context.exit
+  end
+  
+  it_should_behave_like 'ScriptableObject'
+  
+  it 'is callable' do
+    # NOTE: no implicit or bound this thus this === global
+    @object.call.should == '[object global]'
+  end
+  
+  it 'might be bind and called' do
+    @object.bind(@object).should be_a(Rhino::JS::Function)
+    @object.bind(@object).call.should == '[object Function]'
+  end
+  
+  it 'might be bind to a this context' do
+    @object.bind(@object).should be_a(Rhino::JS::Function)
+    @object.bind(@object).call.should == '[object Function]'
+  end
+
+  it 'might be bind to a this with args' do
+    array = @context.newArray(@scope, [].to_java)
+    push = Rhino::JS::ScriptableObject.getProperty(array, 'push')
+    
+    this = @context.newArray(@scope, [ 0 ].to_java)
+    push.bind(this, 1, 2).call(3, 4)
+    
+    this.length.should == 5
+    5.times { |i| this.get(i, this).should == i }
+  end
+  
+  it 'might be applied' do
+    an_obj = @context.newObject(@scope)
+    @object.apply(an_obj).should == '[object Object]'
+    
+    array = @context.newArray(@scope, [].to_java)
+    push = Rhino::JS::ScriptableObject.getProperty(array, 'splice')
+    
+    this = @context.newArray(@scope, [ 0, 3, 4 ].to_java)
+    push.apply(this, 1, 0, 1, 2)
+    
+    this.length.should == 5
+    5.times { |i| this.get(i, this).should == i }
+  end
+  
+  it 'might get method-called' do
+    @object.method(:apply).should == @object.method(:methodcall)
+  end
+  
+end
+
+describe "NativeFunction (constructor)" do
+      
+  before do
+    factory = Rhino::JS::ContextFactory.new
+    context, scope = nil, nil
+    factory.call do |ctx|
+      context = ctx
+      scope = context.initStandardObjects(nil, false)
+    end
+    factory.enterContext(context)
+    
+    @object = Rhino::JS::ScriptableObject.getProperty(context.newObject(scope), 'constructor')
+    @object.instance_eval do
+      def to_h_properties
+        {
+          "arguments"=>nil, "prototype"=>{}, "name"=>"Object", "arity"=>1, "length"=>1,
+          
+          "getPrototypeOf"=> { "arguments"=>nil, "prototype"=>{}, "name"=>"getPrototypeOf", "arity"=>1, "length"=>1}, 
+          "keys"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"keys", "arity"=>1, "length"=>1}, 
+          "getOwnPropertyNames"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"getOwnPropertyNames", "arity"=>1, "length"=>1}, 
+          "getOwnPropertyDescriptor"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"getOwnPropertyDescriptor", "arity"=>2, "length"=>2}, 
+          "defineProperty"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"defineProperty", "arity"=>3, "length"=>3}, 
+          "isExtensible"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"isExtensible", "arity"=>1, "length"=>1}, 
+          "preventExtensions"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"preventExtensions", "arity"=>1, "length"=>1}, 
+          "defineProperties"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"defineProperties", "arity"=>2, "length"=>2}, 
+          "create"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"create", "arity"=>2, "length"=>2}, 
+          "isSealed"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"isSealed", "arity"=>1, "length"=>1}, 
+          "isFrozen"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"isFrozen", "arity"=>1, "length"=>1}, 
+          "seal"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"seal", "arity"=>1, "length"=>1}, 
+          "freeze"=>{"arguments"=>nil, "prototype"=>{}, "name"=>"freeze", "arity"=>1, "length"=>1}
+        }
+      end
+    end
+  end
+
+  after do
+    Rhino::JS::Context.exit
+  end
+  
+  it_should_behave_like 'ScriptableObject'
+  
+  it 'is constructable' do
+    @object.new.should == {}
+  end
+  
+end

data/spec/rhino/ruby_spec.rb

@@ -0,0 +1,390 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+shared_examples_for Rhino::Ruby::Scriptable, :shared => true do
+
+  it "puts, gets and has a read/write attr" do
+    start = mock('start')
+    start.expects(:put).never
+    
+    @wrapper.unwrap.instance_eval do
+      def foo; @foo; end
+      def foo=(foo); @foo = foo; end
+    end
+    
+    @wrapper.put('foo', start, 42)
+    @wrapper.has('foo', nil).should == true
+    @wrapper.get('foo', nil).should == 42
+    @wrapper.unwrap.instance_variable_get(:'@foo').should == 42
+  end
+
+  it "puts, gets and has a write only attr" do
+    start = mock('start')
+    start.expects(:put).never
+    
+    @wrapper.unwrap.instance_eval do
+      def foo=(foo); @foo = foo; end
+    end
+    
+    @wrapper.put('foo', start, 42)
+    @wrapper.has('foo', nil).should == true
+    @wrapper.get('foo', nil).should be(nil)
+    @wrapper.unwrap.instance_variable_get(:'@foo').should == 42
+  end
+
+  it "puts, gets and has gets delegated if it acts like a Hash" do
+    start = mock('start')
+    start.expects(:put).never
+    
+    @wrapper.unwrap.instance_eval do
+      def [](name); (@hash ||= {})[name]; end
+      def []=(name, value); (@hash ||= {})[name] = value; end
+    end
+    
+    @wrapper.put('foo', start, 42)
+    @wrapper.has('foo', nil).should == true
+    @wrapper.get('foo', nil).should == 42
+    @wrapper.unwrap.instance_variable_get(:'@hash')['foo'].should == 42
+  end
+  
+  it "puts, gets and has non-existing property" do
+    start = mock('start')
+    start.expects(:put).once
+    
+    @wrapper.put('foo', start, 42)
+    @wrapper.has('foo', nil).should == false
+    @wrapper.get('foo', nil).should be(Rhino::JS::Scriptable::NOT_FOUND)
+  end
+  
+end
+
+describe Rhino::Ruby::Object do
+  
+  before do
+    @wrapper = Rhino::Ruby::Object.wrap @object = Object.new
+  end
+  
+  it "unwraps a ruby object" do
+    @wrapper.unwrap.should be(@object)
+  end
+  
+  it_should_behave_like Rhino::Ruby::Scriptable
+  
+  class UII < Object
+    
+    attr_reader :reader
+    attr_writer :writer
+
+    def method; nil; end
+    
+  end
+  
+  it "returns the ruby class name" do
+    rb_object = Rhino::Ruby::Object.wrap UII.new
+    rb_object.getClassName.should == UII.name
+  end
+  
+  it "reports being a ruby object on toString" do
+    rb_object = Rhino::Ruby::Object.wrap UII.new
+    rb_object.toString.should == '[ruby UII]'
+  end
+
+  it "puts a non-existent attr (delegates to start)" do
+    start = mock('start')
+    start.expects(:put).once
+    rb_object = Rhino::Ruby::Object.wrap UII.new
+    
+    rb_object.put('nonExistingAttr', start, 42)
+  end
+
+  it "getIds include ruby class methods" do
+    rb_object = Rhino::Ruby::Object.wrap UII.new
+    
+    rb_object.getIds.to_a.should include("reader")
+    rb_object.getIds.to_a.should include("method")
+    rb_object.getIds.to_a.should_not include('writer=')
+    rb_object.getIds.to_a.should include("writer")
+  end
+
+  it "getIds include ruby instance methods" do
+    rb_object = Rhino::Ruby::Object.wrap object = UII.new
+    object.instance_eval do
+      def foo; 'foo'; end
+    end
+    
+    rb_object.getIds.to_a.should include('foo')
+  end
+  
+  it "getIds include writers as attr names" do
+    rb_object = Rhino::Ruby::Object.wrap object = UII.new
+    
+    rb_object.getIds.to_a.should include('writer')
+    rb_object.getIds.to_a.should_not include('writer=')
+    
+    object.instance_eval do
+      def foo=(foo)
+        'foo'
+      end
+    end
+
+    rb_object.getIds.to_a.should include('foo')
+    rb_object.getIds.to_a.should_not include('foo=')
+  end
+  
+  describe 'with scope' do
+    
+    before do
+      factory = Rhino::JS::ContextFactory.new
+      context = nil
+      factory.call do |ctx|
+        context = ctx
+        @scope = context.initStandardObjects(nil, false)
+      end
+      factory.enterContext(context)
+    end
+
+    after do
+      Rhino::JS::Context.exit
+    end
+    
+    it "sets up correct prototype" do
+      rb_object = Rhino::Ruby::Object.wrap UII.new, @scope
+      rb_object.getPrototype.should_not be(nil)
+      rb_object.getPrototype.should be_a(Rhino::JS::NativeObject)
+    end
+    
+  end
+  
+  it "is aliased to RubyObject" do
+    (!! defined? Rhino::RubyObject).should == true
+    Rhino::RubyObject.should be(Rhino::Ruby::Object)
+  end
+  
+end
+
+describe Rhino::Ruby::Function do
+  
+  before do
+    @wrapper = Rhino::Ruby::Function.wrap @method = Object.new.method(:to_s)
+  end
+  
+  it "unwraps a ruby method" do
+    @wrapper.unwrap.should be(@method)
+  end
+  
+  it_should_behave_like Rhino::Ruby::Scriptable
+
+  it "is callable as a function" do
+    rb_function = Rhino::Ruby::Function.wrap method = 'foo'.method(:to_s)
+    context = nil; scope = nil; this = nil; args = nil
+    rb_function.call(context, scope, this, args).should == 'foo'
+  end
+
+  it "args get converted before delegating a ruby function call" do
+    klass = Class.new(Object) do
+      def foo(array)
+        array.all? { |elem| elem.is_a?(String) }
+      end
+    end
+    rb_function = Rhino::Ruby::Function.wrap method = klass.new.method(:foo)
+    context = nil; scope = nil; this = nil
+    args = [ '1'.to_java, java.lang.String.new('2') ].to_java
+    args = [ Rhino::JS::NativeArray.new(args) ].to_java
+    rb_function.call(context, scope, this, args).should be(true)
+  end
+
+  it "returned value gets converted to javascript" do
+    klass = Class.new(Object) do
+      def foo
+        [ 42 ]
+      end
+    end
+    rb_function = Rhino::Ruby::Function.wrap method = klass.new.method(:foo)
+    context = nil; scope = nil; this = nil; args = [].to_java
+    rb_function.call(context, scope, this, args).should be_a(Rhino::JS::NativeArray)
+  end
+
+  it "slices redundant args when delegating call" do
+    klass = Class.new(Object) do
+      def foo(a1)
+        a1
+      end
+    end
+    rb_function = Rhino::Ruby::Function.wrap method = klass.new.method(:foo)
+    context = nil; scope = nil; this = nil
+    
+    args = [ 1.to_java, 2.to_java, 3.to_java ].to_java; js_return = nil
+    lambda { js_return = rb_function.call(context, scope, this, args) }.should_not raise_error
+    js_return.should == 1
+  end
+  
+  it "fills missing args when delegating call" do
+    klass = Class.new(Object) do
+      def foo(a1, a2)
+        [ a1, a2 ]
+      end
+    end
+    rb_function = Rhino::Ruby::Function.wrap klass.new.method(:foo)
+    context = nil; scope = nil; this = nil
+    
+    args = [ 1.to_java ].to_java; js_return = nil
+    lambda { js_return = rb_function.call(context, scope, this, args) }.should_not raise_error
+    js_return.toArray.to_a.should == [ 1, nil ]
+
+    args = [ ].to_java; js_return = nil
+    lambda { js_return = rb_function.call(context, scope, this, args) }.should_not raise_error
+    js_return.toArray.to_a.should == [ nil, nil ]
+  end
+  
+  it "fills missing args when delegating call that ends with varargs" do
+    klass = Class.new(Object) do
+      def foo(a1, a2, *args)
+        [ a1, a2, args ].flatten
+      end
+    end
+    rb_function = Rhino::Ruby::Function.wrap klass.new.method(:foo)
+    context = nil; scope = nil; this = nil
+
+    args = [ ].to_java; js_return = nil
+    lambda { js_return = rb_function.call(context, scope, this, args) }.should_not raise_error
+    js_return.toArray.to_a.should == [ nil, nil ]
+    
+    args = [ 1.to_java ].to_java; js_return = nil
+    lambda { js_return = rb_function.call(context, scope, this, args) }.should_not raise_error
+    js_return.toArray.to_a.should == [ 1, nil ]
+
+    args = [ 1.to_java, 2.to_java ].to_java; js_return = nil
+    lambda { js_return = rb_function.call(context, scope, this, args) }.should_not raise_error
+    js_return.toArray.to_a.should == [ 1, 2 ]
+    
+    args = [ 1.to_java, 2.to_java, 3.to_java ].to_java; js_return = nil
+    lambda { js_return = rb_function.call(context, scope, this, args) }.should_not raise_error
+    js_return.toArray.to_a.should == [ 1, 2, 3 ]
+  end
+  
+  it "returns correct arity and length" do
+    klass = Class.new(Object) do
+      def foo(a1, a2)
+        a1 || a2
+      end
+    end
+    rb_function = Rhino::Ruby::Function.wrap klass.new.method(:foo)
+    rb_function.getArity.should == 2
+    rb_function.getLength.should == 2
+  end
+
+  it "reports arity and length of 0 for varargs only method" do
+    klass = Class.new(Object) do
+      def foo(*args); args; end
+    end
+    rb_function = Rhino::Ruby::Function.wrap klass.new.method(:foo)
+    rb_function.getArity.should == 0
+    rb_function.getLength.should == 0
+  end
+  
+  it "reports correct arity and length for ending varargs" do
+    klass = Class.new(Object) do
+      def foo(a1, *args); [ a1, args ]; end
+    end
+    rb_function = Rhino::Ruby::Function.wrap klass.new.method(:foo)
+    rb_function.getArity.should == 1
+    rb_function.getLength.should == 1
+  end
+  
+  describe 'with scope' do
+    
+    before do
+      factory = Rhino::JS::ContextFactory.new
+      context = nil
+      factory.call do |ctx|
+        context = ctx
+        @scope = context.initStandardObjects(nil, false)
+      end
+      factory.enterContext(context)
+    end
+
+    after do
+      Rhino::JS::Context.exit
+    end
+    
+    it "sets up correct prototype" do
+      rb_function = Rhino::Ruby::Function.wrap 'foo'.method(:concat), @scope
+      rb_function.getPrototype.should_not be(nil)
+      rb_function.getPrototype.should be_a(Rhino::JS::Function)
+    end
+    
+  end
+  
+  it "is aliased to RubyFunction" do
+    (!! defined? Rhino::RubyFunction).should == true
+    Rhino::RubyFunction.should be(Rhino::Ruby::Function)
+  end
+  
+end
+
+describe Rhino::Ruby::Constructor do
+  
+  before do
+    @wrapper = Rhino::Ruby::Constructor.wrap @class = Class.new(Object)
+  end
+  
+  it "unwraps a ruby method" do
+    @wrapper.unwrap.should be(@class)
+  end
+  
+  it_should_behave_like Rhino::Ruby::Scriptable
+
+  class Foo < Object
+  end
+  
+  it "is callable as a function" do
+    rb_new = Rhino::Ruby::Constructor.wrap Foo
+    context = nil; scope = nil; this = nil; args = nil
+    rb_new.call(context, scope, this, args).should be_a(Rhino::Ruby::Object)
+    rb_new.call(context, scope, this, args).unwrap.should be_a(Foo)
+  end
+  
+  it "returns correct arity and length" do
+    rb_new = Rhino::Ruby::Constructor.wrap Foo
+    rb_new.getArity.should == 0
+    rb_new.getLength.should == 0
+  end
+
+  it "reports arity and length of 0 for varargs" do
+    klass = Class.new do
+      def initialize(*args); args; end
+    end
+    rb_new = Rhino::Ruby::Constructor.wrap klass
+    rb_new.getArity.should == 0
+    rb_new.getLength.should == 0
+  end
+  
+  describe 'with scope' do
+    
+    before do
+      factory = Rhino::JS::ContextFactory.new
+      context = nil
+      factory.call do |ctx|
+        context = ctx
+        @scope = context.initStandardObjects(nil, false)
+      end
+      factory.enterContext(context)
+    end
+
+    after do
+      Rhino::JS::Context.exit
+    end
+    
+    it "has a function prototype" do
+      rb_function = Rhino::Ruby::Function.wrap 'foo'.method(:concat), @scope
+      rb_function.getPrototype.should_not be(nil)
+      rb_function.getPrototype.should be_a(Rhino::JS::Function)
+    end
+    
+  end
+  
+  it "is aliased to RubyConstructor" do
+    (!! defined? Rhino::RubyConstructor).should == true
+    Rhino::RubyConstructor.should be(Rhino::Ruby::Constructor)
+  end
+  
+end