therubyracer 0.10.2 → 0.11.0beta1

data/ext/v8/v8.cc

@@ -0,0 +1,87 @@
+#include "rr.h"
+
+namespace rr {
+
+void V8::Init() {
+  ClassBuilder("V8").
+    defineSingletonMethod("IdleNotification", &IdleNotification).
+    defineSingletonMethod("SetFlagsFromString", &SetFlagsFromString).
+    defineSingletonMethod("SetFlagsFromCommandLine", &SetFlagsFromCommandLine).
+    defineSingletonMethod("PauseProfiler", &PauseProfiler).
+    defineSingletonMethod("ResumeProfiler", &ResumeProfiler).
+    defineSingletonMethod("IsProfilerPaused", &IsProfilerPaused).
+    defineSingletonMethod("GetCurrentThreadId", &GetCurrentThreadId).
+    defineSingletonMethod("TerminateExecution", &TerminateExecution).
+    defineSingletonMethod("IsExecutionTerminating", &IsExecutionTerminating).
+    defineSingletonMethod("Dispose", &Dispose).
+    defineSingletonMethod("LowMemoryNotification", &LowMemoryNotification).
+    defineSingletonMethod("AdjustAmountOfExternalAllocatedMemory", &AdjustAmountOfExternalAllocatedMemory).
+    defineSingletonMethod("ContextDisposedNotification", &ContextDisposedNotification).
+    defineSingletonMethod("SetCaptureStackTraceForUncaughtExceptions", &SetCaptureStackTraceForUncaughtExceptions).
+    defineSingletonMethod("GetHeapStatistics", &GetHeapStatistics).
+    defineSingletonMethod("GetVersion", &GetVersion);
+}
+
+VALUE V8::IdleNotification(int argc, VALUE argv[], VALUE self) {
+  VALUE hint;
+  rb_scan_args(argc, argv, "01", &hint);
+  if (RTEST(hint)) {
+    return Bool(v8::V8::IdleNotification(NUM2INT(hint)));
+  } else {
+    return Bool(v8::V8::IdleNotification());
+  }
+}
+VALUE V8::SetFlagsFromString(VALUE self, VALUE string) {
+  Void(v8::V8::SetFlagsFromString(RSTRING_PTR(string), (int)RSTRING_LEN(string)));
+}
+VALUE V8::SetFlagsFromCommandLine(VALUE self, VALUE args, VALUE remove_flags) {
+  int argc = RARRAY_LENINT(args);
+  char* argv[argc];
+  for(int i = 0; i < argc; i++) {
+    argv[i] = RSTRING_PTR(rb_ary_entry(args, i));
+  }
+  Void(v8::V8::SetFlagsFromCommandLine(&argc, argv, Bool(remove_flags)));
+}
+VALUE V8::AdjustAmountOfExternalAllocatedMemory(VALUE self, VALUE change_in_bytes) {
+  return SIZET2NUM(v8::V8::AdjustAmountOfExternalAllocatedMemory(NUM2SIZET(change_in_bytes)));
+}
+VALUE V8::PauseProfiler(VALUE self) {
+  Void(v8::V8::PauseProfiler());
+}
+VALUE V8::ResumeProfiler(VALUE self) {
+  Void(v8::V8::ResumeProfiler());
+}
+VALUE V8::IsProfilerPaused(VALUE self) {
+  return Bool(v8::V8::IsProfilerPaused());
+}
+VALUE V8::GetCurrentThreadId(VALUE self) {
+  return INT2FIX(v8::V8::GetCurrentThreadId());
+}
+VALUE V8::TerminateExecution(VALUE self, VALUE thread_id) {
+  Void(v8::V8::TerminateExecution(NUM2INT(thread_id)));
+}
+VALUE V8::IsExecutionTerminating(VALUE self) {
+  return Bool(v8::V8::IsExecutionTerminating());
+}
+VALUE V8::Dispose(VALUE self) {
+  Void(v8::V8::Dispose());
+}
+VALUE V8::LowMemoryNotification(VALUE self) {
+  Void(v8::V8::LowMemoryNotification());
+}
+VALUE V8::ContextDisposedNotification(VALUE self) {
+  return INT2FIX(v8::V8::ContextDisposedNotification());
+}
+VALUE V8::SetCaptureStackTraceForUncaughtExceptions(int argc, VALUE argv[], VALUE self) {
+  VALUE should_capture; VALUE frame_limit; VALUE options;
+  rb_scan_args(argc, argv, "12", &should_capture, &frame_limit, &options);
+  int limit = RTEST(frame_limit) ? NUM2INT(frame_limit) : 10;
+  Void(v8::V8::SetCaptureStackTraceForUncaughtExceptions(Bool(should_capture), limit, Stack::Trace::StackTraceOptions(options)));
+}
+VALUE V8::GetHeapStatistics(VALUE self, VALUE statistics_ptr) {
+  Void(v8::V8::GetHeapStatistics(HeapStatistics(statistics_ptr)));
+}
+VALUE V8::GetVersion(VALUE self) {
+  return rb_str_new2(v8::V8::GetVersion());
+}
+}

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

@@ -1,23 +1,31 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require "v8/version"
 
-module V8
-  require 'v8/version'
-  require 'v8/v8' #native glue
-  require 'v8/c/locker'
-  require 'v8/portal'
-  require 'v8/portal/caller'
-  require 'v8/portal/proxies'
-  require 'v8/portal/templates'
-  require 'v8/portal/function'
-  require 'v8/portal/constructor'
-  require 'v8/portal/interceptors'
-  require 'v8/context'
-  require 'v8/object'
-  require 'v8/array'
-  require 'v8/function'
-  require 'v8/tap'
-  require 'v8/access'
-  require 'v8/error'
-  require 'v8/stack'
-end
+require 'ref'
+require 'v8/init'
+require 'v8/util/weakcell'
+require 'v8/error'
+require 'v8/error/protect'
+require 'v8/error/try'
+require 'v8/conversion/fundamental'
+require 'v8/conversion/indentity'
+require 'v8/conversion/reference'
+require 'v8/conversion/primitive'
+require 'v8/conversion/code'
+require 'v8/conversion/class'
+require 'v8/conversion/object'
+require 'v8/conversion/time'
+require 'v8/conversion/hash'
+require 'v8/conversion/array'
+require 'v8/conversion/proc'
+require 'v8/conversion/method'
+require 'v8/conversion/symbol'
+require 'v8/conversion/string'
+require 'v8/conversion'
+require 'v8/access/names'
+require 'v8/access/indices'
+require 'v8/access/invocation'
+require 'v8/access'
+require 'v8/context'
+require 'v8/object'
+require 'v8/array'
+require 'v8/function'

data/lib/v8/access.rb

@@ -1,87 +1,5 @@
-require 'set'
-module V8
-  class Access
-    def get(obj, name, &dontintercept)
-      methods = accessible_methods(obj)
-      if methods.include?(name)
-        method = obj.method(name)
-        method.arity == 0 ? method.call : method.unbind
-      elsif obj.respond_to?(:[])
-        obj.send(:[], name, &dontintercept)
-      else
-        yield
-      end
-    end
-
-    def iget(obj, index, &dontintercept)
-      if obj.respond_to?(:[])
-        obj.send(:[], index, &dontintercept)
-      else
-        yield
-      end
-    end
-
-    def set(obj, name, value, &dontintercept)
-      setter = name + "="
-      methods = accessible_methods(obj, true)
-      if methods.include?(setter)
-        obj.send(setter, value)
-      elsif obj.respond_to?(:[]=)
-        obj.send(:[]=, name, value, &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 query(obj, name, attributes)
-      if obj.respond_to?(name)
-        attributes.dont_delete
-        unless obj.respond_to?(name + "=")
-          attributes.read_only
-        end
-      else
-        yield
-      end
-    end
-
-    def iquery(obj, index, attributes)
-      if obj.respond_to?(:[])
-        attributes.dont_delete
-        unless obj.respond_to?(:[]=)
-          attributes.read_only
-        end
-      else
-        yield
-      end
-    end
-
-    def names(obj)
-      accessible_methods(obj)
-    end
-
-    def indices(obj)
-      obj.respond_to?(:length) ? (0..obj.length).to_a : yield
-    end
-
-    private
-
-    def accessible_methods(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! {|m| m == "[]" || m == "[]=" || m =~ /=$/} unless special_methods
-      end
-    end
-  end
-end 
+class V8::Access
+  include Names
+  include Indices
+  include Invocation
+end