therubyracer 0.4.7-x86-darwin-9

data/ext/v8/v8_str.h

@@ -0,0 +1,9 @@
+#ifndef _RUBY_V8_STR_
+#define _RUBY_V8_STR_
+
+#include "ruby.h" 
+
+VALUE v8_str_new(VALUE clazz, VALUE str);
+VALUE v8_str_to_s(VALUE self);
+
+#endif

data/ext/v8/v8_template.cpp

@@ -0,0 +1,53 @@
+#include <ruby.h>
+#include <v8.h>
+#include "v8_ref.h"
+#include "v8_func.h"
+#include "v8_template.h"
+#include "converters.h"
+#include "callbacks.h"
+
+using namespace v8;
+
+Local<ObjectTemplate> Racer_Create_V8_ObjectTemplate(VALUE value) {
+  Local<ObjectTemplate> tmpl = ObjectTemplate::New();
+  // tmpl->SetInternalFieldCount(2);
+  tmpl->SetNamedPropertyHandler(
+    RacerRubyNamedPropertyGetter,
+    RacerRubyNamedPropertySetter,
+    0, // RacerRubyNamedPropertyQuery,
+    0, // RacerRubyNamedPropertyDeleter,
+    RacerRubyNamedPropertyEnumerator,
+    External::Wrap((void *)value)
+  );
+  return tmpl;
+}
+
+
+ 
+VALUE v8_Template_Set(VALUE self, VALUE name, VALUE value) {
+  HandleScope handles;
+  Local<Template> tmpl = V8_Ref_Get<Template>(self);
+  Local<Data> data = V8_Ref_Get<Data>(value);
+  tmpl->Set(RSTRING(name)->ptr, data);
+  return Qnil;
+}
+
+VALUE v8_ObjectTemplate_New(VALUE clazz) {
+  HandleScope handles;
+  return V8_Ref_Create(clazz, ObjectTemplate::New());
+}
+
+VALUE v8_FunctionTemplate_New(int argc, VALUE *argv, VALUE self) {
+  VALUE code;
+  rb_scan_args(argc, argv, "00&", &code);
+  HandleScope handles;
+  Local<FunctionTemplate> t = FunctionTemplate::New(RacerRubyInvocationCallback, External::Wrap((void *)code));
+  return V8_Ref_Create(self,t,code);
+}
+
+VALUE v8_FunctionTemplate_GetFunction(VALUE self) {
+  HandleScope handles;
+  Local<FunctionTemplate> t = V8_Ref_Get<FunctionTemplate>(self);
+  return V8_Wrap_Function(t->GetFunction());
+}
+

data/ext/v8/v8_template.h

@@ -0,0 +1,13 @@
+#ifndef _RUBY_V8_TEMPLATE_
+#define _RUBY_V8_TEMPLATE_ 
+
+v8::Local<v8::ObjectTemplate> Racer_Create_V8_ObjectTemplate(VALUE object);
+
+VALUE v8_Template_Set(VALUE self, VALUE name, VALUE value);
+
+VALUE v8_ObjectTemplate_New(VALUE clazz);
+
+VALUE v8_FunctionTemplate_New(int argc, VALUE *argv, VALUE self);
+VALUE v8_FunctionTemplate_GetFunction(VALUE self);
+
+#endif

data/lib/v8.rb

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

data/lib/v8/context.rb

@@ -0,0 +1,87 @@
+require 'stringio'
+
+module V8  
+  class Context    
+    def initialize(opts = {})      
+      @native = C::Context.new(opts[:with])
+    end
+    
+    def open(&block)
+      if block_given?
+        unless @native == C::Context::GetCurrent()
+          @native.open do
+            block.call(self)
+          end
+        else
+          block.call(self)
+        end
+      end
+    end
+    
+    def eval(javascript, sourcename = '<eval>', line = 1)
+      if IO === javascript || StringIO === javascript
+        javascript = javascript.read()
+      end
+      @native.open do        
+        @native.eval(javascript).tap do |result|
+          raise JavascriptError.new(result) if result.kind_of?(C::Message)
+          return To.ruby(result)
+        end
+      end
+    end
+        
+    def evaluate(*args)
+      self.eval(*args)
+    end
+    
+    def load(filename)
+      File.open(filename) do |file|
+        evaluate file, filename, 1
+      end      
+    end
+    
+    def [](key)
+      open do
+        To.ruby(@native.Global().Get(key.to_s))
+      end
+    end
+    
+    def []=(key, value)
+      value.tap do 
+        open do
+          @native.Global().tap do |scope|
+            scope.Set(key.to_s, value)
+          end
+        end
+      end
+    end
+    
+    def self.open(opts = {}, &block)
+      new(opts).open(&block)
+    end
+    
+    def self.eval(source)
+      new.eval(source)
+    end
+    
+    def V8.eval(*args)
+      V8::Context.eval(*args)
+    end
+  end
+  
+  class ContextError < StandardError
+    def initialize(caller_name)
+      super("tried to call method '#{caller_name} without an open context")
+    end
+    def self.check_open(caller_name)
+      raise new(caller_name) unless C::Context::InContext()
+    end
+  end
+  class JavascriptError < StandardError
+    def initialize(v8_message)
+      super(v8_message.Get())
+    end
+  end
+  class RunawayScriptError < ContextError
+  end
+end

data/lib/v8/object.rb

@@ -0,0 +1,38 @@
+
+module V8
+  class Object
+    include Enumerable
+    
+    def initialize(native)
+      @native = native
+    end
+    
+    def [](key)
+      @native.context.open do
+        To.ruby(@native.Get(key.to_s))        
+      end
+    end
+    
+    def []=(key, value)
+      value.tap do
+        @native.context.open do
+          @native.Set(key.to_s, value)
+        end
+      end
+    end
+    
+    def each
+      for prop in @native.GetPropertyNames()
+        yield prop, self[prop]
+      end
+    end
+  end
+end
+
+class Object  
+  def eval_js(javascript)
+    V8::Context.open(:with => self) do |cxt|
+      cxt.eval(javascript)
+    end
+  end
+end

data/lib/v8/to.rb

@@ -0,0 +1,33 @@
+
+module V8
+  module To
+    class << self
+      def ruby(value)
+        case value
+        when V8::C::Object then V8::Object.new(value)
+        when V8::C::String then "Wonkers!"          
+        else
+          value
+        end
+      end
+      
+      def v8(value)
+        case value
+        when String then  C::String.new(value)
+        when Proc   then  C::FunctionTemplate.new(&value).GetFunction()
+        when Method then  C::FunctionTemplate.new(&value.to_proc).GetFunction()
+        else
+          value
+        end
+      end
+      
+      def camel_case(str)
+        str.to_s.gsub(/_(\w)/) {$1.upcase}
+      end
+      
+      def perl_case(str)
+        str.gsub(/([A-Z])([a-z])/) {"_#{$1.downcase}#{$2}"}.downcase
+      end
+    end
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -I #{File.dirname(__FILE__) + '/../lib'} -r v8"
+puts "Revving Up The Ruby Racer!"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/ext/cxt_spec.rb

@@ -0,0 +1,25 @@
+
+require "#{File.dirname(__FILE__)}/../spec_helper.rb"
+
+include V8
+
+describe C::Context do  
+  
+  it "should not have a current context if no context is open" do
+    C::Context::GetCurrent().should be_nil
+  end
+  
+  it "can determine if there is a current context" do
+    C::Context::InContext().should be(false)
+    C::Context.new.open do |cxt|
+      C::Context::InContext().should be(true)
+    end
+  end
+  
+  it "returns the currently open context" do
+    C::Context.new.open do |cxt|
+      cxt.should be_eql(C::Context::GetCurrent())
+      cxt.should == C::Context::GetCurrent()
+    end
+  end
+end

data/spec/ext/obj_spec.rb

@@ -0,0 +1,13 @@
+require "#{File.dirname(__FILE__)}/../spec_helper.rb"
+
+include V8
+
+describe C::Object do
+  it "has a reference to its calling context" do
+    C::Context.new.open do |cxt|
+      o = cxt.eval('new Object()');
+      o.context.should == cxt
+      o.context.should be_eql(cxt)
+    end
+  end
+end

data/spec/redjs/README.txt

@@ -0,0 +1,8 @@
+Rspecs for a Ruby interface to javascript.
+
+This is useful for different javascript interpreters wanting to present a unified interface to ruby.
+
+Currently used by 
+ The Ruby Rhino: http://github.com/cowboyd/therubyrhino
+ The Ruby Racer: http://github.com/cowboyd/therubyracer
+ 

data/spec/redjs/jsapi_spec.rb

@@ -0,0 +1,394 @@
+require "#{File.dirname(__FILE__)}/tap.rb"
+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
+  end
+end