therubyracer 0.5.0-x86-linux → 0.11.0beta5-x86-linux

data/lib/v8/access/names.rb

@@ -0,0 +1,65 @@
+require 'set'
+class V8::Access
+  module Names
+    def names(obj)
+      accessible_names(obj)
+    end
+
+    def get(obj, name, &dontintercept)
+      methods = accessible_names(obj)
+      if methods.include?(name)
+        method = obj.method(name)
+        method.arity == 0 ? method.call : method.unbind
+      elsif obj.respond_to?(:[]) && !special?(name)
+        obj.send(:[], name, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def set(obj, name, value, &dontintercept)
+      setter = name + "="
+      methods = accessible_names(obj, true)
+      if methods.include?(setter)
+        obj.send(setter, value)
+      elsif obj.respond_to?(:[]=) && !special?(name)
+        obj.send(:[]=, name, value, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def query(obj, name, attributes, &dontintercept)
+      if obj.respond_to?(name)
+        attributes.dont_delete
+        unless obj.respond_to?(name + "=")
+          attributes.read_only
+        end
+      else
+        yield
+      end
+    end
+
+    def delete(obj, name, &dontintercept)
+      yield
+    end
+
+    def accessible_names(obj, special_methods = false)
+      obj.public_methods(false).map {|m| m.to_s}.to_set.tap do |methods|
+        ancestors = obj.class.ancestors.dup
+        while ancestor = ancestors.shift
+          break if ancestor == ::Object
+          methods.merge(ancestor.public_instance_methods(false).map {|m| m.to_s})
+        end
+        methods.reject!(&special?) unless special_methods
+      end
+    end
+
+    private
+
+    def special?(name = nil)
+      @special ||= lambda {|m| m == "[]" || m == "[]=" || m =~ /=$/}
+      name.nil? ? @special : @special[name]
+    end
+  end
+end

data/lib/v8/array.rb

@@ -0,0 +1,26 @@
+class V8::Array < V8::Object
+
+  def initialize(native_or_length = nil)
+    super do
+      if native_or_length.is_a?(Numeric)
+        V8::C::Array::New(native_or_length)
+      elsif native_or_length.is_a?(V8::C::Array)
+        native_or_length
+      else
+        V8::C::Array::New()
+      end
+    end
+  end
+
+  def each
+    @context.enter do
+      0.upto(@native.Length() - 1) do |i|
+        yield @context.to_ruby(@native.Get(i))
+      end
+    end
+  end
+
+  def length
+    @native.Length()
+  end
+end

data/lib/v8/context.rb

@@ -1,101 +1,243 @@
 require 'stringio'
+module V8
+  # All JavaScript must be executed in a context. This context consists of a global scope containing the
+  # standard JavaScript objects¨and functions like Object, String, Array, as well as any objects or
+  # functions from Ruby which have been embedded into it from the containing enviroment. E.g.
+  #
+  #     V8::Context.new do |cxt|
+  #         cxt['num'] = 5
+  #         cxt.eval('num + 5') #=> 10
+  #     end
+  #
+  # The same object may appear in any number of contexts, but only one context may be executing JavaScript code
+  # in any given thread. If a new context is opened in a thread in which a context is already opened, the second
+  # context will "mask" the old context e.g.
+  #
+  #   six = 6
+  #   Context.new do |cxt|
+  #     cxt['num'] = 5
+  #     cxt.eval('num') # => 5
+  #     Context.new do |cxt|
+  #       cxt['num'] = 10
+  #       cxt.eval('num') # => 10
+  #       cxt.eval('++num') # => 11
+  #     end
+  #     cxt.eval('num') # => 5
+  #   end
+  class Context
+    include V8::Error::Try
 
-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)
+    # @!attribute [r] conversion
+    #   @return [V8::Conversion] conversion behavior for this context
+    attr_reader :conversion
+
+    # @!attrribute [r] access
+    #   @return [V8::Access] Ruby access behavior for this context
+    attr_reader :access
+
+    # @!attribute [r] native
+    #   @return [V8::C::Context] the underlying C++ object
+    attr_reader :native
+
+    # Creates a new context.
+    #
+    # If passed the `:with` option, that object will be used as
+    # the global scope of the newly creating context. e.g.
+    #
+    #     scope = Object.new
+    #     def scope.hello; "Hi"; end
+    #     V8::Context.new(:with => scope) do |cxt|
+    #       cxt['hello'] #=> 'Hi'
+    #     end
+    #
+    # @param [Hash<Symbol, Object>] options initial context configuration
+    #  * :with scope serves as the global scope of the new context
+    # @yield [V8::Context] the newly created context
+    def initialize(options = {})
+      @conversion = Conversion.new
+      @access = Access.new
+      if global = options[:with]
+        Context.new.enter do
+          global_template = global.class.to_template.InstanceTemplate()
+          @native = V8::C::Context::New(nil, global_template)
         end
+        enter {link global, @native.Global()}
+      else
+        @native = V8::C::Context::New()
       end
+      yield self if block_given?
     end
-    
-    def eval(javascript, sourcename = '<eval>', line = 1)
-      if IO === javascript || StringIO === javascript
-        javascript = javascript.read()
+
+    # Compile and execute a string of JavaScript source.
+    #
+    # If `source` is an IO object it will be read fully before being evaluated
+    #
+    # @param [String,IO] source the source code to compile and execute
+    # @param [String] filename the name to use for this code when generating stack traces
+    # @param [Integer] line the line number to start with
+    # @return [Object] the result of the evaluation
+    def eval(source, filename = '<eval>', line = 1)
+      if IO === source || StringIO === source
+        source = source.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)
-        end
+      enter do
+        script = try { V8::C::Script::New(source.to_s, filename.to_s) }
+        to_ruby try {script.Run()}
       end
     end
-        
-    def evaluate(*args)
-      self.eval(*args)
-    end
-    
-    def load(filename)
-      File.open(filename) do |file|
-        evaluate file, filename, 1
-      end      
-    end
-    
+
+    # Read a value from the global scope of this context
+    #
+    # @param [Object] key the name of the value to read
+    # @return [Object] value the value at `key`
     def [](key)
-      open do
-        To.ruby(@native.Global().Get(key.to_s))
+      enter do
+        to_ruby(@native.Global().Get(to_v8(key)))
       end
     end
-    
+
+    # Binds `value` to the name `key` in the global scope of this context.
+    #
+    # @param [Object] key the name to bind to
+    # @param [Object] value the value to bind
     def []=(key, value)
-      value.tap do 
-        open do
-          @native.Global().tap do |scope|
-            scope.Set(key.to_s, value)
-          end
-        end
+      enter do
+        @native.Global().Set(to_v8(key), to_v8(value))
       end
+      return value
     end
-    
-    def self.open(opts = {}, &block)
-      new(opts).open(&block)
+
+    # Destroy this context and release any internal references it may
+    # contain to embedded Ruby objects.
+    #
+    # A disposed context may never again be used for anything, and all
+    # objects created with it will become unusable.
+    def dispose
+      return unless @native
+      @native.Dispose()
+      @native = nil
+      V8::C::V8::ContextDisposedNotification()
+      def self.enter
+        fail "cannot enter a context which has already been disposed"
+      end
     end
-    
-    def self.eval(source)
-      new.eval(source)
+
+    # Returns this context's global object. This will be a `V8::Object`
+    # if no scope was provided or just an `Object` if a Ruby object
+    # is serving as the global scope.
+    #
+    # @return [Object] scope the context's global scope.
+    def scope
+      enter { to_ruby @native.Global() }
     end
-    
-    def V8.eval(*args)
-      V8::Context.eval(*args)
+
+    # Converts a v8 C++ object into its ruby counterpart. This is method
+    # is used to translate all values passed to Ruby from JavaScript, either
+    # as return values or as callback parameters.
+    #
+    # @param [V8::C::Object] v8_object the native c++ object to convert.
+    # @return [Object] to pass to Ruby
+    # @see V8::Conversion for how to customize and extend this mechanism
+    def to_ruby(v8_object)
+      @conversion.to_ruby(v8_object)
     end
-  end
-  
-  class ContextError < StandardError
-    def initialize(caller_name)
-      super("tried to call method '#{caller_name} without an open context")
+
+    # Converts a Ruby object into a native v8 C++ object. This method is
+    # used to translate all values passed to JavaScript from Ruby, either
+    # as return value or as callback parameters.
+    #
+    # @param [Object] ruby_object the Ruby object to convert
+    # @return [V8::C::Object] to pass to V8
+    # @see V8::Conversion for customizing and extending this mechanism
+    def to_v8(ruby_object)
+      @conversion.to_v8(ruby_object)
     end
-    def self.check_open(caller_name)
-      raise new(caller_name) unless C::Context::InContext()
+
+    # Marks a Ruby object and a v8 C++ Object as being the same. In other
+    # words whenever `ruby_object` is passed to v8, the result of the
+    # conversion should be `v8_object`. Conversely, whenever `v8_object`
+    # is passed to Ruby, the result of the conversion should be `ruby_object`.
+    # The Ruby Racer uses this mechanism to maintain referential integrity
+    # between Ruby and JavaScript peers
+    #
+    # @param [Object] ruby_object the Ruby half of the object identity
+    # @param [V8::C::Object] v8_object the V8 half of the object identity.
+    # @see V8::Conversion::Identity
+    def link(ruby_object, v8_object)
+      @conversion.equate ruby_object, v8_object
     end
-  end
-  class JavascriptError < StandardError
-    def initialize(v8_message)
-      super("#{v8_message.Get()}: #{v8_message.GetSourceLine()}")
-      @native = v8_message
+
+    # Links `ruby_object` and `v8_object` inside the currently entered
+    # context. This is an error if no context has been entered.
+    #
+    # @param [Object] ruby_object the Ruby half of the object identity
+    # @param [V8::C::Object] v8_object the V8 half of the object identity.
+    def self.link(ruby_object, v8_object)
+      current.link ruby_object, v8_object
     end
 
-    def source_name
-      @native.GetScriptResourceName()      
+    # Run some Ruby code in the context of this context.
+    #
+    # This will acquire the V8 interpreter lock (possibly blocking
+    # until it is available), and prepare V8 for JavaScript execution.
+    #
+    # Only one context may be running at a time per thread.
+    #
+    # @return [Object] the result of executing `block`
+    def enter(&block)
+      if !entered?
+        lock_scope_and_enter(&block)
+      else
+        yield
+      end
     end
-    
-    def source_line
-      @native.GetSourceLine()
+
+    # Indicates if this context is the currently entered context
+    #
+    # @return true if this context is currently entered
+    def entered?
+      Context.current == self
     end
-    
-    def line_number
-      @native.GetLineNumber()
+
+    # Get the currently entered context.
+    #
+    # @return [V8::Context] currently entered context, nil if none entered.
+    def self.current
+      Thread.current[:v8_context]
+    end
+
+    # Compile and execute the contents of the file with path `filename`
+    # as JavaScript code.
+    #
+    # @param [String] filename path to the file to execute.
+    # @return [Object] the result of the evaluation.
+    def load(filename)
+      File.open(filename) do |file|
+        self.eval file, filename
+      end
+    end
+
+    private
+
+    def self.current=(context)
+      Thread.current[:v8_context] = context
+    end
+
+    def lock_scope_and_enter
+      current = Context.current
+      Context.current = self
+      V8::C::Locker() do
+        V8::C::HandleScope() do
+          begin
+            @native.Enter()
+            yield if block_given?
+          ensure
+            @native.Exit()
+          end
+        end
+      end
+    ensure
+      Context.current = current
     end
-    
-  end
-  class RunawayScriptError < ContextError
   end
 end

data/lib/v8/conversion.rb

@@ -0,0 +1,35 @@
+
+class V8::Conversion
+  include Fundamental
+  include Identity
+
+  def to_ruby(v8_object)
+    super v8_object
+  end
+
+  def to_v8(ruby_object)
+    super ruby_object
+  end
+end
+
+for type in [TrueClass, FalseClass, NilClass, Float, Fixnum] do
+  type.class_eval do
+    include V8::Conversion::Primitive
+  end
+end
+
+for type in [Class, Object, Array, Hash, String, Symbol, Time, Proc, Method] do
+  type.class_eval do
+    include V8::Conversion.const_get(name)
+  end
+end
+class UnboundMethod
+  include V8::Conversion::Method
+end
+
+for type in [:Object, :String, :Date] do
+  V8::C::const_get(type).class_eval do
+    include V8::Conversion::const_get("Native#{type}")
+  end
+end
+

data/lib/v8/conversion/array.rb

@@ -0,0 +1,11 @@
+class V8::Conversion
+  module Array
+    def to_v8
+      array = V8::Array.new(length)
+      each_with_index do |item, i|
+        array[i] = item
+      end
+      return array.to_v8
+    end
+  end
+end