therubyracer-freebsd 0.10.1 → 0.11.1p2

data/lib/v8/context.rb

@@ -1,111 +0,0 @@
-require 'stringio'
-
-module V8
-  class Context
-    attr_reader :native, :scope, :access
-
-    def initialize(opts = {})
-      @access = Access.new
-      @to = Portal.new(self, @access)
-      @to.lock do
-        with = opts[:with]
-        constructor = nil
-        template = if with
-          constructor = @to.templates.to_constructor(with.class)
-          constructor.disable()
-          constructor.template.InstanceTemplate()
-        else
-          C::ObjectTemplate::New()
-        end
-        @native = opts[:with] ? C::Context::New(template) : C::Context::New()
-        @native.enter do
-          @global = @native.Global()
-          @to.proxies.register_javascript_proxy @global, :for => with if with
-          constructor.enable() if constructor
-          @scope = @to.rb(@global)
-          @global.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyContext"), C::External::New(self))
-        end
-        yield(self) if block_given?
-      end
-    end
-
-    def eval(javascript, filename = "<eval>", line = 1)
-      if IO === javascript || StringIO === javascript
-        javascript = javascript.read()
-      end
-      err = nil
-      value = nil
-      @to.lock do
-        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
-      end
-      raise err if err
-      return value
-    end
-
-    def load(filename)
-      File.open(filename) do |file|
-        self.eval file, filename, 1
-      end
-    end
-
-    def [](key)
-      @to.open do
-        @to.rb @global.Get(@to.v8(key))
-      end
-    end
-
-    def []=(key, value)
-      @to.open do
-        @global.Set(@to.v8(key), @to.v8(value))
-      end
-      return value
-    end
-
-    def self.stack(limit = 99)
-      if native = C::Context::GetEntered()
-        global = native.Global()
-        cxt = global.GetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyContext")).Value()
-        cxt.instance_eval {@to.rb(C::StackTrace::CurrentStackTrace(limit))}
-      else
-        []
-      end
-    end
-    
-    def self.passes_this_argument?
-      true
-    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

@@ -1,130 +0,0 @@
-
-module V8
-  class JSError < StandardError
-    attr_reader :value, :boundaries
-
-    def initialize(try, to)
-      @to = to
-      super(initialize_unsafe(try))
-    rescue Exception => e
-      @boundaries = [Boundary.new(:rbframes => e.backtrace)]
-      @value = e
-      super(<<-EOMSG)
-You have uncovered what is probably a BUG in therubyracer exception code. An error report would be very helpful.
-JSError#initialize failed!: #{e.message}"
-EOMSG
-    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!; frame.chomp!(",")}
-        end.reject(&:empty?)
-      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 = @to.rb(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

@@ -1,44 +0,0 @@
-module V8
-  class Function < V8::Object
-
-    def methodcall(thisObject, *args)
-      err = nil
-      return_value = nil
-      @portal.open do |to|
-        C::TryCatch.try do |try|
-          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)
-      @portal.open do
-        self.methodcall(@portal.context.native.Global(), *args)
-      end
-    end
-
-    def new(*args)
-      @portal.open do |to|
-        to.rb(@native.NewInstance(to.v8(args)))
-      end
-    end
-
-    def name
-      @portal.open do |to|
-        to.rb(@native.GetName())
-      end
-    end
-
-    def name=(name)
-      name.tap do
-        @portal.open do |to|
-          @native.SetName(to.v8(name))
-        end
-      end
-    end
-  end
-end

data/lib/v8/object.rb

@@ -1,69 +0,0 @@
-
-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)
-      super or 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/caller.rb

@@ -1,37 +0,0 @@
-
-module V8
-  class Portal
-    class Caller
-
-      def initialize(portal)
-        @portal = portal
-      end
-
-      def raw
-        yield
-      rescue Exception => e
-        case e
-        when SystemExit, NoMemoryError
-          raise e
-        else
-          error = V8::C::Exception::Error(V8::C::String::New(e.message))
-          #TODO: This is almost certainly a crash here.
-          #we need to hold onto `error` while it bubbles up the javascript stack.
-          error.SetHiddenValue("TheRubyRacer::Cause", C::External::New(e))
-          V8::C::ThrowException(error)
-        end
-      end
-
-      def protect(*args, &block)
-        @portal.v8 raw(*args, &block)
-      end
-
-      def invoke(code, *args, &block)
-        protect do
-          args = args.slice(0, code.arity) if code.arity >= 0
-          code.call(*args, &block)
-        end
-      end
-    end
-  end
-end

data/lib/v8/portal/constructor.rb

@@ -1,98 +0,0 @@
-
-module V8
-  class Portal
-    class ConstructorAdapter
-      attr_reader :template, :exposed
-      alias_method :exposed?, :exposed
-
-      def initialize(templates, class_id)
-        @exposed = false
-        @class_id = class_id
-        @templates = templates
-        @invoke = method(:invoke)
-        @template = C::FunctionTemplate::New(@invoke)
-        portal.interceptors.setup(@template.InstanceTemplate())
-        cls = self.ruby_class
-        superclass = cls.superclass
-        if cls != ::Object && superclass != ::Object && superclass != ::Class
-          @template.Inherit(templates.to_constructor(superclass).template)
-        end
-        if cls.name && cls.name =~ /(::)?(\w+?)$/
-          template.SetClassName(C::String::NewSymbol("rb::" + $2))
-        else
-          template.SetClassName("Ruby")
-        end
-      end
-
-      def function
-        @template.GetFunction()
-      end
-
-      def allocate(object)
-        arguments = C::Array::New(1)
-        arguments.Set(0, C::External::New(object))
-        function.NewInstance(arguments)
-      end
-
-      def disable
-        @disabled = true
-      end
-
-      def enable
-        @disabled = nil
-      end
-
-      def invoke(arguments)
-        return if @disabled
-        if !@exposed
-          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
-            object = arguments[0].Value()
-            proxies.register_javascript_proxy arguments.This(), :for => object
-          end
-        else
-          instance = nil
-          if arguments.Length() > 0 && arguments[0].kind_of?(C::External)
-            instance = arguments[0].Value()
-          else
-            rbargs = []
-            for i in 0..arguments.Length() - 1
-              rbargs << @templates.portal.rb(arguments[i])
-            end
-            instance = portal.caller.raw do
-              self.ruby_class.new(*rbargs)
-            end
-          end
-          proxies.register_javascript_proxy arguments.This(), :for => instance
-        end
-      end
-
-      def exposed=(exposed)
-        if exposed && !@augmented
-          #create a prototype so that this constructor also acts like a ruby object
-          prototype_template = C::ObjectTemplate::New()
-          portal.interceptors.setup(prototype_template)
-          prototype = prototype_template.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())
-          template.GetFunction().SetPrototype(prototype)
-          @augmented = true
-        end
-        @exposed = exposed
-      end
-
-      def ruby_class
-        ObjectSpace._id2ref(@class_id)
-      end
-
-      def proxies
-        @templates.proxies
-      end
-
-      def portal
-        @templates.portal
-      end
-    end
-  end
-end

data/lib/v8/portal/function.rb

@@ -1,63 +0,0 @@
-module V8
-  class Portal
-    class FunctionAdapter
-
-      attr_reader :template
-
-      def initialize(portal, code)
-        @portal = portal
-        @caller = case code
-        when Method then BoundCall.new(portal)
-        when UnboundMethod then BindAndCall.new(portal)
-        else Call.new(portal)
-        end
-        @code = code
-        @template = V8::C::FunctionTemplate::New(@caller, @code)
-      end
-
-      def function
-        @template.GetFunction()
-      end
-
-      class Call
-        def initialize(portal)
-          @portal = portal
-        end
-
-        def call(arguments)
-          proc = arguments.Data()
-          rbargs = [@portal.rb(arguments.This())]
-          for i in 0..arguments.Length() - 1
-            rbargs << @portal.rb(arguments[i])
-          end
-          @portal.caller.invoke(proc, *rbargs)
-        end
-      end
-
-      class BoundCall < Call
-        def call(arguments)
-          proc = arguments.Data()
-          rbargs = []
-          for i in 0..arguments.Length() - 1
-            rbargs << @portal.rb(arguments[i])
-          end
-          @portal.caller.invoke(proc, *rbargs)
-        end
-      end
-
-      class BindAndCall < Call
-        def call(arguments)
-          method = arguments.Data()
-          rbargs = []
-          for i in 0..arguments.Length() - 1
-            rbargs << @portal.rb(arguments[i])
-          end
-          this = @portal.rb(arguments.This())
-          @portal.caller.protect do
-            method.bind(this).call(*rbargs)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/v8/portal/interceptors.rb

@@ -1,152 +0,0 @@
-module V8
-  class Portal
-    class Interceptors
-      def initialize(portal)
-        @getter = NamedPropertyGetter.new(portal)
-        @setter = NamedPropertySetter.new(portal)
-        @query = nil
-        @deleter = nil
-        @enumerator = NamedPropertyEnumerator.new(portal)
-        @igetter = IndexedPropertyGetter.new(portal)
-        @isetter = IndexedPropertySetter.new(portal)
-        @iquery = nil
-        @ideleter = nil
-        @ienumerator = IndexedPropertyEnumerator.new(portal)
-      end
-
-      def setup(template)
-        template.SetNamedPropertyHandler(@getter,@setter,@query,@deleter,@enumerator, nil)
-        template.SetIndexedPropertyHandler(@igetter,@isetter,@iquery,@ideleter,@ienumerator, nil)
-      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 Interceptor
-
-        def initialize(portal)
-          @to, @access = portal, portal.access
-        end
-
-        def intercept(info, retval = nil, &code)
-          obj = @to.rb(info.This())
-          intercepts = true
-          result = @to.caller.protect do
-            dontintercept = proc do
-              intercepts = false
-            end
-            code.call(obj, dontintercept)
-          end
-          intercepts ? (retval || result) : C::Empty
-        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
-end
-