therubyracer 0.5.0-x86-darwin-9 → 0.5.1-x86-darwin-9

data/History.txt

@@ -1,3 +1,7 @@
+=== 0.5.1 2010-02-17
+* 1 minor enhancement
+  * fix bug in 1.8.6 by creating Object#tap if it does not exist
+
 === 0.5.0 2010-02-17
 * 1 major enhancement
   * support for Linux 64 bit

data/Rakefile

@@ -9,7 +9,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
     gemspec.name = gemspec.rubyforge_project = "therubyracer"
-    gemspec.version = "0.5.0"
+    gemspec.version = "0.5.1"
     gemspec.summary = "Embed the V8 Javascript interpreter into Ruby"
     gemspec.description = "Call javascript code and manipulate javascript objects from ruby. Call ruby code and manipulate ruby objects from javascript."
     gemspec.email = "cowboyd@thefrontside.net"
@@ -34,6 +34,12 @@ rescue LoadError
   puts "Rake Compiler not available. Install it with: gem install rake-compiler"
 end
 
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
 desc "Build gem"
 task :gem => :build
 

data/lib/v8/tap.rb

@@ -0,0 +1,8 @@
+
+unless Object.method_defined?(:tap)
+  class Object
+    def tap
+      yield self
+    end
+  end
+end

data/lib/v8.rb

@@ -2,9 +2,10 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module V8
-  VERSION = '0.5.0'
+  VERSION = '0.5.1'
   require 'v8/v8' #native glue
   require 'v8/to'
   require 'v8/context'
   require 'v8/object'
+  require 'v8/tap'
 end

data/spec/redjs/jsapi_spec.rb

@@ -0,0 +1,405 @@
+
+require "#{File.dirname(__FILE__)}/../redjs_helper.rb"
+
+describe "Ruby Javascript API" do
+
+  describe "Basic Evaluation" do
+    it "can evaluate some javascript" do
+      Context.eval("5 + 3")
+    end
+  
+    it "can pass back null to ruby" do
+      Context.eval("null").should be_nil      
+    end
+  
+    it "can pass back undefined to ruby" do
+      Context.eval("this.undefined").should be_nil
+    end
+  
+    it "can pass the empty string back to ruby" do
+      Context.eval("''").should == ""
+    end
+  
+    it "can pass doubles back to ruby" do
+      Context.eval("2.5").should == 2.5
+    end
+  
+    it "can pass fixed numbers back to ruby" do
+      Context.eval("1").should == 1
+    end
+  
+    it "can pass boolean values back to ruby" do
+      Context.eval("true").should be(true)
+      Context.eval("false").should be(false)
+    end  
+  
+    it "treats nil and the empty string as the same thing when it comes to eval" do
+      Context.eval(nil).should == Context.eval('')
+    end
+  
+    it "can pass back strings to ruby" do
+      Context.open do |cxt|
+        cxt['foo'] = "Hello World"
+        cxt.eval("foo").should == "Hello World"
+      end
+    end
+
+    it "can pass back very long strings to ruby" do
+      lorem = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis faucibus, diam vel pellentesque aliquet, nisl sapien molestie eros, vitae vehicula libero massa vel neque. Phasellus tempor pharetra ipsum vel venenatis. Quisque vitae nisl vitae quam mattis pellentesque et in sapien. Sed at lectus quis eros pharetra feugiat non ac neque. Vivamus lacus eros, feugiat at volutpat at, viverra id nisl. Vivamus ac dolor eleifend libero venenatis pharetra ut iaculis arcu. Donec neque nibh, vehicula non porta a, consectetur eu erat. Sed eleifend, metus vel euismod placerat, lectus lectus sollicitudin nisl, ac elementum sem quam nec dolor. In hac habitasse platea dictumst. Proin vitae suscipit orci. Suspendisse a ipsum vel lorem tempus scelerisque et vitae neque. Proin sodales, tellus sit amet consequat cursus, odio massa ultricies enim, eu fermentum velit lectus in lacus. Quisque eu porttitor diam. Nunc felis purus, facilisis non tristique ac, pulvinar nec nulla. Duis dolor risus, egestas nec tristique ac, ullamcorper cras amet."
+      Context.open do |cxt|
+        cxt.eval("'#{lorem}'").should == lorem
+      end
+    end
+  
+    it "can pass objects back to ruby" do
+      Context.open do |cxt|      
+        cxt.eval("({foo: 'bar', baz: 'bang', '5': 5, embedded: {badda: 'bing'}})").tap do |object|
+          object.should_not be_nil        
+          object['foo'].should == 'bar'
+          object['baz'].should == 'bang'
+          object['5'].should == 5
+          object['embedded'].tap do |embedded|  
+            embedded.should_not be_nil
+            embedded['badda'].should == 'bing'
+          end
+        end
+      end
+    end
+  
+    it "unwraps ruby objects returned by embedded ruby code to maintain referential integrity" do
+      Object.new.tap do |o|
+        Context.open do |cxt|
+          cxt['get'] = lambda {o}
+          cxt.eval('get()').should be(o)
+        end
+      end
+    end   
+  end
+
+  describe "Calling Ruby Code From Within Javascript" do
+
+    before(:each) do
+      @class = Class.new
+      @instance = @class.new
+    end
+
+    it "can embed a closure into a context and call it" do
+      Context.open do |cxt|
+        cxt["say"] = lambda {|word, times| word * times}
+        cxt.eval("say('Hello',2)").should == "HelloHello"
+      end
+    end
+  
+    it "can embed a ruby object into a context and call its methods" do
+      class_eval do
+        def say_hello(to)
+          "Hello #{to}!"
+        end
+      end
+      evaljs('o.say_hello("Gracie")').should == "Hello Gracie!"
+    end
+  
+    it "can call a bound ruby method" do
+      five = class_eval do
+        def initialize(lhs)
+          @lhs = lhs
+        end
+        def times(rhs)
+          @lhs * rhs
+        end
+        new(5)
+      end
+      Context.open do |cxt|
+        cxt['timesfive'] = five.method(:times)
+        cxt.eval('timesfive(3)').should == 15
+      end          
+    end
+    
+    it "reports ruby methods that do not exist as undefined" do
+      Context.open(:with => Object.new) do |cxt|
+        cxt.eval('this.foobar').should be_nil 
+      end
+    end
+  
+    it "can call public locally defined ruby methods" do
+      class_eval do
+        def voo(str)
+          "voo#{str}"
+        end
+      end
+      evaljs("o.voo('doo')").should == "voodoo"
+    end
+  
+    it "translates ruby naming conventions into javascript naming conventions, but you can still access them by their original names" do
+      class_eval do
+        def my_special_method(to)
+          "hello #{to}"
+        end
+      end
+      evaljs("o.mySpecialMethod('Frank')").should == "hello Frank"
+      evaljs("o.my_special_method('Jack')").should == "hello Jack"
+    end
+  
+    it "hides methods not defined directly on this instance's class" do
+      class_eval do
+        def bar
+        end
+      end
+      evaljs("o.to_s").should be_nil
+    end
+  
+    it "translated camel case properties are enumerated by default, but perl case are not" do
+      class_eval do
+        def foo_bar
+        end
+      
+        def baz_bang        
+        end      
+      end
+      require 'set'
+      evaljs(<<-EOJS).to_set.should == Set.new(["fooBar","bazBang"])
+      var names = [];
+      for (var p in o) {
+        names.push(p);
+      }
+      names;
+      EOJS
+    end
+  
+    it "will see a method that appears after the wrapper was first created" do
+      Context.open do |cxt|
+        cxt['o'] = @instance
+        class_eval do
+          def whiz(str)
+            "whiz#{str}!"
+          end
+        end
+        cxt.eval("o.whiz('bang')").should == "whizbang!"
+      end
+    end 
+  
+    it "treats ruby methods that have an arity of 0 as javascript properties by default" do
+      class_eval do
+        def property
+          "flan!"
+        end
+      end
+      evaljs('o.property').should == 'flan!'
+    end
+  
+    it "will call ruby accesssor function when setting a property from javascript" do
+      class_eval do
+        def dollars
+          @dollars
+        end
+        
+        def dollars=(amount)
+          @dollars = amount
+        end        
+      end
+      evaljs('o.dollars = 50')
+      @instance.dollars.should == 50
+    end
+    
+    it "will accept expando properties by default for properties on ruby object that are not implemented in ruby" do
+      evaljs('o.five = 5; o.five').should == 5
+    end
+    
+    it "it silently fails to replace properties which are defined on ruby objects but which are read-only" do
+      class_eval do
+        def bar
+          "baz"
+        end      
+      end
+      evaljs('o.bar = "bing"; o.bar').should == "baz"
+    end
+  
+    def evaljs(str)
+      Context.open do |cxt|
+        cxt['puts'] = lambda {|o| puts o.inspect}
+        cxt['o'] = @instance
+        cxt.eval(str)
+      end
+    end
+  
+    def class_eval(&body)
+      @class.class_eval &body
+    end
+  
+  end
+
+  describe "Setting up the Host Environment" do
+    it "can eval javascript with a given ruby object as the scope." do
+      scope = Class.new.class_eval do
+        def plus(lhs, rhs)
+          lhs + rhs
+        end
+      
+        def minus(lhs, rhs)
+          lhs - rhs
+        end
+      
+        new
+      end
+
+      Context.open(:with => scope) do |cxt|
+        cxt.eval("plus(1,2)").should == 3
+        cxt.eval("minus(10, 20)").should == -10
+        cxt.eval("this").should be(scope)
+      end    
+    end
+  
+    it "can directly embed ruby values into javascript" do
+      Context.open do |cxt|
+        cxt["bar"] = 9
+        cxt['foo'] = "bar"
+        cxt['num'] = 3.14
+        cxt['trU'] = true
+        cxt['falls'] = false
+        cxt.eval("bar + 10").should be(19)
+        cxt.eval('foo').should == "bar"
+        cxt.eval('num').should == 3.14
+        cxt.eval('trU').should be(true)
+        cxt.eval('falls').should be(false)      
+      end
+    end
+    
+    it "extends object to allow for the arbitrary execution of javascript with any object as the scope" do
+      Class.new.class_eval do
+      
+        def initialize
+          @lhs = 5
+        end
+      
+        def timesfive(rhs)
+          @lhs * rhs     
+        end
+      
+        new.eval_js("timesfive(6)").should == 30
+      end
+    end
+  
+    it "can limit the number of instructions that are executed in the context" do
+      pending "haven't figured out how to constrain resources in V8"
+      lambda {
+        Context.open do |cxt|
+          cxt.instruction_limit = 100 * 1000
+          timeout(1) do
+            cxt.eval('while (true);')
+          end
+        end
+      }.should raise_error(RunawayScriptError)
+    end    
+  end
+
+  describe "loading javascript source into the interpreter" do
+
+    it "can take an IO object in the eval method instead of a string" do
+      source = StringIO.new(<<-EOJS)
+  /*
+  * we want to have a fairly verbose function so that we can be assured tha
+  * we overflow the buffer size so that we see that the reader is chunking
+  * it's payload in at least several fragments.
+  *
+  * That's why we're wasting space here
+  */
+  function five() {
+    return 5
+  }
+  foo = 'bar'
+  five();
+      EOJS
+      Context.open do |cxt|
+        cxt.eval(source, "StringIO").should == 5
+        cxt['foo'].should == "bar"
+      end
+    end
+
+    it "can load a file into the runtime" do
+      mock(:JavascriptSourceFile).tap do |file|
+        File.should_receive(:open).with("path/to/mysource.js").and_yield(file)
+        Context.open do |cxt|
+          cxt.should_receive(:evaluate).with(file, "path/to/mysource.js", 1)
+          cxt.load("path/to/mysource.js")
+        end
+      end
+
+    end
+  end
+
+  describe "A Javascript Object Reflected Into Ruby" do
+  
+    before(:each) do
+      @o = Context.open do |cxt|
+        @cxt = cxt      
+        cxt.eval("o = new Object(); o")
+      end
+    end
+  
+    def evaljs(js)
+      @cxt.open do
+        @cxt.eval(js)
+      end
+    end
+  
+    it "can have its properties manipulated via ruby style [] hash access" do
+      @o["foo"] = 'bar'
+      evaljs('o.foo').should == "bar"
+      evaljs('o.blue = "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
+
+    it "traverses the prototype chain when hash accessing properties from the ruby object" do
+      Context.open do |cxt|
+        cxt.eval(<<EOJS)['bar'].should == "baz"
+function Foo() {}
+Foo.prototype.bar = 'baz'
+new Foo()
+EOJS
+      end
+    end
+
+    it "is enumenable" do
+      @cxt.open do
+        evaljs("o.foo = 'bar'; o.bang = 'baz'; o[5] = 'flip'")
+        @o.inject({}) {|i,p| k,v = p; i.tap {i[k] = v}}.should == {"foo" => 'bar', "bang" => 'baz', 5 => 'flip'}    
+      end
+    end  
+end
+
+  describe "Exception Handling" do
+    it "raises javascript exceptions as ruby exceptions" do
+      lambda {
+        Context.new.eval('foo')
+      }.should raise_error(JavascriptError)
+    end
+
+    it "can handle syntax errors" do
+    	lambda {
+    		Context.eval('does not compiles')
+    	}.should raise_error
+    end
+    
+    it "should track message state" do
+      begin        
+        Context.open do |cxt|
+          cxt.eval("var foo = 'bar';\nsyntax error!", "foo.js")
+        end
+      rescue JavascriptError => e
+        e.line_number.should == 2
+        e.source_name.should == "foo.js"
+      end
+    end
+  end
+end

data/therubyracer.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{therubyracer}
-  s.version = "0.5.0"
+  s.version = "0.5.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Charles Lowell", "Bill Robertson"]
-  s.date = %q{2010-02-16}
+  s.date = %q{2010-02-17}
   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.extensions = ["ext/v8/extconf.rb"]
@@ -639,6 +639,7 @@ Gem::Specification.new do |s|
      "lib/v8.rb",
      "lib/v8/context.rb",
      "lib/v8/object.rb",
+     "lib/v8/tap.rb",
      "lib/v8/to.rb",
      "script/console",
      "script/destroy",
@@ -661,6 +662,7 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/ext/cxt_spec.rb",
      "spec/ext/obj_spec.rb",
+     "spec/redjs/jsapi_spec.rb",
      "spec/redjs_helper.rb",
      "spec/spec_helper.rb",
      "spec/v8/to_spec.rb"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: therubyracer
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.5.1
 platform: x86-darwin-9
 authors: 
 - Charles Lowell
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-16 00:00:00 -06:00
+date: 2010-02-17 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -606,6 +606,7 @@ files:
 - ext/v8/upstream/2.0.6/src/ia32/jump-target-ia32.cc
 - ext/v8/upstream/scons/engine/SCons/Executor.py
 - ext/v8/upstream/2.0.6/src/arm/builtins-arm.cc
+- lib/v8/tap.rb
 - ext/v8/v8_template.cpp
 - spec/v8/to_spec.rb
 - ext/v8/upstream/scons/engine/SCons/Node/__init__.py
@@ -657,6 +658,7 @@ files:
 - ext/v8/upstream/2.0.6/src/ia32/debug-ia32.cc
 - ext/v8/upstream/2.0.6/src/disassembler.cc
 - ext/v8/upstream/2.0.6/src/objects-debug.cc
+- spec/redjs/jsapi_spec.rb
 - lib/v8/v8.bundle
 has_rdoc: true
 homepage: http://github.com/cowboyd/therubyracer
@@ -689,6 +691,7 @@ summary: Embed the V8 Javascript interpreter into Ruby
 test_files: 
 - spec/ext/cxt_spec.rb
 - spec/ext/obj_spec.rb
+- spec/redjs/jsapi_spec.rb
 - spec/redjs_helper.rb
 - spec/spec_helper.rb
 - spec/v8/to_spec.rb