therubyracer 0.4.0

data/ext/v8/v8_standalone.h

@@ -0,0 +1,31 @@
+#ifndef __v8_standalone_h__
+#define __v8_standalone_h__
+
+#include "ruby.h"
+
+/**
+ * interned symbol for "call"
+ */
+extern VALUE ruby_call_symbol;
+
+/**
+ * id for respond_to?
+ */
+extern VALUE ruby_respond_to_ID;
+
+extern VALUE ruby_proc_class;
+extern VALUE ruby_method_class;
+
+
+/**
+ * Determine whether or not a value can respond to "call".
+ * i.e. is this Proc/Method object?
+ */
+bool is_callable(VALUE& object);
+
+/**
+ * Debugging aid.  Println debugging goo for VALUES.
+ */
+VALUE v8_what_is_this(VALUE self, VALUE object);
+
+#endif

data/ext/v8/v8_str.cpp

@@ -0,0 +1,17 @@
+
+#include "v8_str.h"
+#include "v8.h"
+#include "v8_ref.h"
+
+using namespace v8;
+
+VALUE v8_str_new(VALUE clazz, VALUE str) {
+  HandleScope handles;
+  return V8_Ref_Create(clazz, String::New(RSTRING(str)->ptr));
+}
+
+VALUE v8_str_to_s(VALUE self){
+  HandleScope handles;
+  Local<String> str = V8_Ref_Get<String>(self);
+  return rb_str_new2(*String::AsciiValue(str));
+}

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,55 @@
+#include <ruby.h>
+#include <v8.h>
+#include "v8_ref.h"
+#include "v8_func.h"
+#include "v8_template.h"
+#include "converters.h"
+
+using namespace v8;
+
+Handle<Value> RubyInvocationCallback(const Arguments& args) {
+  VALUE code = (VALUE)External::Unwrap(args.Data());
+  if (NIL_P(code)) {
+    return Null();
+  } else {      
+    VALUE* arguments = new VALUE[args.Length()];
+    for(int c=0;c<args.Length(); ++c) {
+      Handle<Value> val = args[c];
+      arguments[c] = V82RB(val);
+    }
+      
+    VALUE result = rb_funcall2(code, rb_intern("call"), args.Length(), arguments);
+    delete [] arguments;
+    
+    Handle<Value> convertedResult = RB2V8(result);
+    return convertedResult  ;
+  }
+}
+ 
+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(RubyInvocationCallback, 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,11 @@
+#ifndef _RUBY_V8_TEMPLATE_
+#define _RUBY_V8_TEMPLATE_ 
+
+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.0'
+  require 'v8/v8' #native glue
+  require 'v8/to'
+  require 'v8/context'
+  require 'v8/object'
+end

data/lib/v8/context.rb

@@ -0,0 +1,41 @@
+module V8
+  class Context    
+    def initialize
+      @native = C::Context.new
+    end
+    
+    def open(&block)
+      @native.open do
+        block.call(self).tap do |result|
+          raise JavascriptError.new(result) if result.kind_of?(C::Message)
+        end
+      end if block_given?
+    end
+    
+    def eval(javascript)
+      To.ruby @native.eval(javascript)
+    end
+        
+    def evaluate(*args)
+      self.eval(*args)
+    end
+    
+    def []=(key, value)
+      value.tap do 
+        @native.Global().tap do |scope|
+          scope.Set(key.to_s, value)
+        end
+      end
+    end
+    
+    def self.open(&block)
+      new.open(&block)
+    end    
+  end
+  
+  class ContextError < StandardError
+  end
+  class JavascriptError < StandardError
+    
+  end
+end

data/lib/v8/object.rb

@@ -0,0 +1,12 @@
+
+module V8
+  class Object
+    def initialize(native)
+      @native = native
+    end
+    
+    def [](key)
+      To.ruby(@native.Get(key))
+    end
+  end
+end

data/lib/v8/to.rb

@@ -0,0 +1,25 @@
+
+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
+    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/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,376 @@
+require 'rubygems'
+require "#{File.dirname(__FILE__)}/../redjs_helper.rb"
+
+describe "Ruby Javascript API" do
+
+  describe "Basic Evaluation" do
+    it "can evaluate some javascript" do
+      Context.open do |cxt|
+        cxt.eval("5 + 3").should == 8
+      end
+    end
+  
+    it "can pass back null to ruby" do
+      Context.open do |cxt|
+        cxt.eval("null").should be_nil      
+      end
+    end
+  
+    it "can pass back undefined to ruby" do
+      Context.open do |cxt|
+        cxt.eval("this.undefined").should be_nil
+      end
+    end
+  
+    it "can pass the empty string back to ruby" do
+      eval("''").should == ""
+    end
+  
+    it "can pass doubles back to ruby" do
+      eval("2.5").should == 2.5
+    end
+  
+    it "can pass fixed numbers back to ruby" do
+      eval("1").should == 1
+    end
+  
+    it "can pass boolean values back to ruby" do
+      eval("true").should be(true)
+      eval("false").should be(false)
+    end  
+  
+    it "treats nil and the empty string as the same thing when it comes to eval" do
+      Context.open do |cxt|
+        cxt.eval(nil).should == cxt.eval('')
+      end
+    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
+      pending
+      mock(:object).tap do |o|
+        Context.open do |cxt|
+          cxt['get'] = lambda {o}
+          cxt.eval('get()').should be(o)
+        end
+      end
+    end  
+
+    it "won't let you do some operations unless the context is open" do
+      pending "I'm not sure about this requirement"
+      Context.new.tap do |closed|
+        lambda {closed.eval('1')}.should raise_error(ContextError)    
+      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"] = C::FunctionTemplate.new {|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 "can call public locally defined ruby methods" do
+      class_eval do
+        def voo
+          "doo"
+        end
+      end
+      evaljs("o.voo").should_not be_nil
+      evaljs("o.voo()").should == "doo"
+    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
+          "hello"
+        end
+      end
+      evaljs("o.mySpecialMethod").should_not be_nil
+      evaljs("o.mySpecialMethod()").should == "hello"
+      evaljs("o.my_special_method").should_not be_nil
+      evaljs("o.my_special_method()").should == "hello"
+    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
+      pending "why the hell isn't the return value of getIds() being respected?!?"
+      evaljs(<<-EOJS).should == ["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 bar
+            "baz!"
+          end
+        end
+        cxt.eval("o.bar").should_not be_nil
+        cxt.eval("o.bar()").should == "baz!"
+      end
+    end 
+  
+    it "treats ruby methods that have an arity of 0 as javascript properties by default"
+  
+    it "will call ruby accesssor function when setting a property from javascript"  
+  
+    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
+      lambda {
+        Context.open do |cxt|
+          cxt.instruction_limit = 100 * 1000
+          timeout(1) do
+            cxt.eval('while (true);')
+          end
+        end
+      }.should raise_error(Rhino::RunawayScriptError)
+    end
+    
+    it "has a private constructor" do
+      lambda {
+        Context.new(nil)
+      }.should raise_error
+    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
+      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
+
+  describe "Exception Handling" do
+    it "raises javascript exceptions as ruby exceptions" do
+      lambda {
+        Context.open do |cxt|
+          cxt.eval('foo')
+        end
+      }.should raise_error(JavascriptError)
+    end
+  end
+end