therubyracer 0.6.3 → 0.7.0.pre

data/ext/v8/v8_value.h

@@ -0,0 +1,10 @@
+#ifndef _RR_V8_VALUE_
+#define _RR_V8_VALUE_ 
+
+#include "rr.h"
+
+extern VALUE rr_cV8_C_Value;
+extern VALUE rr_cV8_C_Empty;
+void rr_init_value();
+VALUE rr_wrap_v8_value(v8::Handle<v8::Value>& value);
+#endif

data/lib/v8.rb

@@ -2,11 +2,13 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module V8
-  VERSION = '0.6.3'
+  VERSION = '0.7.0.pre'
   require 'v8/v8' #native glue
   require 'v8/to'
   require 'v8/context'
   require 'v8/object'
+  require 'v8/array'
   require 'v8/function'
   require 'v8/tap'
+  require 'v8/access'
 end

data/lib/v8/access.rb

@@ -0,0 +1,60 @@
+require 'set'
+module V8
+  
+  class NamedPropertyGetter
+    def self.call(property, info)
+      name = To.rb(property)
+      obj = To.rb(info.This())
+      perl_name = To.perl_case(name)
+      methods = obj.public_methods(false).map(&:to_s)
+      method_name = if methods.include?(name)
+        name
+      elsif methods.include?(perl_name)
+        perl_name
+      end
+      if method_name
+        method = obj.method(method_name)
+        if method.arity == 0
+          Function.rubycall(method)
+        else
+          To.v8(method)
+        end
+      else
+        C::Empty
+      end
+    end
+  end
+
+  class NamedPropertySetter
+    def self.call(property, value, info)
+      obj = To.rb(info.This())
+      setter = To.rb(property) + "="
+      camel_name = To.camel_case(setter)
+      perl_name = To.perl_case(setter)
+      methods = obj.public_methods(false).map(&:to_s)
+      if methods.include?(perl_name)
+        obj.send(perl_name, To.rb(value))
+      elsif methods.include?(camel_name)
+        obj.send(camel_name, To.rb(value))
+      else
+         C::Empty
+      end
+    end
+  end
+  
+  class NamedPropertyEnumerator
+    def self.call(info)
+      obj = To.rb(info.This())
+      camel_methods = obj.public_methods(false).inject(Set.new) do |set, name|
+        set.tap do
+          set << To.camel_case(name)
+        end
+      end
+      names = V8::C::Array::New(camel_methods.length)
+      camel_methods.each_with_index do |name, i|
+        names.Set(i, C::String::New(name))
+      end
+      return names
+    end
+  end
+end

data/lib/v8/array.rb

@@ -0,0 +1,15 @@
+
+module V8
+  class Array < V8::Object
+    
+    def each
+      for i in 0..(@native.Length() - 1)
+        yield To.ruby(@native.Get(i))
+      end
+    end
+
+    def length
+      @native.Length()
+    end
+  end
+end

data/lib/v8/callbacks.rb

@@ -0,0 +1,88 @@
+
+module V8
+  module C
+    class MethodInfo
+      
+      attr_reader :perl_methods, :camel_methods
+      
+      def initialize(object)
+        @object = object
+        @methods = Set.new
+        for name in object.public_methods(false) do
+          @methods << name.to_s
+        end
+      end
+      
+      def find(name)
+        for format in [name, To.perl_case(name), To.camel_case(name)]
+          return @object.method(format) if @methods.include?(format)
+        end
+      end
+    end
+  end
+  
+  class NamedPropertyGetter
+    def self.call(property, info)
+      methods = MethodInfo(To.rb(info.This()))
+      
+      if method = methods.find(To.rb(property))
+        if method.arity == 0
+          To.v8(method.call)
+        else
+          To.v8(method)
+        end
+      else
+        C::Empty
+      end
+
+    #   method_name = if methods.include?(name)
+    #     name
+    #   elsif methods.include?(perl_name)
+    #     perl_name
+    #   end
+    #   if method_name
+    #     method = obj.method(method_name)
+    #     if method.arity == 0
+    #       To.v8(method.call())
+    #     else
+    #       To.v8(method)
+    #     end
+    #   else
+    #     C::Empty
+    #   end
+    # end
+  end
+
+  class NamedPropertySetter
+    def self.call(property, value, info)
+      obj = To.rb(info.This())
+      setter = To.rb(property) + "="
+      camel_name = To.camel_case(setter)
+      perl_name = To.perl_case(setter)
+      methods = obj.public_methods(false).map(&:to_s)
+      if methods.include?(perl_name)
+        obj.send(perl_name, To.rb(value))
+      elsif methods.include?(camel_name)
+        obj.send(camel_name, To.rb(value))
+      else
+         C::Empty
+      end
+    end
+  end
+  
+  class NamedPropertyEnumerator
+    def self.call(info)
+      obj = To.rb(info.This())
+      camel_methods = obj.public_methods(false).inject(Set.new) do |set, name|
+        set.tap do
+          set << To.camel_case(name)
+        end
+      end
+      names = V8::C::Array::New(camel_methods.length)
+      camel_methods.each_with_index do |name, i|
+        names.Set(i, C::String::New(name))
+      end
+      return names
+    end
+  end
+end

data/lib/v8/cli.rb

@@ -26,7 +26,7 @@ module V8
       end
       if options.version_info
         puts "The Ruby Racer #{V8::VERSION}"
-        puts "V8 Version 2.0.6"
+        puts "V8 Version 2.1.10"
         exit
       elsif options.selftest
         self.test        

data/lib/v8/context.rb

@@ -1,35 +1,39 @@
 require 'stringio'
 
-module V8  
+module V8
   class Context    
-    def initialize(opts = {})      
-      @native = C::Context.new(opts[:with])
+    attr_reader :native, :scope
+    def initialize(opts = {})
+      @native = C::Context::New(opts[:with])
+      @scope = V8::Object.new(@native.Global(), @native)
+      yield(self) if block_given?
     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)
+    def eval(javascript, filename = "<eval>", line = 1)
       if IO === javascript || StringIO === javascript
         javascript = javascript.read()
       end
-      @native.open do        
-        @native.eval(javascript, sourcename).tap do |result|
-          raise JavascriptError.new(result) if result.kind_of?(C::Message)
-          return To.ruby(result)
+      err = nil
+      value = nil
+      C::TryCatch.try do |try|
+        @native.enter do
+          script = C::Script::Compile(To.v8(javascript.to_s), To.v8(filename.to_s))
+          if try.HasCaught()
+            err = JavascriptError.new(try)
+          else
+            result = script.Run()
+            if try.HasCaught()
+              err = JavascriptError.new(try)
+            else
+              value = To.ruby(result)
+            end
+          end
         end
       end
+      raise err if err
+      return value
     end
-        
+            
     def evaluate(*args)
       self.eval(*args)
     end
@@ -41,25 +45,13 @@ module V8
     end
     
     def [](key)
-      open do
-        To.ruby(@native.Global().Get(key.to_s))
-      end
+      @scope[key]
     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)
+      @scope[key] = value
     end
-    
+
     def self.eval(source)
       new.eval(source)
     end
@@ -68,44 +60,41 @@ module V8
       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()}: #{v8_message.GetScriptResourceName()}:#{v8_message.GetLineNumber()}")
-      @native = v8_message
-    end
-
-    def source_name
-      @native.GetScriptResourceName()      
-    end
     
-    def source_line
-      @native.GetSourceLine()
-    end
+  class JavascriptError < StandardError
+    attr_reader :source_name, :source_line, :line_number, :javascript_stacktrace
     
-    def line_number
-      @native.GetLineNumber()
+    def initialize(try)
+      msg = try.Message()
+      @source_name = To.ruby(msg.GetScriptResourceName())
+      @source_line = To.ruby(msg.GetSourceLine())
+      @line_number = To.ruby(msg.GetLineNumber())
+      @javascript_stacktrace = To.ruby(try.StackTrace())
+      super("#{To.ruby(msg.Get())}: #{@source_name}:#{@line_number}")
     end
     
-    def javascript_stacktrace
-      @native.stack
+    def self.check(try)
+      raise JavascriptError.new(try) if try.HasCaught()
     end
-    
-  end
-  class RunawayScriptError < ContextError
+
   end
   
   module C
-    class Message
-      attr_reader :stack
+    class Context
+      def enter
+        if block_given?
+          if IsEntered()
+            yield(self)
+          else
+            Enter()
+            begin
+              yield(self)
+            ensure
+              Exit()
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/v8/function.rb

@@ -2,8 +2,26 @@ module V8
   class Function < V8::Object
     
     def call(thisObject, *args)
-      To.ruby(@native.Call(To.v8(thisObject), *args.map {|a| To.v8(a)}))
+      err = nil
+      return_value = nil
+      C::TryCatch.try do |try|
+        @context.enter do
+          this = To.v8(thisObject)
+          return_value = To.ruby(@native.Call(this, *args.map {|a| To.v8(a)}))
+          err = JavascriptError.new(try) if try.HasCaught()
+        end
+      end
+      raise err if err
+      return return_value
     end
-    
+
+    def self.rubycall(rubycode, *args)
+      begin
+        To.v8(rubycode.call(*args))
+      rescue StandardError => e
+        V8::C::ThrowException(V8::C::Exception::Error(V8::C::String::New(e.message)))
+      end
+    end
+
   end
 end

data/lib/v8/object.rb

@@ -3,33 +3,37 @@ module V8
   class Object
     include Enumerable
     
-    def initialize(native)
+    def initialize(native, context = nil)
       @native = native
+      @context = context || C::Context::GetEntered()
+      raise ScriptError, "V8::Object.new called without an open V8 context" unless @context
     end
     
     def [](key)
-      @native.context.open do
-        To.ruby(@native.Get(key.to_s))        
+      @context.enter do
+        To.ruby(@native.Get(To.v8(key)))        
       end
     end
     
     def []=(key, value)
       value.tap do
-        @native.context.open do
-          @native.Set(key.to_s, value)
+        @context.enter do
+          @native.Set(To.v8(key), To.v8(value))
         end
       end
     end
     
     def to_s
-      @native.context.open do
-        @native.ToString()
+      @context.enter do
+        To.rb(@native.ToString())
       end
     end
     
     def each
-      for prop in @native.GetPropertyNames()
-        yield prop, self[prop]
+      @context.enter do
+        for prop in To.rb(@native.GetPropertyNames())
+          yield prop, self[prop]
+        end
       end
     end
   end
@@ -37,8 +41,6 @@ end
 
 class Object  
   def eval_js(javascript)
-    V8::Context.open(:with => self) do |cxt|
-      cxt.eval(javascript)
-    end
+    V8::Context.new(:with => self).eval(javascript)
   end
 end