therubyracer-xcode 0.12.2

data/ext/v8/value.cc

@@ -0,0 +1,239 @@
+#include "rr.h"
+
+namespace rr {
+
+VALUE Value::Empty;
+
+void Value::Init() {
+  Empty = rb_eval_string("Object.new");
+  ClassBuilder("Value").
+    defineConst("Empty", Empty).
+    defineMethod("IsUndefined", &IsUndefined).
+    defineMethod("IsNull", &IsNull).
+    defineMethod("IsTrue", &IsTrue).
+    defineMethod("IsFalse", &IsFalse).
+    defineMethod("IsString", &IsString).
+    defineMethod("IsFunction", &IsFunction).
+    defineMethod("IsArray", &IsArray).
+    defineMethod("IsObject", &IsObject).
+    defineMethod("IsBoolean", &IsBoolean).
+    defineMethod("IsNumber", &IsNumber).
+    defineMethod("IsExternal", &IsExternal).
+    defineMethod("IsInt32", &IsInt32).
+    defineMethod("IsUint32", &IsUint32).
+    defineMethod("IsDate", &IsDate).
+    defineMethod("IsBooleanObject", &IsBooleanObject).
+    defineMethod("IsNumberObject", &IsNumberObject).
+    defineMethod("IsStringObject", &IsStringObject).
+    defineMethod("IsNativeError", &IsNativeError).
+    defineMethod("IsRegExp", &IsRegExp).
+    defineMethod("ToString", &ToString).
+    defineMethod("ToDetailString", &ToDetailString).
+    defineMethod("ToObject", &ToObject).
+    defineMethod("BooleanValue", &BooleanValue).
+    defineMethod("NumberValue", &NumberValue).
+    defineMethod("IntegerValue", &IntegerValue).
+    defineMethod("Uint32Value", &Uint32Value).
+    defineMethod("IntegerValue", &IntegerValue).
+    defineMethod("Equals", &Equals).
+    defineMethod("StrictEquals", &StrictEquals)
+    .store(&Class);
+    rb_gc_register_address(&Empty);
+}
+
+ VALUE Value::IsUndefined(VALUE self) {
+   return Bool(Value(self)->IsUndefined());
+ }
+ VALUE Value::IsNull(VALUE self) {
+   return Bool(Value(self)->IsNull());
+ }
+ VALUE Value::IsTrue(VALUE self) {
+   return Bool(Value(self)->IsTrue());
+ }
+ VALUE Value::IsFalse(VALUE self) {
+   return Bool(Value(self)->IsFalse());
+ }
+ VALUE Value::IsString(VALUE self) {
+   return Bool(Value(self)->IsString());
+ }
+ VALUE Value::IsFunction(VALUE self) {
+   return Bool(Value(self)->IsFunction());
+ }
+ VALUE Value::IsArray(VALUE self) {
+   return Bool(Value(self)->IsArray());
+ }
+ VALUE Value::IsObject(VALUE self) {
+   return Bool(Value(self)->IsObject());
+ }
+ VALUE Value::IsBoolean(VALUE self) {
+   return Bool(Value(self)->IsBoolean());
+ }
+ VALUE Value::IsNumber(VALUE self) {
+   return Bool(Value(self)->IsNumber());
+ }
+ VALUE Value::IsExternal(VALUE self) {
+   return Bool(Value(self)->IsExternal());
+ }
+ VALUE Value::IsInt32(VALUE self) {
+   return Bool(Value(self)->IsInt32());
+ }
+ VALUE Value::IsUint32(VALUE self) {
+   return Bool(Value(self)->IsUint32());
+ }
+ VALUE Value::IsDate(VALUE self) {
+   return Bool(Value(self)->IsDate());
+ }
+ VALUE Value::IsBooleanObject(VALUE self) {
+   return Bool(Value(self)->IsBooleanObject());
+ }
+ VALUE Value::IsNumberObject(VALUE self) {
+   return Bool(Value(self)->IsNumberObject());
+ }
+ VALUE Value::IsStringObject(VALUE self) {
+   return Bool(Value(self)->IsStringObject());
+ }
+ VALUE Value::IsNativeError(VALUE self) {
+   return Bool(Value(self)->IsNativeError());
+ }
+ VALUE Value::IsRegExp(VALUE self) {
+   return Bool(Value(self)->IsRegExp());
+ }
+
+ // VALUE Value::ToBoolean(VALUE self) {
+ //   return Boolean(Value(self)->ToBoolean());
+ // }
+
+ // VALUE Value::ToNumber(VALUE self) {
+ //   return Number(Value(self)->ToNumber());
+ // }
+ VALUE Value::ToString(VALUE self) {
+   return String(Value(self)->ToString());
+ }
+
+ VALUE Value::ToDetailString(VALUE self) {
+   return String(Value(self)->ToDetailString());
+ }
+
+ VALUE Value::ToObject(VALUE self) {
+   return Object(Value(self)->ToObject());
+ }
+
+ // VALUE Value::ToInteger(VALUE self) {
+ //   return Integer(Value(self)->ToInteger());
+ // }
+
+ // VALUE Value::ToUint32(VALUE self) {
+ //   return Uint32(Value(self)->ToUint32());
+ // }
+
+ // VALUE Value::ToInt32(VALUE self) {
+ //   return Int32(Value(self)->ToInt32());
+ // }
+
+
+// VALUE Value::ToArrayIndex(VALUE self) {
+//   return Uint32(Value(self)->ToArrayIndex());
+// }
+
+VALUE Value::BooleanValue(VALUE self) {
+  return Bool(Value(self)->BooleanValue());
+}
+VALUE Value::NumberValue(VALUE self) {
+  return rb_float_new(Value(self)->NumberValue());
+}
+VALUE Value::IntegerValue(VALUE self) {
+  return INT2NUM(Value(self)->IntegerValue());
+}
+VALUE Value::Uint32Value(VALUE self) {
+  return UINT2NUM(Value(self)->Uint32Value());
+}
+VALUE Value::Int32Value(VALUE self) {
+  return INT2FIX(Value(self)->Int32Value());
+}
+
+VALUE Value::Equals(VALUE self, VALUE other) {
+  return Bool(Value(self)->Equals(Value(other)));
+}
+
+VALUE Value::StrictEquals(VALUE self, VALUE other) {
+  return Bool(Value(self)->StrictEquals(Value(other)));
+}
+
+Value::operator VALUE() {
+  if (handle.IsEmpty() || handle->IsUndefined() || handle->IsNull()) {
+    return Qnil;
+  }
+  if (handle->IsTrue()) {
+    return Qtrue;
+  }
+  if (handle->IsFalse()) {
+    return Qfalse;
+  }
+  if (handle->IsExternal()) {
+    return External((v8::Handle<v8::External>)v8::External::Cast(*handle));
+  }
+  if (handle->IsUint32()) {
+    return UInt32(handle->Uint32Value());
+  }
+  if (handle->IsInt32()) {
+    return INT2FIX(handle->Int32Value());
+  }
+  if (handle->IsBoolean()) {
+    return handle->BooleanValue() ? Qtrue : Qfalse;
+  }
+  if (handle->IsNumber()) {
+    return rb_float_new(handle->NumberValue());
+  }
+  if (handle->IsString()) {
+    return String(handle->ToString());
+  }
+  if (handle->IsDate()) {
+    return Date((v8::Handle<v8::Date>)v8::Date::Cast(*handle));
+  }
+  if (handle->IsObject()) {
+    return Object(handle->ToObject());
+  }
+  return Ref<v8::Value>::operator VALUE();
+}
+
+Value::operator v8::Handle<v8::Value>() const {
+    if (rb_equal(value,Empty)) {
+      return v8::Handle<v8::Value>();
+    }
+    switch (TYPE(value)) {
+    case T_FIXNUM:
+      return v8::Integer::New(NUM2INT(value));
+    case T_FLOAT:
+      return v8::Number::New(NUM2DBL(value));
+    case T_STRING:
+      return v8::String::New(RSTRING_PTR(value), (int)RSTRING_LEN(value));
+    case T_NIL:
+      return v8::Null();
+    case T_TRUE:
+      return v8::True();
+    case T_FALSE:
+      return v8::False();
+    case T_DATA:
+      return Ref<v8::Value>::operator v8::Handle<v8::Value>();
+    case T_OBJECT:
+    case T_CLASS:
+    case T_ICLASS:
+    case T_MODULE:
+    case T_REGEXP:
+    case T_MATCH:
+    case T_ARRAY:
+    case T_HASH:
+    case T_STRUCT:
+    case T_BIGNUM:
+    case T_FILE:
+    case T_SYMBOL:
+    case T_UNDEF:
+    case T_NODE:
+    default:
+      rb_warn("unknown conversion to V8 for: %s", RSTRING_PTR(rb_inspect(value)));
+      return v8::String::New("Undefined Conversion");
+    }
+
+    return v8::Undefined();
+}
+}

data/lib/therubyracer.rb

@@ -0,0 +1 @@
+require "v8"

data/lib/v8/access/indices.rb

@@ -0,0 +1,40 @@
+class V8::Access
+  module Indices
+
+    def indices(obj)
+      obj.respond_to?(:length) ? (0..obj.length).to_a : []
+    end
+
+    def iget(obj, index, &dontintercept)
+      if obj.respond_to?(:[])
+        obj.send(:[], index, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def iset(obj, index, value, &dontintercept)
+      if obj.respond_to?(:[]=)
+        obj.send(:[]=, index, value, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def iquery(obj, index, attributes, &dontintercept)
+      if obj.respond_to?(:[])
+        attributes.dont_delete
+        unless obj.respond_to?(:[]=)
+          attributes.read_only
+        end
+      else
+        yield
+      end
+    end
+
+    def idelete(obj, index, &dontintercept)
+      yield
+    end
+
+  end
+end

data/lib/v8/access/invocation.rb

@@ -0,0 +1,47 @@
+class V8::Access
+  module Invocation
+    def methodcall(code, this, args)
+      code.methodcall this, args
+    end
+
+    module Aritize
+      def aritize(args)
+        arity < 0 ? args : Array.new(arity).to_enum(:each_with_index).map {|item, i| args[i]}
+      end
+    end
+
+    module Proc
+      include Aritize
+      def methodcall(this, args)
+        call *aritize([this].concat(args))
+      end
+      ::Proc.send :include, self
+    end
+
+    module Method
+      include Aritize
+      def methodcall(this, args)
+        context = V8::Context.current
+        access = context.access
+        if this.equal? self.receiver
+          call *aritize(args)
+        elsif this.class <= self.receiver.class
+          access.methodcall(unbind, this, args)
+        elsif this.equal? context.scope
+          call *aritize(args)
+        else
+          fail TypeError, "cannot invoke #{self} on #{this}"
+        end
+      end
+      ::Method.send :include, self
+    end
+
+    module UnboundMethod
+      def methodcall(this, args)
+        access = V8::Context.current.access
+        access.methodcall bind(this), this, args
+      end
+      ::UnboundMethod.send :include, self
+    end
+  end
+end

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/access.rb

@@ -0,0 +1,5 @@
+class V8::Access
+  include Names
+  include Indices
+  include Invocation
+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

@@ -0,0 +1,258 @@
+# -*- coding: utf-8 -*-
+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
+
+    # @!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
+
+    # @!attribute [r] timeout
+    #   @return [Number] maximum execution time in milliseconds for scripts executed in this context
+    attr_reader :timeout
+
+    # 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
+    #
+    # If passed the `:timeout` option, every eval will timeout once
+    #   N milliseconds elapse
+    #
+    # @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
+      @timeout = options[:timeout]
+      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
+        V8::C::Locker() do
+          @native = V8::C::Context::New()
+        end
+      end
+      yield self if block_given?
+    end
+
+    # 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
+      enter do
+        script = try { V8::C::Script::New(source.to_s, filename.to_s) }
+        if @timeout
+          to_ruby try {script.RunWithTimeout(@timeout)}
+        else
+          to_ruby try {script.Run()}
+        end
+      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)
+      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)
+      enter do
+        @native.Global().Set(to_v8(key), to_v8(value))
+      end
+      return value
+    end
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # Indicates if this context is the currently entered context
+    #
+    # @return true if this context is currently entered
+    def entered?
+      Context.current == self
+    end
+
+    # 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
+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