therubyrhino 1.72.7

data/.gitignore

@@ -0,0 +1,5 @@
+.idea
+doc
+*.gem
+.rvmrc
+.bundle

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "spec/redjs"]
+	path = spec/redjs
+	url = git@github.com:cowboyd/redjs.git

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: .
+  specs:
+    therubyrhino (1.72.7)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rspec (1.3.0)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  rspec
+  therubyrhino!

data/History.txt

@@ -0,0 +1,43 @@
+=== 1.72.7
+* N major enhancements:
+* N minor enhancements:
+
+=== 1.72.6 2009-11-30
+* 2 major enhancements:
+  * evaluate an IO object such as a file or an socket input stream
+  * load javascript sources directly into the context with the file system
+
+=== 1.72.5 2009-11-12
+* 2 major enhancements:
+  * evaluate javascript with a ruby object as it's scope using Context#open(:with => object)
+  * add eval_js() method to Object to evaluate in the context of that object
+
+=== 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
+  * remove Context#init_standard_objects
+
+=== 1.72.2 2009-11-10
+* 1 major enhancement:
+  * ability to limit the instruction count for a context
+
+=== 1.72.1 2009-11-09
+* 4 major enhancements:
+  * easily manipulate javascript objects from ruby (NativeObject)
+  * make NativeObject Enumerable
+  * to_h and to_json for NativeObject
+  * embed ruby instances and call methods from javascript
+
+=== 1.72.0 2009-09-24
+
+* 2 major enhancements:
+  * evaluate javascript in jruby
+  * embed callable ruby objects in javascript

data/README.rdoc

@@ -0,0 +1,157 @@
+= therubyrhino
+
+* http://github.com/cowboyd/therubyrhino
+* irc://irc.freenode.net/therubyrhino
+
+== DESCRIPTION:
+
+Embed the Mozilla Rhino Javascript interpreter into Ruby
+
+== FEATURES/PROBLEMS:
+
+* Evaluate Javascript from with in Ruby
+* Embed your Ruby objects into the Javascript world
+
+== SYNOPSIS:
+
+1. Javascript goes into Ruby
+1. Ruby Objects goes into Javascript
+1. Our shark's in the Javascript!
+
+  require 'rhino'
+  
+# evaluate some simple javascript
+  eval_js "7 * 6" #=> 42
+
+# that's quick and dirty, but if you want more control over your
+# environment, use a Context:
+  Rhino::Context.open do |cxt|
+    cxt['foo'] = "bar"
+    cxt.eval('foo') # => "bar"
+  end
+
+# evaluate a ruby function from javascript
+  
+  Rhino::Context.open do |context|
+    context["say"] = lambda {|word, times| word * times}
+    context.eval("say("Hello", 3)") #=> HelloHelloHello
+  end
+  
+# embed a ruby object into your javascript environment
+
+  class MyMath
+    def plus(lhs, rhs)
+      lhs + rhs
+    end
+  end
+
+  Rhino::Context.open do |context|
+    context["math"] = MyMath.new
+    context.eval("math.plus(20,22)") #=> 42
+  end
+  
+# make a ruby object *be* your javascript environment
+  math = MyMath.new
+  Rhino::Context.open(:with => math) do |context|
+    context.eval("plus(20,22)") #=> 42
+  end
+  
+  #or the equivalent
+  
+  math.eval_js("plus(20,22)")
+
+# Configure your embedding setup
+
+  # 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
+
+  #limit the number of instructions that can be executed in order to prevent
+  #rogue scripts
+  Rhino::Context.open do |context|
+    context.instruction_limit = 100000
+    context.eval("while (true);") # => Error!
+  end
+
+==== Different ways of loading javascript source
+
+In addition to just evaluating strings, you can also use streams such as files.
+
+# evaluate bytes read from any File/IO object:
+  File.open("mysource.js") do |file|
+    eval_js file, "mysource.js"
+  end
+
+# or load it by filename
+  Rhino::Context.open do |context|
+    context.load("mysource.js")
+  end
+
+=== Safe by default
+
+The Ruby Rhino is designed to let you evaluate javascript as safely as possible unless you tell it to do something more
+dangerous. The default context is a hermetically sealed javascript environment with only the standard javascript objects
+and functions. Nothing from the ruby world is accessible at all.
+
+For ruby objects that you explicitly embed into javascript, only the +public+ methods *defined in their classes* are
+exposed by default. E.g.
+
+  class A
+    def a
+      "a"
+    end
+  end
+
+  class B < A
+    def b
+      "b"
+    end
+  end
+
+
+  Rhino::Context.open do |cxt|
+    cxt['a'] = A.new
+    cxt['b'] = B.new
+    cxt.eval("a.a()") # => 'a'
+    cxt.eval("b.b()") # => 'b'
+    cxt.eval("b.a()") # => 'TypeError: undefined property 'a' is not a function'
+  end
+  
+== REQUIREMENTS:
+
+* JRuby >= 1.3.0
+
+== INSTALL:
+
+* jgem install therubyrhino
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Charles Lowell
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+
+for file in Dir['tasks/*.rake']
+  load file
+end
+
+desc "remove all build artifacts"
+task :clean do
+  sh "rm -rf pkg/"
+end

data/lib/rhino/context.rb

@@ -0,0 +1,208 @@
+require 'stringio'
+
+module Rhino
+
+# ==Overview
+#  All Javascript must be executed in a context which represents the execution environment in
+#  which scripts will run. The environment consists of the standard javascript objects
+#  and functions like Object, String, Array, etc... as well as any objects or functions which 
+#  have been defined in it. e.g.
+#  
+#   Context.open do |cxt|
+#     cxt['num'] = 5
+#     cxt.eval('num + 5') #=> 10
+#   end
+# 
+# == Multiple Contexts.
+# The same object may appear in any number of contexts, but only one context may be executing javascript code 
+# in any given thread. If a new context is opened in a thread in which a context is already opened, the second
+# context will "mask" the old context e.g.
+#
+#   six = 6
+#   Context.open do |cxt|
+#     cxt['num'] = 5
+#     cxt.eval('num') # => 5     
+#     Context.open do |cxt|
+#       cxt['num'] = 10
+#       cxt.eval('num') # => 10
+#       cxt.eval('++num') # => 11
+#     end
+#     cxt.eval('num') # => 5
+#   end
+#
+# == Notes
+# While there are many similarities between Rhino::Context and Java::OrgMozillaJavascript::Context, they are not
+# the same thing and should not be confused.
+
+  class Context
+    attr_reader :scope
+
+    class << self
+
+      # initalize a new context with a fresh set of standard objects. All operations on the context
+      # should be performed in the block that is passed.
+      def open(options = {}, &block)
+        new(options).open(&block)
+      end
+      
+      def eval(javascript)
+        new.eval(javascript)
+      end
+      
+    end
+
+    # Create a new javascript environment for executing javascript and ruby code.
+    # * <tt>:sealed</tt> - if this is true, then the standard objects such as Object, Function, Array will not be able to be modified
+    # * <tt>:with</tt> - use this ruby object as the root scope for all javascript that is evaluated
+    # * <tt>:java</tt> - if true, java packages will be accessible from within javascript
+    def initialize(options = {}) #:nodoc:
+      ContextFactory.new.call do |native|
+        @native = native
+        @global = NativeObject.new(@native.initStandardObjects(nil, options[:sealed] == true))
+        if with = options[:with]
+          @scope = To.javascript(with)
+          @scope.setParentScope(@global.j)
+        else
+          @scope = @global
+        end
+        unless options[:java]
+          for package in ["Packages", "java", "javax", "org", "com", "edu", "net"]
+            @global.j.delete(package)
+          end
+        end
+      end
+    end
+
+    # Read a value from the global scope of this context
+    def [](k)
+      @scope[k]
+    end
+
+    # Set a value in the global scope of this context. This value will be visible to all the 
+    # javascript that is executed in this context.    
+    def []=(k, v)
+      @scope[k] = v
+    end
+
+    # Evaluate a string of javascript in this context:
+    # * <tt>source</tt> - the javascript source code to evaluate. This can be either a string or an IO object.
+    # * <tt>source_name</tt> - associated name for this source code. Mainly useful for backtraces.
+    # * <tt>line_number</tt> - associate this number with the first line of executing source. Mainly useful for backtraces
+    def eval(source, source_name = "<eval>", line_number = 1)
+      self.open do
+        begin
+          scope = To.javascript(@scope)
+          if IO === source || StringIO === source
+            result = @native.evaluateReader(scope, IOReader.new(source), source_name, line_number, nil)
+          else
+            result = @native.evaluateString(scope, source.to_s, source_name, line_number, nil)
+          end
+          To.ruby result
+        rescue J::RhinoException => e
+          raise Rhino::JavascriptError, e
+        end
+      end
+    end
+    
+    def evaluate(*args) # :nodoc:
+      self.eval(*args)
+    end
+
+    # Read the contents of <tt>filename</tt> and evaluate it as javascript. Returns the result of evaluating the
+    # javascript. e.g.
+    #
+    # Context.open do |cxt|
+    #   cxt.load("path/to/some/lib.js")
+    # end
+    #
+    def load(filename)
+      File.open(filename) do |file|
+        evaluate file, filename, 1
+      end
+    end
+
+    # Set the maximum number of instructions that this context will execute.
+    # If this instruction limit is exceeded, then a Rhino::RunawayScriptError
+    # will be raised
+    def instruction_limit=(limit)
+      @native.setInstructionObserverThreshold(limit);
+      @native.factory.instruction_limit = limit
+    end
+
+    # Set the optimization level that this context will use. This is sometimes necessary
+    # in Rhino, if the bytecode size of the compiled javascript exceeds the 64KB limit.
+    # By using the -1 optimization level, you tell Rhino to run in interpretative mode,
+    # taking a hit to performance but escaping the Java bytecode limit.
+    def optimization_level=(level)
+      @native.setOptimizationLevel(level)
+    end
+
+    # Enter this context for operations. Some methods such as eval() will
+    # fail unless this context is open
+    def open
+      begin
+        @native.factory.enterContext(@native)
+        yield self
+      ensure
+        J::Context.exit()
+      end if block_given?
+    end
+
+  end
+
+  class IOReader < Java::JavaIo::Reader #:nodoc:
+
+    def initialize(io)
+      @io = io
+    end
+
+    def read(charbuffer, offset, length)
+      begin
+        str = @io.read(length)
+        if str.nil?
+          return -1
+        else
+          jstring = Java::JavaLang::String.new(str)
+          for i in 0 .. jstring.length - 1
+            charbuffer[i + offset] = jstring.charAt(i)
+          end
+          return jstring.length
+        end
+      rescue StandardError => e
+        raise Java::JavaIo::IOException.new, "Failed reading from ruby IO object"
+      end
+    end
+  end
+
+  class ContextFactory < J::ContextFactory # :nodoc:
+
+    def observeInstructionCount(cxt, count)
+      raise RunawayScriptError, "script exceeded allowable instruction count" if count > @limit
+    end
+
+    def instruction_limit=(count)
+      @limit = count
+    end
+  end
+
+  class ContextError < StandardError # :nodoc:
+    
+  end
+
+  class JavascriptError < StandardError # :nodoc:
+    def initialize(native)
+      @native = native
+    end
+
+    def message
+      @native.cause.details
+    end
+
+    def javascript_backtrace
+      @native.getScriptStackTrace()
+    end
+  end
+
+  class RunawayScriptError < StandardError # :nodoc:
+  end
+end

data/lib/rhino/java.rb

@@ -0,0 +1,24 @@
+require 'java'
+require 'rhino/rhino-1.7R2.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

@@ -0,0 +1,23 @@
+
+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)
+      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/native_object.rb

@@ -0,0 +1,71 @@
+
+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

data/lib/rhino/object.rb

@@ -0,0 +1,8 @@
+
+class Object
+  def eval_js(source, options = {})
+    Rhino::Context.open(options.merge(:with => self)) do |cxt|
+      cxt.eval(source)
+    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

@@ -0,0 +1,65 @@
+
+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::Generic
+    end
+    
+    def getIds()
+      puts "getIds()"
+      require 'java'
+      @ruby.public_methods(false).map {|m| m.gsub(/(.)_(.)/) {::JavaLang::String.new("#{$1}#{$2.upcase}")}}.tap {|ids| puts "ids: #{ids.inspect}"}.to_java
+    end
+        
+    def to_s
+      "[Native #{@ruby.class.name}]"
+    end
+    
+    alias_method :prototype, :getPrototype
+    
+    
+    class Prototype < J::ScriptableObject
+            
+      def get(name, start)
+        robject = To.ruby(start)
+        if name == "toString" 
+          return RubyFunction.new(lambda { "[Ruby #{robject.class.name}]"})
+        end
+        rb_name = name.gsub(/([a-z])([A-Z])/) {"#{$1}_#{$2.downcase}"}
+        if (robject.public_methods(false).include?(rb_name)) 
+          method = robject.method(rb_name)
+          if method.arity == 0
+            To.javascript(method.call)
+          else
+            RubyFunction.new(method)
+          end
+        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/version.rb

@@ -0,0 +1,4 @@
+
+module Rhino
+  VERSION = "1.72.7"
+end

data/lib/rhino/wormhole.rb

@@ -0,0 +1,36 @@
+
+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::NativeArray           then array(object)
+      when J::Regexp::NativeRegExp  then object
+      when J::Function              then NativeFunction.new(object)
+      when J::Scriptable            then NativeObject.new(object)
+      else  object
+      end        
+    end
+    
+    def javascript(object)
+      case 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
+    
+    def array(native)
+      native.length.times.map {|i| ruby(native.get(i,native))}
+    end
+    
+    module_function :ruby, :javascript, :array
+  end
+end

data/lib/rhino.rb

@@ -0,0 +1,15 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+
+module Rhino
+  VERSION = '1.72.7'
+  require 'rhino/java'
+  require 'rhino/object'
+  require 'rhino/context'
+  require 'rhino/wormhole'
+  require 'rhino/ruby_object'
+  require 'rhino/ruby_function'
+  require 'rhino/native_object'
+  require 'rhino/native_function'
+end

data/spec/redjs_helper.rb

@@ -0,0 +1,5 @@
+
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include Rhino
+

data/spec/rhino/context_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include Rhino
+  
+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|
+        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.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(: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(:java => true) do |cxt|
+          cxt["Packages"].should_not be_nil
+      end
+    end    
+  end
+end

data/spec/rhino/wormhole_spec.rb

@@ -0,0 +1,135 @@
+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 "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)
+        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]
+      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)
+      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 "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        
+    end
+    
+    it "leaves native javascript objects alone" do
+      J::NativeObject.new.tap do |o|
+        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|
+        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
+  
+  def to(object)
+    To.javascript(object)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'rhino'

data/tasks/jruby.rake

@@ -0,0 +1,7 @@
+if RUBY_PLATFORM =~ /java/
+  require 'java'
+else
+  puts "Java RubyGem only! You are not running within jruby."
+  puts "Try: jruby -S rake #{ARGV.join(' ')}"
+  exit(1)
+end

data/tasks/rspec.rake

@@ -0,0 +1,13 @@
+begin
+  require 'spec'
+  require 'spec/rake/spectask'
+  desc "Run the specs under spec/models"
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_opts = ['--options', "spec/spec.opts"]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+rescue LoadError
+  desc "bundle install to run rspecs"
+  task :spec
+end
+

data/therubyrhino.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rhino/version"
+
+Gem::Specification.new do |s|
+  s.name = %q{therubyrhino}
+  s.version = Rhino::VERSION
+  s.authors = ["Charles Lowell"]
+  s.description = %q{Call javascript code and manipulate javascript objects from ruby. Call ruby code and manipulate ruby objects from javascript.}
+  s.email = %q{cowboyd@thefrontside.net}
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.files = `git ls-files`.split("\n")
+  s.homepage = %q{http://github.com/cowboyd/therubyrhino}
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{therubyrhino}
+  s.summary = %q{Embed the Rhino JavaScript interpreter into JRuby}
+
+  s.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: therubyrhino
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 1
+    - 72
+    - 7
+  version: 1.72.7
+platform: ruby
+authors: 
+  - Charles Lowell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-10 00:00:00 -06:00
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    version_requirements: &id001 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 0
+            version: "0"
+    requirement: *id001
+    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: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - README.rdoc
+files: 
+  - .gitignore
+  - .gitmodules
+  - Gemfile
+  - Gemfile.lock
+  - History.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/object.rb
+  - lib/rhino/rhino-1.7R2.jar
+  - lib/rhino/ruby_function.rb
+  - lib/rhino/ruby_object.rb
+  - lib/rhino/version.rb
+  - lib/rhino/wormhole.rb
+  - spec/redjs_helper.rb
+  - spec/rhino/context_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: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: therubyrhino
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Embed the Rhino JavaScript interpreter into JRuby
+test_files: []
+