therubyrhino 1.73.0 → 1.73.1

data/spec/rhino/wormhole_spec.rb

@@ -1,44 +1,38 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-include Rhino
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
 
 describe Rhino::To do
+  
   describe "ruby translation" do
+    
     it "converts javascript NOT_FOUND to ruby nil" do
-      To.ruby(J::Scriptable::NOT_FOUND).should be_nil
+      Rhino.to_ruby(Rhino::JS::Scriptable::NOT_FOUND).should be_nil
     end
   
-    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)
-          ruby_object.j.should be(o)
+    it "converts javascript undefined into nil" do
+      Rhino.to_ruby(Rhino::JS::Undefined.instance).should be_nil
+    end
+    
+    it "does return javascript object" do
+      Rhino::JS::NativeObject.new.tap do |js_obj|
+        Rhino.to_ruby(js_obj).tap do |rb_obj|
+          rb_obj.should be(js_obj)
         end
       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]
+      Rhino::JS::NativeArray.new([1,2,4].to_java).tap do |js_array|
+        Rhino.to_ruby(js_array).should == [1,2,4]
       end
     end
     
-    it "wraps native javascript functions into a ruby NativeFunction wrapper" do
+    it "does return javascript function" do
       
-      c = Class.new(J::BaseFunction).class_eval do
-        self.tap do
-          def call(cxt, scope, this, args)
-            args.join(',')
-          end
-        end
-      end
+      klass = Class.new(Rhino::JS::BaseFunction)
       
-      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"
+      klass.new.tap do |js_fn|
+        Rhino.to_ruby(js_fn).tap do |rb_fn|
+          rb_fn.should be(js_fn)
         end
       end
       
@@ -46,97 +40,124 @@ describe Rhino::To do
     
     it "leaves native ruby objects alone" do
       Object.new.tap do |o|
-        To.ruby(o).should be(o)
+        Rhino.to_ruby(o).should be(o)
       end
     end
     
     it "it unwraps wrapped java objects" do
-      Context.open do |cx|
+      Rhino::Context.open do |cx|
         scope = cx.scope
-        java.lang.String.new("Hello World").tap do |str|
-          J::NativeJavaObject.new(scope.j, str, str.getClass()).tap do |o|
-            To.ruby(o).should == "Hello World"
-          end
+        j_str = java.lang.String.new("Hello World")
+        Rhino::JS::NativeJavaObject.new(scope, j_str, j_str.getClass()).tap do |o|
+          Rhino.to_ruby(o).should == "Hello World"
         end
       end
     end
     
-    it "converts javascript undefined into nil" do
-      To.ruby(J::Undefined.instance).should be_nil
-    end
   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)
-      end        
+      Rhino.to_javascript(1).should be(1)
+      Rhino.to_javascript(2.5).should == 2.5
+      Rhino.to_javascript("foo").should == "foo"
+      Rhino.to_javascript(true).should be(true)
+      Rhino.to_javascript(false).should be(false)
+      Rhino.to_javascript(nil).should be_nil
     end
     
     it "leaves native javascript objects alone" do
-      J::NativeObject.new.tap do |o|
-        To.javascript(o).should be(o)
+      Rhino::JS::NativeObject.new.tap do |o|
+        Rhino.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)
+      Rhino.to_javascript([1,2,3,4,5]).tap do |a|
+        a.should be_kind_of(Rhino::JS::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)
+        a.prototype.should be_nil # this is how Rhino works !
       end
     end
-
+    
     it "converts ruby hashes into native objects" do
-      To.javascript({ :bare => true }).tap do |h|
-        h.should be_kind_of(J::NativeObject)
+      Rhino.to_javascript({ :bare => true }).tap do |h|
+        h.should be_kind_of(Rhino::JS::NativeObject)
         h.get("bare", h).should be(true)
+        h.prototype.should be_nil # this is how Rhino works !
       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']
+    describe "with a 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
-    end
 
-    it "creates a prototype for the object based on its class" do
-      Class.new.tap do |c|
-        c.class_eval do
-          def foo(one, two)
-            "1: #{one}, 2: #{two}"
-          end
+      after do
+        Rhino::JS::Context.exit
+      end
+      
+      it "converts ruby arrays into javascript arrays" do
+        Rhino.to_javascript([1,2,3,4,5], @scope).tap do |a|
+          a.should be_kind_of(Rhino::JS::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)
+          a.prototype.should_not be_nil
         end
+      end
 
-        To.javascript(c.new).tap do |o|
-          o.should be_kind_of(RubyObject)
-          o.prototype.tap do |p|
-            p.should_not be_nil
-            p.get("foo", p).should_not be_nil
-            p.get("toString", p).should_not be_nil
-          end
+      it "converts ruby hashes into native objects" do
+        Rhino.to_javascript({ :bare => true }, @scope).tap do |h|
+          h.should be_kind_of(Rhino::JS::NativeObject)
+          h.get("bare", h).should be(true)
+          h.prototype.should_not be_nil
         end
       end
-    end    
+      
+    end
+    
+    it "converts procs and methods into native functions" do
+      Rhino.to_javascript(lambda {|lhs,rhs| lhs * rhs}).tap do |f|
+        f.should be_kind_of(Rhino::JS::Function)
+        f.call(nil, nil, nil, [7,6]).should be(42)
+      end
+      
+      Rhino.to_javascript("foo,bar,baz".method(:split)).tap do |m|
+        m.should be_kind_of(Rhino::JS::Function)
+        Rhino.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
+#      klass = Class.new do
+#        def foo(one, two)
+#          "1: #{one}, 2: #{two}"
+#        end        
+#      end
+#
+#      Rhino.to_javascript(klass.new).tap do |o|
+#        o.should be_kind_of(Rhino::RubyObject)
+#        o.prototype.tap do |p|
+#          p.should_not be_nil
+#          p.get("foo", p).should_not be_nil
+#          p.get("toString", p).should_not be_nil
+#        end
+#      end
+#    end
+    
   end
   
-  def to(object)
-    To.javascript(object)
-  end
 end

data/spec/spec_helper.rb

@@ -1,2 +1,3 @@
 
+require 'mocha'
 require 'rhino'

data/therubyrhino.gemspec

@@ -17,5 +17,6 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"
+  s.add_development_dependency "mocha"
   s.add_development_dependency "jruby-openssl"
 end

metadata

@@ -2,7 +2,7 @@
 name: therubyrhino
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.73.0
+  version: 1.73.1
 platform: ruby
 authors: 
   - Charles Lowell
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-28 00:00:00 Z
+date: 2012-01-24 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: rake
@@ -35,7 +35,7 @@ dependencies:
     prerelease: false
     type: :development
   - !ruby/object:Gem::Dependency 
-    name: jruby-openssl
+    name: mocha
     version_requirements: &id003 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
@@ -45,6 +45,17 @@ dependencies:
     requirement: *id003
     prerelease: false
     type: :development
+  - !ruby/object:Gem::Dependency 
+    name: jruby-openssl
+    version_requirements: &id004 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    requirement: *id004
+    prerelease: false
+    type: :development
 description: Call javascript code and manipulate javascript objects from ruby. Call ruby code and manipulate ruby objects from javascript.
 email: cowboyd@thefrontside.net
 executables: []
@@ -62,17 +73,24 @@ files:
   - Rakefile
   - lib/rhino.rb
   - lib/rhino/context.rb
-  - lib/rhino/java.rb
-  - lib/rhino/native_function.rb
-  - lib/rhino/native_object.rb
+  - lib/rhino/deprecations.rb
+  - lib/rhino/error.rb
   - lib/rhino/object.rb
   - lib/rhino/rhino-1.7R3.jar
-  - lib/rhino/ruby_function.rb
-  - lib/rhino/ruby_object.rb
+  - lib/rhino/rhino_ext.rb
+  - lib/rhino/ruby.rb
+  - lib/rhino/ruby/access.rb
+  - lib/rhino/ruby/attribute_access.rb
+  - lib/rhino/ruby/default_access.rb
   - lib/rhino/version.rb
   - lib/rhino/wormhole.rb
   - spec/redjs_helper.rb
+  - spec/rhino/access_spec.rb
   - spec/rhino/context_spec.rb
+  - spec/rhino/deprecations_spec.rb
+  - spec/rhino/error_spec.rb
+  - spec/rhino/rhino_ext_spec.rb
+  - spec/rhino/ruby_spec.rb
   - spec/rhino/wormhole_spec.rb
   - spec/spec.opts
   - spec/spec_helper.rb

data/lib/rhino/java.rb

@@ -1,24 +0,0 @@
-require 'java'
-require 'rhino/rhino-1.7R3.jar'
-
-module Rhino
-  # This module contains all the native Rhino objects implemented in Java
-  # e.g. 
-  #   Rhino::J::NativeObject # => org.mozilla.javascript.NativeObject
-  module J
-    import "org.mozilla.javascript"
-
-    module Regexp
-      import "org.mozilla.javascript.regexp"
-    end
-  end
-end
-
-unless Object.method_defined?(:tap)
-  class Object #:nodoc:
-    def tap
-      yield self
-      self
-    end
-  end
-end

data/lib/rhino/native_function.rb

@@ -1,29 +0,0 @@
-
-module Rhino
-
-  # Wraps a function that has been defined in Javascript so that it can
-  # be referenced and called from javascript. e.g.
-  #
-  #   plus = Rhino::Context.open do |cx|
-  #     cx.eval('function(lhs, rhs) {return lhs + rhs}')
-  #   end
-  #   plus.call(5,4) # => 9
-  #
-  class NativeFunction < NativeObject
-    def call(*args)
-      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
-
-    def methodcall(this, *args)
-      cxt = J::Context.enter()
-      scope = @j.getParentScope() || cxt.initStandardObjects()
-      @j.call(cxt, scope, To.javascript(this), args.map {|o| To.javascript(o)})
-    ensure
-      J::Context.exit()
-    end
-  end
-end

data/lib/rhino/native_object.rb

@@ -1,71 +0,0 @@
-
-module Rhino
-  # Wraps a javascript object and makes its properties available from ruby.
-  class NativeObject
-    include Enumerable
-    
-    # The native java object wrapped by this NativeObject. This will generally
-    # be an instance of org.mozilla.javascript.Scriptable
-    attr_reader :j
-    
-    def initialize(j=nil) # :nodoc:
-      @j = j || J::NativeObject.new
-    end
-    
-    # get a property from this javascript object, where +k+ is a string or symbol
-    # corresponding to the property name
-    # e.g.
-    #   jsobject = Context.open do |cxt|
-    #      cxt.eval('({foo: 'bar',  'Take me to': 'a funky town'})')
-    #   end
-    # 
-    #   jsobject[:foo] # => 'bar'
-    #   jsobject['foo'] # => 'bar'
-    #   jsobject['Take me to'] # => 'a funky town'
-    def [](k)
-      To.ruby J::ScriptableObject.getProperty(@j,k.to_s)
-    end
-    
-    # set a property on the javascript object, where +k+ is a string or symbol corresponding
-    # to the property name, and +v+ is the value to set. e.g.
-    #
-    #   jsobject = eval_js "new Object()"
-    #   jsobject['foo'] = 'bar'
-    #   Context.open(:with => jsobject) do |cxt|
-    #     cxt.eval('foo') # => 'bar'
-    #   end
-
-    def []=(k,v)
-      J::ScriptableObject.putProperty(@j, k.to_s, To.javascript(v))
-    end
-    
-    # enumerate the key value pairs contained in this javascript object. e.g.
-    # 
-    #   eval_js("{foo: 'bar', baz: 'bang'}").each do |key,value|
-    #     puts "#{key} -> #{value} "
-    #   end
-    #
-    # outputs foo -> bar baz -> bang
-    def each
-      for id in @j.getAllIds() do
-        yield id,@j.get(id,@j)
-      end
-    end
-    
-    # Converts the native object to a hash. This isn't really a stretch since it's
-    # pretty much a hash in the first place.
-    def to_h
-      {}.tap do |h|
-        each do |k,v|
-          v = To.ruby(v)
-          h[k] = self.class === v ? v.to_h : v
-        end
-      end
-    end
-    
-    # Convert this javascript object into a json string.
-    def to_json(*args)
-      to_h.to_json(*args)
-    end
-  end
-end