therubyracer-heroku 0.8.1.pre2

data/lib/v8/context.rb

@@ -0,0 +1,88 @@
+require 'stringio'
+
+module V8
+  class Context    
+    attr_reader :native, :scope, :access
+    def initialize(opts = {})
+      @access = Access.new
+      @to = Portal.new(self, @access)
+      @native = opts[:with] ? C::Context::New(@to.rubytemplate) : C::Context::New()
+      @native.enter do
+        @global = @native.Global()
+        @scope = @to.rb(@global)
+        @global.SetHiddenValue(C::String::New("TheRubyRacer::RubyObject"), C::External::New(opts[:with])) if opts[:with]
+      end
+      yield(self) if block_given?
+    end
+    
+    def eval(javascript, filename = "<eval>", line = 1)
+      if IO === javascript || StringIO === javascript
+        javascript = javascript.read()
+      end
+      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 = JSError.new(try, @to)
+          else
+            result = script.Run()
+            if try.HasCaught()
+              err = JSError.new(try, @to)
+            else
+              value = @to.rb(result)
+            end
+          end
+        end
+      end
+      raise err if err
+      return value
+    end
+            
+    def evaluate(*args)
+      self.eval(*args)
+    end
+    
+    def load(filename)
+      File.open(filename) do |file|
+        evaluate file, filename, 1
+      end      
+    end
+    
+    def [](key)
+      @scope[key]
+    end
+    
+    def []=(key, value)
+      @scope[key] = value
+    end
+
+    def self.eval(source)
+      new.eval(source)
+    end
+    
+    def V8.eval(*args)
+      V8::Context.eval(*args)
+    end
+  end
+
+  module C
+    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/error.rb

@@ -0,0 +1,129 @@
+
+module V8
+  class JSError < StandardError
+    attr_reader :value, :boundaries
+
+    def initialize(try, to)
+      @to = to
+      begin
+        super(initialize_unsafe(try))
+      rescue Exception => e
+        @boundaries = Boundary.new(:rbframes => e.backtrace)
+        @value = e
+        super("BUG! please report. JSError#initialize failed!: #{e.message}")
+      end
+    end
+
+    def initialize_unsafe(try)
+      message = nil
+      ex = @to.rb(try.Exception())
+      @boundaries = [Boundary.new(:rbframes => caller(3), :jsframes => parse_js_frames(try))]
+      if V8::Object === ex
+        if msg = ex['message']
+          message = msg
+        else
+          message = ex.to_s
+        end
+        if cause = ex.instance_variable_get(:@native).GetHiddenValue("TheRubyRacer::Cause")
+          if !cause.IsEmpty()
+            prev = cause.Value()
+            if prev.kind_of?(JSError)
+              @boundaries.concat prev.boundaries
+              @value = prev.value
+            else
+              @value = prev
+              @boundaries.concat [Boundary.new(:rbframes => prev.backtrace)]
+            end
+          else
+            @value = ex
+          end
+        end
+      else
+        @value = ex
+        message = ex.to_s
+      end
+      return message
+    end
+
+    def in_ruby?
+      @value.kind_of?(Exception)
+    end
+
+    def in_javascript?
+      !in_ruby?
+    end
+
+    def backtrace(*modifiers)
+      trace_framework = modifiers.include?(:framework)
+      trace_ruby = modifiers.length == 0 || modifiers.include?(:ruby)
+      trace_javascript = modifiers.length == 0 || modifiers.include?(:javascript)
+      mixed = []
+      rbcontext = []
+      jscontext = []
+      @boundaries.each do |b|
+        rbframes = b.rbframes.dup
+        rbcontext.reverse_each do |frame|
+          if frame == rbframes.last
+            rbframes.pop
+          else
+            break
+          end
+        end if trace_ruby
+        jsframes = b.jsframes.dup
+        jscontext.reverse_each do |frame|
+          if frame == jsframes.last
+            jsframes.pop
+          else
+            break
+          end
+        end if trace_javascript
+        rbcontext = b.rbframes
+        jscontext = b.jsframes
+        rbframes.reject! {|f| f =~ /lib\/v8\/.*\.rb/} unless trace_framework
+        mixed.unshift(*rbframes) if trace_ruby
+        mixed.unshift(*jsframes) if trace_javascript
+      end
+      return mixed
+    end
+
+    def parse_js_frames(try)
+      #I can't figure out why V8 is not capturing the stacktrace here
+      #in terms of StackTrace and StackFrame objects, so we have to
+      #parse the string.
+      raw = @to.rb(try.StackTrace())
+      if raw && !raw.empty? && !syntax_error?(try)
+        raw.split("\n")[1..-1].tap do |frames|
+          frames.each {|frame| frame.strip!.chomp!(",")}
+        end
+      else
+        msg = try.Message()
+        ["at #{@to.rb(msg.GetScriptResourceName())}:#{msg.GetLineNumber()}:#{msg.GetStartColumn() + 1}"]
+      end
+    end
+
+    #Syntax errors are weird in that they have a non-empty stack trace
+    #but it does not contain any source location information, so
+    #in these instances, we have to pull it out of the Message object
+    #in the TryCatch. Is there a better way to detect a syntax error
+    def syntax_error?(try)
+      ex = try.Exception()
+      if ex && ex.kind_of?(V8::Object)
+        type = ex["constructor"]
+        type && type.kind_of?(V8::Function) && type.name == "SyntaxError"
+      else
+        false
+      end
+    end
+
+    class Boundary
+      attr_reader :rbframes, :jsframes
+
+      def initialize(frames = {})
+        @rbframes = frames[:rbframes] || []
+        @jsframes = frames[:jsframes] || []
+      end
+    end
+  end
+  #deprecated -- use JSError
+  JavasriptError = JSError
+end

data/lib/v8/function.rb

@@ -0,0 +1,28 @@
+module V8
+  class Function < V8::Object
+    
+    def methodcall(thisObject, *args)
+      err = nil
+      return_value = nil
+      C::TryCatch.try do |try|
+        @portal.open do |to|
+          this = to.v8(thisObject)
+          return_value = to.rb(@native.Call(this, to.v8(args)))
+          err = JSError.new(try, to) if try.HasCaught()
+        end
+      end
+      raise err if err
+      return return_value
+    end
+    
+    def call(*args)
+      self.methodcall(@portal.context.native.Global(), *args)
+    end
+    
+    def new(*args)
+      @portal.open do |to|
+        to.rb(@native.NewInstance(to.v8(args)))
+      end
+    end
+  end
+end

data/lib/v8/object.rb

@@ -0,0 +1,69 @@
+
+module V8
+  class Object
+    include Enumerable
+
+    def initialize(native, portal)
+      @native, @portal = native, portal
+    end
+
+    def [](key)
+      @portal.open do |to|
+        to.rb(@native.Get(to.v8(key)))
+      end
+    end
+
+    def []=(key, value)
+      value.tap do
+        @portal.open do |to|
+          @native.Set(to.v8(key), to.v8(value))
+        end
+      end
+    end
+
+    def to_s
+      @portal.open do |to|
+        to.rb(@native.ToString())
+      end
+    end
+
+    def each
+      @portal.open do |to|
+        for prop in to.rb(@native.GetPropertyNames())
+          yield prop, self[prop]
+        end
+      end
+    end
+
+    def respond_to?(method)
+      self[method] != nil
+    end
+
+    def method_missing(name, *args, &block)
+      if name.to_s =~ /(.*)=$/
+        if args.length > 1
+          self[$1] = args
+          return args
+        else
+          self[$1] = args.first
+          return args
+        end
+      end
+      return super(name, *args, &block) unless self.respond_to?(name)
+      property = self[name]
+      if property.kind_of?(V8::Function)
+        property.methodcall(self, *args)
+      elsif args.empty?
+        property
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.length} for 0)" unless args.empty?
+      end
+    end
+  end
+end
+
+class Object  
+  def eval_js(javascript)
+    V8::Context.new(:with => self).eval(javascript)
+  end
+end

data/lib/v8/portal.rb

@@ -0,0 +1,327 @@
+
+module V8
+  class Portal
+    attr_reader :context
+
+    def initialize(context, access)
+      @context, @access = context, access
+      @named_property_getter = Interceptor(NamedPropertyGetter)
+      @named_property_setter = Interceptor(NamedPropertySetter)
+      @named_property_query = nil
+      @named_property_deleter = nil
+      @named_property_enumerator = Interceptor(NamedPropertyEnumerator)
+
+      @indexed_property_getter = Interceptor(IndexedPropertyGetter)
+      @indexed_property_setter = Interceptor(IndexedPropertySetter)
+      @indexed_property_query = nil
+      @indexed_property_deleter = nil
+      @indexed_property_enumerator = Interceptor(IndexedPropertyEnumerator)
+
+      @constructors = Hash.new do |h, cls|
+        h[cls] = template = C::FunctionTemplate::New() do |arguments|
+          unless arguments.Length() == 1 && arguments[0].kind_of?(C::External)
+            C::ThrowException(C::Exception::Error(C::String::New("cannot call native constructor from javascript")))
+          else
+            arguments.This().tap do |this|
+              this.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), arguments[0])              
+            end
+          end
+        end
+        template.tap do
+          setuptemplate(template.InstanceTemplate())
+          if cls != ::Object && cls.superclass != ::Object && cls.superclass != ::Class
+            template.Inherit(@constructors[cls.superclass])
+          end
+          if cls.name && cls.name =~ /(::)?(\w+?)$/
+            template.SetClassName(C::String::NewSymbol("rb::" + $2))
+          else
+            template.SetClassName("Ruby")
+          end
+        end
+      end
+
+      @instances = Hash.new do |h, obj|
+        args = C::Array::New(1)
+        args.Set(0, C::External::New(obj))
+        h[obj] = @constructors[obj.class].GetFunction().NewInstance(args)
+      end
+
+      @functions = Functions.new(self)
+
+      @embedded_constructors = Hash.new do |h, cls|
+        template = @constructors[cls]
+        template.SetCallHandler() do |arguments|
+          wrap = nil
+          if arguments.Length() > 0 && arguments[0].kind_of?(C::External)
+            wrap = arguments[0]
+          else
+            rbargs = []
+            for i in 0..arguments.Length() - 1
+              rbargs << rb(arguments[i])
+            end
+            instance = rubysend(cls, :new, *rbargs)
+            wrap = C::External::New(instance)
+          end
+          arguments.This().tap do |this|
+            this.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), wrap)
+          end
+        end
+        h[cls] = template
+      end
+    end
+
+    def open
+      @context.native.enter do
+        yield(self)
+      end if block_given?
+    end
+
+    def rb(value)
+      case value
+      when V8::C::Function  then peer(value) {V8::Function}
+      when V8::C::Array     then peer(value) {V8::Array}
+      when V8::C::Object    then peer(value) {V8::Object}
+      when V8::C::String    then value.Utf8Value()
+      when V8::C::Date      then Time.at(value.NumberValue() / 1000)
+      when V8::C::Value     then nil if value.IsEmpty()
+      else
+        value
+      end
+    end
+
+    def v8(value)
+      case value
+      when V8::Object
+        value.instance_eval {@native}
+      when String
+        C::String::New(value.to_s)
+      when Symbol
+        C::String::NewSymbol(value.to_s)
+      when Proc,Method,UnboundMethod
+        @functions[value]
+      when ::Array
+        C::Array::New(value.length).tap do |a|
+          value.each_with_index do |item, i|
+            a.Set(i, v8(item))
+          end
+        end
+      when ::Hash
+        C::Object::New().tap do |o|
+          value.each do |key, value|
+            o.Set(v8(key), v8(value))
+          end
+        end
+      when ::Time
+        C::Date::New(value.to_f * 1000)
+      when ::Class
+        @embedded_constructors[value].GetFunction().tap do |f|
+          f.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), C::External::New(value))
+          #set the function's prototype object to the object that will have the named property handlers
+          prototype = rubytemplate.NewInstance()
+          #set *that* object's prototype to an empty function so that it will look and behave like a function.
+          prototype.SetPrototype(C::FunctionTemplate::New() {}.GetFunction())
+          f.SetPrototype(prototype)
+        end
+      when nil,Numeric,TrueClass,FalseClass, C::Value
+        value
+      else
+        @instances[value]
+      end
+    end
+
+    def rubyprotect
+      begin
+        v8 yield
+      rescue Exception => e
+        case e
+        when SystemExit, NoMemoryError
+          raise e
+        else
+          error = V8::C::Exception::Error(V8::C::String::New(e.message))
+          error.SetHiddenValue("TheRubyRacer::Cause", C::External::New(e))
+          V8::C::ThrowException(error)
+        end
+      end
+    end
+
+    def rubycall(rubycode, *args, &block)
+      rubyprotect do
+        rubycode.call(*args, &block)
+      end
+    end
+
+    def rubysend(obj, message, *args, &block)
+      rubyprotect do
+        obj.send(message, *args, &block)
+      end
+    end
+    
+    def rubytemplate
+      C::ObjectTemplate::New().tap do |t|
+        setuptemplate(t)
+      end
+    end
+    
+    def setuptemplate(t)
+      t.SetNamedPropertyHandler(
+        @named_property_getter,
+        @named_property_setter,
+        nil,
+        nil,
+        @named_property_enumerator
+      )
+      t.SetIndexedPropertyHandler(
+        @indexed_property_getter,
+        @indexed_property_setter,
+        nil,
+        nil,
+        @indexed_property_enumerator
+      )
+    end
+
+    private
+
+    def peer(value)
+      external = value.GetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"))
+      if external && !external.IsEmpty()
+        external.Value()
+      else
+        yield.new(value, self).tap do |object|
+          value.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), C::External::New(object))
+        end
+      end
+    end
+
+    class Interceptor
+      def initialize(portal, access)
+        @to, @access = portal, access
+      end
+
+      def intercept(info, retval = nil, &code)
+        obj = @to.rb(info.This())
+        intercepts = true
+        result = @to.rubyprotect do
+          dontintercept = proc do
+            intercepts = false
+          end
+          code.call(obj, dontintercept)
+        end
+        intercepts ? (retval || result) : C::Empty
+      end
+
+    end
+
+    def Interceptor(cls)
+      cls.new self, @access
+    end
+
+    class PropertyAttributes
+      attr_reader :flags
+      def initialize
+        @flags = 0
+      end
+
+      def read_only
+        tap do
+          @flags |= V8::C::ReadOnly
+        end
+      end
+
+      def dont_enum
+        tap do
+          @flags |= V8::C::DontEnum
+        end
+      end
+
+      def dont_delete
+        tap do
+          @flags |= V8::C::DontDelete
+        end
+      end
+    end
+    
+    class NamedPropertyGetter < Interceptor
+      def call(property, info)
+        intercept(info) do |obj, dontintercept|
+          @access.get(obj, @to.rb(property), &dontintercept)
+        end
+      end
+    end
+
+    class NamedPropertySetter < Interceptor
+      def call(property, value, info)
+        intercept(info, value) do |obj, dontintercept|
+          @access.set(obj, @to.rb(property), @to.rb(value), &dontintercept)
+        end
+      end
+    end
+
+    class NamedPropertyQuery
+      def call(property, info)
+        attributes = PropertyAttributes.new
+        result = intercept(info) do |obj, dontintercept|
+          @access.query(obj, @to.rb(property), attributes, &dontintercept)
+        end
+        return result == C::Empty ? result : C::Integer::New(attributes.flags)
+      end
+    end
+
+    class NamedPropertyEnumerator < Interceptor
+      def call(info)
+        intercept(info) do |obj, dontintercept|
+          @access.names(obj, &dontintercept).to_a
+        end
+      end
+    end
+    
+    class NamedPropertyDeleter < Interceptor
+      def call(property, info)
+        intercept(info) do |obj, dontintercept|
+          @access.delete(obj, property, &dontintercept)
+        end
+      end
+    end
+
+    class IndexedPropertyGetter < Interceptor
+      def call(index, info)
+        intercept(info) do |obj, dontintercept|
+          @access.iget(obj, index, &dontintercept)
+        end
+      end
+    end
+
+    class IndexedPropertySetter < Interceptor
+      def call(index, value, info)
+        intercept(info, value) do |obj, dontintercept|
+          @access.iset(obj, index, @to.rb(value), &dontintercept)
+        end
+      end
+    end
+
+    class IndexedPropertyQuery < Interceptor
+      def call(property, info)
+        attributes = PropertyAttributes.new
+        result = intercept(info) do |obj, dontintercept|
+          @access.indices(obj, &dontintercept)
+        end
+        result == C::Empty ? C::Empty : C::Integer::New(attributes.flags)
+      end
+    end
+
+    class IndexedPropertyDeleter < Interceptor
+      def call(index, info)
+        intercept(info) do |obj, dontintercept|
+          @access.idelete(obj, index, &dontintercept)
+        end
+      end
+    end
+    
+    class IndexedPropertyEnumerator < Interceptor
+      def call(info)
+        intercept(info) do |obj, dontintercept|
+          @access.indices(obj, &dontintercept)
+        end
+      end
+    end
+  end
+end