therubyrhino 1.72.2-jruby → 1.72.3-jruby

data/History.txt

@@ -1,3 +1,10 @@
+=== 1.72.3 2009 11-11
+* 1 major enhancement
+  * greatly simplified interface to context by unifying context and scope
+  * remove Context#open_std()
+  * remove Context#standard
+  * remove Context#init_standard_objects
+
 === 1.72.2 2009-11-10
 * 1 major enhancement:
   * ability to limit the instruction count for a context

data/Manifest.txt

@@ -5,12 +5,18 @@ 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
 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

data/lib/rhino/context.rb

@@ -4,41 +4,41 @@ module Rhino
   end
   
   class Context
+    
+    attr_reader :scope
 
     class << self
-      def open
+      def open(options = {})
         ContextFactory.new.call do |native|
-          yield new(native)
-        end
-      end
-      
-      def open_std(options = {})
-        open do |cxt|
-          yield cxt, cxt.init_standard_objects(options)
+          yield new(native, options)
         end
       end
-                
+                      
       private :new
     end    
     
-    def initialize(native) #:nodoc:
+    def initialize(native, options) #:nodoc:
       @native = native
-    end
-        
-    def init_standard_objects(options = {})
-      NativeObject.new(@native.initStandardObjects(nil, options[:sealed] == true)).tap do |objects|
-        unless options[:java]
-          for package in ["Packages", "java", "org", "com"]
-            objects.j.delete(package)
-          end
+      @scope = NativeObject.new(@native.initStandardObjects(nil, options[:sealed] == true))
+      unless options[:java]
+        for package in ["Packages", "java", "org", "com"]
+          @scope.j.delete(package)
         end
-      end
+      end      
     end
     
-    def eval(str, scope = @native.initStandardObjects())
+    def [](k)
+      @scope[k]
+    end
+    
+    def []=(k,v)
+      @scope[k] = v
+    end
+                            
+    def eval(str)
       str = str.to_s
       begin
-        To.ruby @native.evaluateString(To.javascript(scope), str, "<eval>", 1, nil)
+        To.ruby @native.evaluateString(@scope.j, str, "<eval>", 1, nil)
       rescue J::RhinoException => e
         raise Rhino::RhinoError, e
       end
@@ -48,11 +48,7 @@ module Rhino
       @native.setInstructionObserverThreshold(limit);
       @native.factory.instruction_limit = limit
     end
-    
-    def standard
-      yield @native.initStandardObjects()
-    end
-    
+        
   end
     
   class Function < J::BaseFunction

data/lib/rhino/native_object.rb

@@ -0,0 +1,37 @@
+
+module Rhino
+  class NativeObject
+    include Enumerable
+    attr_reader :j
+    
+    def initialize(j)
+      @j = j
+    end
+    
+    def [](k)
+      To.ruby @j.get(k.to_s, @j)
+    end
+    
+    def []=(k,v)
+      @j.put(k.to_s,@j,To.javascript(v))
+    end
+    
+    def each
+      for id in @j.getAllIds() do
+        yield id,@j.get(id,@j)
+      end
+    end
+    
+    def to_h
+      {}.tap do |h|
+        each do |k,v|
+          h[k] = self.class === v ? v.to_h : v
+        end
+      end
+    end
+    
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
+end

data/lib/rhino/ruby_object.rb

@@ -0,0 +1,35 @@
+
+module Rhino
+  class RubyObject < J::ScriptableObject
+    include J::Wrapper
+    
+    def initialize(object)
+      super()
+      @ruby = object
+    end
+    
+    def unwrap
+      @ruby
+    end
+    
+    def getClassName()
+      @ruby.class.name
+    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
+    end
+    
+    def to_s
+      "[Native #{@ruby.class.name}]"
+    end
+    
+    alias_method :prototype, :getPrototype
+  end
+end

data/lib/rhino/wormhole.rb

@@ -0,0 +1,25 @@
+
+module Rhino
+  module To        
+    JS_UNDEF = [J::Scriptable::NOT_FOUND, J::Undefined]
+    
+    def ruby(object)
+      case object
+      when *JS_UNDEF          then nil
+      when J::Wrapper         then object.unwrap
+      when J::Scriptable      then NativeObject.new(object)
+      else  object
+      end        
+    end
+    
+    def javascript(object)
+      case object
+      when NativeObject then object.j
+      when J::Scriptable then object
+      else RubyObject.new(object)
+      end
+    end
+    
+    module_function :ruby, :javascript    
+  end
+end

data/lib/rhino.rb

@@ -3,7 +3,7 @@ $:.unshift(File.dirname(__FILE__)) unless
 
 
 module Rhino
-  VERSION = '1.72.2'
+  VERSION = '1.72.3'
   require 'rhino/java'
   require 'rhino/context'
   require 'rhino/wormhole'

data/spec/rhino/context_spec.rb

@@ -18,66 +18,47 @@ describe Rhino::Context do
   
   it "can embed primitive ruby object into javascript" do
     Context.open do |cxt|
-      cxt.init_standard_objects.tap do |scope|
-        scope["foo"] = "Hello World"
-        cxt.eval("foo", scope).unwrap.should == "Hello World"
-      end
+      cxt['foo'] = "Hello World"
+      cxt.eval("foo").should == "Hello World"
     end
   end  
   
   describe "Initalizing Standard Javascript Objects" do
     it "provides the standard objects without java integration by default" do
       Context.open do |cxt|
-        cxt.init_standard_objects.tap do |scope|
-          scope["Object"].should_not be_nil
-          scope["Math"].should_not be_nil
-          scope["String"].should_not be_nil
-          scope["Function"].should_not be_nil
-          scope["Packages"].should be_nil
-          scope["java"].should be_nil
-          scope["org"].should be_nil
-          scope["com"].should be_nil
-        end
+        cxt["Object"].should_not be_nil
+        cxt["Math"].should_not be_nil
+        cxt["String"].should_not be_nil
+        cxt["Function"].should_not be_nil
+        cxt["Packages"].should be_nil
+        cxt["java"].should be_nil
+        cxt["org"].should be_nil
+        cxt["com"].should be_nil
       end
     end
     
     it "provides unsealed standard object by default" do
       Context.open do |cxt|
-        cxt.init_standard_objects.tap do |scope|
-          cxt.eval("Object.foop = 'blort'", scope)
-          scope["Object"]['foop'].should == 'blort'
-        end
+        cxt.eval("Object.foop = 'blort'")
+        cxt["Object"]['foop'].should == 'blort'
       end
     end
     
     it "allows you to seal the standard objects so that they cannot be modified" do
-      Context.open do |cxt|
-        cxt.init_standard_objects(:sealed => true).tap do |scope|
-          lambda {
-            cxt.eval("Object.foop = 'blort'", scope)            
-          }.should raise_error(Rhino::RhinoError)
-          
-          lambda {
-            cxt.eval("Object.prototype.toString = function() {}", scope)            
-          }.should raise_error(Rhino::RhinoError)
-          
-        end
+      Context.open(:sealed => true) do |cxt|
+        lambda {
+          cxt.eval("Object.foop = 'blort'")            
+        }.should raise_error(Rhino::RhinoError)
+        
+        lambda {
+          cxt.eval("Object.prototype.toString = function() {}")            
+        }.should raise_error(Rhino::RhinoError)          
       end
     end
     
     it "allows java integration to be turned on when initializing standard objects" do
-      Context.open do |cxt|
-        cxt.init_standard_objects(:java => true).tap do |scope|
-          scope["Packages"].should_not be_nil
-        end
-      end
-    end
-    
-    it "provides a convenience method for initializing scopes" do
-      Context.open_std(:sealed => true, :java => true) do |cxt, scope|
-        scope["Object"].should_not be_nil
-        scope["java"].should_not be_nil
-        cxt.eval("new java.lang.String('foo')", scope).should == "foo"
+      Context.open(:java => true) do |cxt|
+          cxt["Packages"].should_not be_nil
       end
     end    
   end
@@ -85,16 +66,14 @@ describe Rhino::Context do
   
   it "can call ruby functions from javascript" do
     Context.open do |cxt|
-      cxt.standard do |scope|
-        scope.put("say", scope, function {|word, times| word * times})
-        cxt.eval("say('Hello',2)", scope).should == "HelloHello"
-      end
+      cxt["say"] = function {|word, times| word * times}
+      cxt.eval("say('Hello',2)").should == "HelloHello"
     end
   end
   
   it "can limit the number of instructions that are executed in the context" do
     lambda {
-      Context.open_std do |cxt, scope|
+      Context.open do |cxt|
         cxt.instruction_limit = 100 * 1000
         timeout(1) do
           cxt.eval('while (true);')

data/spec/rhino/native_object_spec.rb

@@ -0,0 +1,40 @@
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include Rhino
+
+describe Rhino::NativeObject do
+  
+  before(:each) do
+    @j = J::NativeObject.new
+    @o = NativeObject.new(@j)
+  end
+  
+  it "wraps a native javascript object" do
+    @o["foo"] = 'bar'
+    @j.get("foo", @j).unwrap.should == "bar"    
+    @j.put("blue",@j, "blam")
+    @o["blue"].should == "blam"
+  end
+  
+  it "doesn't matter if you use a symbol or a string to set a value" do
+    @o[:foo] = "bar"
+    @o['foo'].should == "bar"
+    @o['baz'] = "bang"
+    @o[:baz].should == "bang"
+  end
+  
+  it "returns nil when the value is null, null, or not defined" do
+    @o[:foo].should be_nil
+  end
+  
+  describe Enumerable do
+    it "enumerates according to native keys and values" do
+      @j.put("foo", @j, 'bar')
+      @j.put("bang", @j, 'baz')
+      @j.put(5, @j, 'flip')
+      @o.inject({}) {|i,p| k,v = p; i.tap {i[k] = v}}.should == {"foo" => 'bar', "bang" => 'baz', 5 => 'flip'}
+    end
+  end
+  
+end

data/spec/rhino/wormhole_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include Rhino
+
+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
+    end
+  
+    it "wraps native javascript objects in a ruby NativeObject wrapper" 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)
+        end
+      end
+    end
+    
+    it "leaves native ruby objects alone" do
+      Object.new.tap do |o|
+        To.ruby(o).should be(o)
+      end
+    end
+    
+    it "it unwraps wrapped java objects" do
+      Context.open do |cx|
+        scope = cx.scope
+        Java::JavaLang::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
+        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 "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        
+    end
+    
+    it "leaves native javascript objects alone" do
+      J::NativeObject.new.tap do |o|
+        To.javascript(o).should be(o)
+      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
+        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
+        end
+      end
+    end    
+  end
+end

data/therubyrhino.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{therubyrhino}
+  s.version = "1.72.3"
+  s.platform = %q{jruby}
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Charles Lowell"]
+  s.date = %q{2009-11-11}
+  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.homepage = %q{http://github.com/cowboyd/therubyrhino}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{therubyrhino}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Embed the Rhino Javascript engine into JRuby}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<hoe>, [">= 2.3.3"])
+    else
+      s.add_dependency(%q<hoe>, [">= 2.3.3"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 2.3.3"])
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: therubyrhino
 version: !ruby/object:Gem::Version 
-  version: 1.72.2
+  version: 1.72.3
 platform: jruby
 authors: 
   - Charles Lowell
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-10 00:00:00 -05:00
+date: 2009-11-11 00:00:00 -05:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -40,15 +40,21 @@ files:
   - 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
   - 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
 has_rdoc: true
 homepage: http://github.com/cowboyd/therubyrhino
 licenses: []