therubyrhino 1.73.2 → 1.73.3

data/Gemfile

@@ -1,3 +1,5 @@
 source :rubygems
 
-gemspec
+gemspec
+
+gem 'redjs', :git => 'git://github.com/cowboyd/redjs.git', :branch => "0.4", :group => :test

data/History.txt

@@ -1,3 +1,51 @@
+=== 1.73.3 2012-04-23
+RedJS 0.4 compatible
+
+* allow try-catch-ing ScriptError (besides StandardError) in JS
+* support for yield in JS property access via the [], []= methods
+* refactor access implementations to classes + introduce a shared base
+* missing explicit require 'rhino/version'
+* Ruby StandardError wrapping so they can be try-catched as JS "error" values
+* Rhino::Context.new is expected to yield when block passed
+
+=== 1.73.2 2012-04-11
+RedJS 0.2.1 compatible
+
+* improve JSError#message + add JSError#value to reflect throw JS value
+* correctly convert hashes nested within arrays to_javascript (#12)
+* full jruby --1.9 compatibility
+* Context.default_factory - no longer use a new factory per context
+* restrictable limits now require Contex.new(:restrictable => true)
+* added Context#timeout_limit (to complete instruction_limit)
+
+=== 1.73.1 2011-11-28
+NOTE: this is a "major" code update from 1.73.0 with some incompatibilities
+although keeping the bits backward compatible as much as possible :
+
+* add a JS:Function#apply to be used for calling functions from Ruby
+* add a JS:Function#bind usable with JS functions from Ruby
+* JS:Function#call should work similar to Method/Proc#call
+* customizable scriptable access module for resolving Ruby properties from JS
+  with TRR compatible Ruby::DefaultAccess and a custom Ruby::AttributeAccess
+* implement JavaScript function style argument filling/slicing (for Ruby)
+* delegate to hash like method []/[]= when wrapped subject supports them
+* introduce Ruby::Constructor JS wrapper for Ruby classes
+* hande int JavaScript property resolution
+* make sure Time -> Date conversion happens as well
+* deprecate JavascriptError use JSError instead with a javascript_backtrace fix
+* avoid using Rhino::To.javascript instead use Rhino.to_javascript etc.
+* NativeObject/NativeFunction got removed to avoid wrapping - instead Rhino's
+  "native" Java classes are customized using JRuby's Java integration
+* support for setting JS version via Context.version
+* Rhino::J gets deprecated it's now know as Rhino::JS
+
+=== 1.73.0 2011-11-28
+
+* upgrade to rhino-1.7R3
+* cache objects passed to context - same object passed twice ends up the same
+* properly map ruby Time objects to javascript Date
+* jruby --1.9 improvements
+
 === 1.72.8 2011-06-26
 * fix passing of options hash to ruby.
 

data/README.rdoc

@@ -5,18 +5,18 @@
 
 == DESCRIPTION:
 
-Embed the Mozilla Rhino Javascript interpreter into Ruby
+Embed the Mozilla Rhino JavaScript interpreter into Ruby
 
 == FEATURES/PROBLEMS:
 
-* Evaluate Javascript from with in Ruby
-* Embed your Ruby objects into the Javascript world
+* 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!
+1. JavaScript goes into Ruby
+2. Ruby Objects goes into JavaScript
+3. Our shark's in the JavaScript!
 
   require 'rhino'
   
@@ -30,14 +30,14 @@ Embed the Mozilla Rhino Javascript interpreter into Ruby
     cxt.eval('foo') # => "bar"
   end
 
-# evaluate a ruby function from javascript
+# evaluate a ruby function from JS
   
   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
+# embed a ruby object into your JS environment
 
   class MyMath
     def plus(lhs, rhs)
@@ -50,7 +50,7 @@ Embed the Mozilla Rhino Javascript interpreter into Ruby
     context.eval("math.plus(20, 22)") #=> 42
   end
   
-# make a ruby object *be* your javascript environment
+# make a ruby object *be* your JS environment
   math = MyMath.new
   Rhino::Context.open(:with => math) do |context|
     context.eval("plus(20, 22)") #=> 42
@@ -90,7 +90,7 @@ Embed the Mozilla Rhino Javascript interpreter into Ruby
     } # => Rhino::ScriptTimeoutError
   end
 
-==== Different ways of loading javascript source
+==== Different ways of loading JavaScript source
 
 In addition to just evaluating strings, you can also use streams such as files.
 
@@ -106,10 +106,10 @@ In addition to just evaluating strings, you can also use streams such as files.
 
 ==== Configurable Ruby access
 
-By default accessing Ruby objects from javascript is compatible with therubyracer:
+By default accessing Ruby objects from JavaScript is compatible with *therubyracer*:
 https://github.com/cowboyd/therubyracer/wiki/Accessing-Ruby-Objects-From-JavaScript
 
-Thus you end-up calling arbitrary no-arg methods as if they were javascript properties, 
+Thus you end-up calling arbitrary no-arg methods as if they were JavaScript properties, 
 since instance accessors (properties) and methods (functions) are indistinguishable:
 
   Rhino::Context.open do |context|
@@ -132,7 +132,7 @@ that attempts to mirror only attributes as properties as close as possible:
     end
   end
   
-  Rhino::Ruby::Scriptable.access = Rhino::Ruby::AttributeAccess
+  Rhino::Ruby::Scriptable.access = :attribute
   Rhino::Context.open do |context|
     context['Foo'] = Foo
     context.eval('var foo = new Foo()')
@@ -141,14 +141,19 @@ that attempts to mirror only attributes as properties as close as possible:
     context.eval('foo.check_bar()') # called like a function
   end
 
+If you happen to come up with your own access strategy, just set it directly :
+
+  Rhino::Ruby::Scriptable.access = FooApp::BarAccess.instance
+
 === 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.
+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 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.
+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
@@ -171,9 +176,15 @@ exposed by default. E.g.
     cxt.eval("b.a()") # => 'TypeError: undefined property 'a' is not a function'
   end
   
+== Rhino
+
+Rhino is currently maintained at https://github.com/mozilla/rhino
+Release downloads are available at http://www.mozilla.org/rhino/download.html
+Rhino is licensed under the MPL 1.1/GPL 2.0 license.
+
 == REQUIREMENTS:
 
-* JRuby >= 1.3.0
+* JRuby >= 1.5.6
 
 == INSTALL:
 

data/lib/rhino.rb

@@ -17,6 +17,7 @@ module Rhino
   
 end
 
+require 'rhino/version'
 require 'rhino/wormhole'
 Rhino.extend Rhino::To
 

data/lib/rhino/context.rb

@@ -82,6 +82,7 @@ module Rhino
           end
         end
       end
+      yield(self) if block_given?
     end
     
     # Returns the ContextFactory used while creating this context.
@@ -149,7 +150,7 @@ module Rhino
         @native.instruction_limit = limit
       else
         raise "setting an instruction_limit has no effect on this context, use " + 
-              "Context.open(:restricted => true) to gain a restrictable instance"
+              "Context.open(:restrictable => true) to gain a restrictable instance"
       end
     end
 
@@ -166,7 +167,7 @@ module Rhino
         @native.timeout_limit = limit
       else
         raise "setting an timeout_limit has no effect on this context, use " + 
-              "Context.open(:restricted => true) to gain a restrictable instance"
+              "Context.open(:restrictable => true) to gain a restrictable instance"
       end
     end
     

data/lib/rhino/ruby.rb

@@ -2,28 +2,52 @@
 module Rhino
   module Ruby
     
-    def self.wrap_error(e)
-      JS::WrappedException.new(org.jruby.exceptions.RaiseException.new(e))
-    end
-    
     # shared JS::Scriptable implementation
     module Scriptable
       
+      @@access = nil
+      def self.access=(access)
+        @@access = ( access.respond_to?(:get) && access.respond_to?(:put) ) ? access : 
+          begin
+            access = 
+              if access && ! access.is_a?(Class) # Scriptable.access = :attribute
+                name = access.to_s.chomp('_access')
+                name = name[0, 1].capitalize << name[1..-1]
+                name = :"#{name}Access"
+                if Ruby.const_defined?(name)
+                  Ruby.const_get(name) # e.g. Rhino::Ruby::AttributeAccess
+                else
+                  const_get(name) # e.g. Rhino::Ruby::Scriptable::FooAccess
+                end
+              else # nil, false, Class
+                access
+              end
+            access.is_a?(Class) ? access.new : access
+          end
+      end
+      
+      def self.access
+        @@access ||= Ruby::DefaultAccess.new
+      end
+      
       # override Object Scriptable#get(String name, Scriptable start);
       # override Object Scriptable#get(int index, Scriptable start);
       def get(name, start)
+        return nil if exclude?(name)
         access.get(unwrap, name, self) { super }
       end
 
       # override boolean Scriptable#has(String name, Scriptable start);
       # override boolean Scriptable#has(int index, Scriptable start);
       def has(name, start)
+        return nil if exclude?(name)
         access.has(unwrap, name, self) { super }
       end
 
       # override void Scriptable#put(String name, Scriptable start, Object value);
       # override void Scriptable#put(int index, Scriptable start, Object value);
       def put(name, start, value)
+        return nil if exclude?(name)
         access.put(unwrap, name, value) { super }
       end
       
@@ -31,7 +55,7 @@ module Rhino
       def getIds
         ids = []
         unwrap.public_methods(false).each do |name| 
-          name = name[0...-1] if name[-1, 1] == '=' # 'foo=' ... 'foo'
+          next unless name = convert(name)
           name = name.to_s.to_java # java.lang.String
           ids << name unless ids.include?(name)
         end
@@ -39,21 +63,28 @@ module Rhino
         ids.to_java
       end
       
-      @@access = nil
+      private
       
-      def self.access=(access)
-        @@access = access
+      def convert(name)
+        if exclude?(name)
+          nil
+        elsif name[-1, 1] == '='
+          name[0...-1]
+        else
+          name
+        end
       end
       
-      def self.access
-        @@access ||= Ruby::DefaultAccess
-      end
+      FETCH = '[]'.freeze
+      STORE = '[]='.freeze
       
-      private
+      def exclude?(name)
+        name == FETCH || name == STORE
+      end
       
-        def access
-          Scriptable.access
-        end
+      def access
+        Scriptable.access
+      end
       
     end
     
@@ -78,7 +109,7 @@ module Rhino
       def unwrap
         @ruby
       end
-
+      
       # abstract String Scriptable#getClassName();
       def getClassName
         @ruby.class.to_s # to_s handles 'nameless' classes as well
@@ -160,12 +191,12 @@ module Rhino
         begin
           callable = 
             if @callable.is_a?(UnboundMethod)
-              @callable.bind(Rhino.to_ruby(this))
+              @callable.bind(Rhino.to_ruby(this)) # might end up as TypeError
             else
               @callable
             end
           result = callable.call(*rb_args)
-        rescue => e
+        rescue StandardError, ScriptError => e
           raise Ruby.wrap_error(e) # thus `try { } catch (e)` works in JS
         end
         Rhino.to_javascript(result, scope)
@@ -216,6 +247,25 @@ module Rhino
       context ? context.cache(key, &block) : yield
     end
     
+    # "hack" for ruby errors so that they act as JS thrown objects
+    class Exception < JS::JavaScriptException
+      
+      def initialize(value)
+        super wrap_value(value)
+      end
+    
+      private
+      
+      def wrap_value(value)
+        value.is_a?(Object) ? value : Object.wrap(value)
+      end
+      
+    end
+    
+    def self.wrap_error(e)
+      Exception.new(e)
+    end
+    
   end
   
   RubyObject = Ruby::Object

data/lib/rhino/ruby/access.rb

@@ -4,5 +4,78 @@ module Rhino
     autoload :DefaultAccess, "rhino/ruby/default_access"
     autoload :AttributeAccess, "rhino/ruby/attribute_access"
     
+    class AccessBase
+      
+      def has(object, name, scope)
+        # try [](name) method :
+        if object.respond_to?(:'[]') && object.method(:'[]').arity == 1
+          unless internal?(name)
+            value = object.[](name) { return true }
+            return true unless value.nil?
+          end
+        end
+        yield
+      end
+      
+      def get(object, name, scope)
+        # try [](name) method :
+        if object.respond_to?(:'[]') && object.method(:'[]').arity == 1
+          value = begin
+            object[name]
+          rescue LocalJumpError
+            nil
+          end unless internal?(name)
+          return Rhino.to_javascript(value, scope) unless value.nil?
+        end
+        yield
+      end
+      
+      def put(object, name, value)
+        # try []=(name, value) method :
+        if object.respond_to?(:'[]=') && object.method(:'[]=').arity == 2
+          rb_value = Rhino.to_ruby(value)
+          begin
+            return object[name] = rb_value
+          rescue LocalJumpError
+          end unless internal?(name)
+        end
+        yield
+      end
+      
+      private
+      
+      UNDERSCORES = '__'.freeze
+      
+      def internal?(name) # e.g. '__iterator__', '__proto__'
+        name.is_a?(String) && 
+          name[0..1] == UNDERSCORES && name[-2..-1] == UNDERSCORES
+      end
+      
+    end
+    
+    module DeprecatedAccess
+      
+      def has(object, name, scope, &block)
+        Rhino.warn "[DEPRECATION] `#{self.name}.has` is deprecated, please sub-class #{self.name} instead."
+        instance.has(object, name, scope, &block)
+      end
+
+      def get(object, name, scope, &block)
+        Rhino.warn "[DEPRECATION] `#{self.name}.get` is deprecated, please sub-class #{self.name} instead."
+        instance.get(object, name, scope, &block)
+      end
+
+      def put(object, name, value, &block)
+        Rhino.warn "[DEPRECATION] `#{self.name}.put` is deprecated, please sub-class #{self.name} instead."
+        instance.put(object, name, value, &block)
+      end
+
+      private
+      def instance
+        @instance ||= self.new
+      end
+      
+    end
+    
   end
 end

data/lib/rhino/ruby/attribute_access.rb

@@ -1,57 +1,42 @@
 module Rhino
   module Ruby
-    module AttributeAccess
+    class AttributeAccess < AccessBase
       
-      def self.has(object, name, scope)
+      def 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
+        super
       end
       
-      def self.get(object, name, scope)
+      def get(object, name, scope)
         name_sym = name.to_s.to_sym
         if object.respond_to?(name_sym)
           method = object.method(name_sym)
           if method.arity == 0 && # check if it is an attr_reader
             ( object.respond_to?(:"#{name}=") || 
                 object.instance_variables.find { |var| var.to_sym == :"@#{name}" } )
-            begin
-              return Rhino.to_javascript(method.call, scope)
-            rescue => e
-              raise Rhino::Ruby.wrap_error(e)
-            end
+            return Rhino.to_javascript(method.call, scope)
           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
+        super
       end
       
-      def self.put(object, name, value)
+      def put(object, name, value)
         if object.respond_to?(set_name = :"#{name}=")
-          return object.send(set_name, Rhino.to_ruby(value))
+          rb_value = Rhino.to_ruby(value)
+          return object.send(set_name, rb_value)
         end
-        # try []=(name, value) method :
-        if object.respond_to?(:'[]=') && object.method(:'[]=').arity == 2
-          return object[name] = Rhino.to_ruby(value)
-        end
-        yield
+        super
       end
       
+      extend DeprecatedAccess # backward compatibility for a while
+      
     end
   end
 end

data/lib/rhino/ruby/default_access.rb

@@ -1,54 +1,38 @@
 module Rhino
   module Ruby
-    module DefaultAccess
+    class DefaultAccess < AccessBase
       
-      def self.has(object, name, scope)
+      def has(object, name, scope)
         if object.respond_to?(name.to_s) || 
-           object.respond_to?("#{name}=")
+           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
+        super
       end
       
-      def self.get(object, name, scope)
+      def 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
+            return Rhino.to_javascript(method.call, scope)
           else
             return Function.wrap(method.unbind)
           end
-        elsif object.respond_to?("#{name}=")
+        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
+        super
       end
       
-      def self.put(object, name, value)
-        if object.respond_to?(set_name = "#{name}=")
+      def 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
+        super
       end
       
+      extend DeprecatedAccess # backward compatibility for a while
+      
     end
   end
 end

data/lib/rhino/version.rb

@@ -1,4 +1,4 @@
 
 module Rhino
-  VERSION = "1.73.2"
+  VERSION = "1.73.3"
 end

data/spec/rhino/access_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path('../spec_helper', File.dirname(__FILE__))
 describe Rhino::Ruby::AttributeAccess do
   
   before(:all) do
-    Rhino::Ruby::Scriptable.access = Rhino::Ruby::AttributeAccess
+    Rhino::Ruby::Scriptable.access = Rhino::Ruby::AttributeAccess.new
   end
   
   after(:all) do
@@ -66,4 +66,54 @@ describe Rhino::Ruby::AttributeAccess do
     rb_object.the_attr_1.should == 42
   end
   
+  it "might set access as a symbol" do
+    prev_access = Rhino::Ruby::Scriptable.access
+    module FooAccess; end # backward compatibility
+    class Foo2Access; end
+    
+    begin
+      
+      Rhino::Ruby::Scriptable.access = nil
+      lambda {  
+        Rhino::Ruby::Scriptable.access = :attribute
+      }.should_not raise_error
+      Rhino::Ruby::Scriptable.access.should be_a Rhino::Ruby::AttributeAccess
+      
+      Rhino::Ruby::Scriptable.access = nil
+      lambda {  
+        Rhino::Ruby::Scriptable.access = :attribute_access
+      }.should_not raise_error
+      Rhino::Ruby::Scriptable.access.should be_a Rhino::Ruby::AttributeAccess
+
+      lambda {  
+        Rhino::Ruby::Scriptable.access = :foo
+      }.should_not raise_error
+      Rhino::Ruby::Scriptable.access.should == FooAccess
+
+      lambda {  
+        Rhino::Ruby::Scriptable.access = :foo2
+      }.should_not raise_error
+      Rhino::Ruby::Scriptable.access.should be_a Foo2Access
+      
+      lambda {  
+        Rhino::Ruby::Scriptable.access = :bar
+      }.should raise_error
+      
+    ensure
+      Rhino::Ruby::Scriptable.access = prev_access
+    end
+  end
+  
+  it "is backward compatibile with the 'module' way" do
+    Rhino::Ruby::AttributeAccess.respond_to?(:has).should be true
+    Rhino::Ruby::AttributeAccess.respond_to?(:get).should be true
+    Rhino::Ruby::AttributeAccess.respond_to?(:put).should be true
+    
+    Rhino::Ruby::Scriptable.access = Rhino::Ruby::AttributeAccess
+    
+    rb_object = Rhino::Ruby::Object.wrap Meh.new
+    rb_object.get('theMethod0', nil).should be_a(Rhino::Ruby::Function)
+    rb_object.has('non-existent-method', nil).should be false
+  end
+  
 end

data/spec/rhino/redjs_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+require 'redjs/load_specs'
+
+puts "will run JavaScript specs from RedJS #{RedJS::VERSION}"
+
+describe Rhino::Context do
+  
+  it_behaves_like 'RedJS::Context'
+
+  # TODO: remove if present in RedJS
+  it "catched ScriptError in JS" do
+    klass = Class.new do
+      def muu(*args)
+        args && raise(ScriptError.new('muu'))
+      end
+    end
+    
+    error = nil
+    lambda {
+      RedJS::Context.new do |cxt|
+        cxt['obj'] = klass.new
+        error = cxt.eval('var error; try { obj.muu(); error = null } catch(e) { error = e }')
+      end
+    }.should_not raise_error
+    error.should_not be nil
+    error.should be_a ScriptError
+  end
+  
+  it "keeps objects iterable when property accessor is provided" do
+    klass = Class.new do
+      def [](name); name; end
+      attr_accessor :foo
+      def bar=(bar); bar; end 
+    end
+
+    RedJS::Context.new do |cxt|
+      cxt['o'] = klass.new
+      cxt.eval('a = new Array(); for (var i in o) a.push(i);')
+      cxt['a'].length.should == 2 # [ 'foo', 'bar' ]
+    end
+  end
+  
+end

data/spec/rhino/ruby_spec.rb

@@ -388,3 +388,27 @@ describe Rhino::Ruby::Constructor do
   end
   
 end
+
+describe Rhino::Ruby::Exception do
+  
+  it 'outcomes as ruby errors in function calls' do
+    klass = Class.new(Object) do
+      def foo(arg)
+        raise TypeError, "don't foo me with #{arg}" unless arg.is_a?(String)
+      end
+    end
+    rb_function = Rhino::Ruby::Function.wrap klass.new.method(:foo)
+    context = nil; scope = nil; this = nil; args = [ 42.to_java ].to_java
+    begin
+      rb_function.call(context, scope, this, args)
+    rescue java.lang.Exception => e
+      e.should be_a(Rhino::Ruby::Exception)
+      e.getValue.should be_a(Rhino::Ruby::Object)
+      e.value.unwrap.should be_a(TypeError)
+      e.value.unwrap.message == "don't foo me with 42"
+    else
+      fail "#{Rhino::Ruby::Exception} expected to be raised"
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -1,3 +1,10 @@
 
-require 'mocha'
 require 'rhino'
+
+require 'mocha'
+require 'redjs'
+
+module RedJS
+  Context = Rhino::Context
+  Error = Rhino::JSError
+end

metadata

@@ -2,7 +2,7 @@
 name: therubyrhino
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.73.2
+  version: 1.73.3
 platform: ruby
 authors: 
   - Charles Lowell
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-11 00:00:00 Z
+date: 2012-04-23 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: rake
@@ -66,7 +66,6 @@ extra_rdoc_files:
   - README.rdoc
 files: 
   - .gitignore
-  - .gitmodules
   - .travis.yml
   - Gemfile
   - History.txt
@@ -85,15 +84,14 @@ files:
   - 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/redjs_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
   - therubyrhino.gemspec
 homepage: http://github.com/cowboyd/therubyrhino

data/.gitmodules

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

data/spec/redjs_helper.rb

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

data/spec/spec.opts

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