therubyracer-st 0.11.0beta5-x86-mingw32

data/lib/v8/conversion/code.rb

@@ -0,0 +1,38 @@
+class V8::Conversion
+  module Code
+    include V8::Util::Weakcell
+
+    def to_v8
+      fn = to_template.GetFunction()
+      V8::Context.link self, fn
+      return fn
+    end
+
+    def to_template
+      weakcell(:template) {V8::C::FunctionTemplate::New(InvocationHandler.new(self))}
+    end
+
+    class InvocationHandler
+      include V8::Error::Protect
+
+      def initialize(code)
+        @code = code
+      end
+
+      def call(arguments)
+        protect do
+          context = V8::Context.current
+          access = context.access
+          args = ::Array.new(arguments.Length())
+          0.upto(args.length - 1) do |i|
+            if i < args.length
+              args[i] = context.to_ruby arguments[i]
+            end
+          end
+          this = context.to_ruby arguments.This()
+          context.to_v8 access.methodcall(@code, this, args)
+        end
+      end
+    end
+  end
+end

data/lib/v8/conversion/fundamental.rb

@@ -0,0 +1,11 @@
+class V8::Conversion
+  module Fundamental
+    def to_ruby(v8_object)
+      v8_object.to_ruby
+    end
+
+    def to_v8(ruby_object)
+      ruby_object.to_v8
+    end
+  end
+end

data/lib/v8/conversion/hash.rb

@@ -0,0 +1,11 @@
+class V8::Conversion
+  module Hash
+    def to_v8
+      object = V8::Object.new
+      each do |key, value|
+        object[key] = value
+      end
+      return object.to_v8
+    end
+  end
+end

data/lib/v8/conversion/indentity.rb

@@ -0,0 +1,31 @@
+require 'ref'
+
+class V8::Conversion
+  module Identity
+    def to_ruby(v8_object)
+      if v8_object.class <= V8::C::Object
+        v8_idmap[v8_object.GetIdentityHash()] || super(v8_object)
+      else
+        super(v8_object)
+      end
+    end
+
+    def to_v8(ruby_object)
+      return super(ruby_object) if ruby_object.is_a?(String) || ruby_object.is_a?(Primitive)
+      rb_idmap[ruby_object.object_id] || super(ruby_object)
+    end
+
+    def equate(ruby_object, v8_object)
+      v8_idmap[v8_object.GetIdentityHash()] = ruby_object
+      rb_idmap[ruby_object.object_id] = v8_object
+    end
+
+    def v8_idmap
+      @v8_idmap ||= Ref::WeakValueMap.new
+    end
+
+    def rb_idmap
+      @ruby_idmap ||= Ref::WeakValueMap.new
+    end
+  end
+end

data/lib/v8/conversion/method.rb

@@ -0,0 +1,26 @@
+class V8::Conversion
+  module Method
+    include V8::Conversion::Code
+
+    def to_v8
+      template = @@method_cache[self] ||= to_template
+      template.GetFunction()
+    end
+
+    class MethodCache
+      def initialize
+        @map = Ref::WeakValueMap.new
+      end
+
+      def [](method)
+        @map[method.to_s]
+      end
+
+      def []=(method, template)
+        @map[method.to_s] = template
+      end
+    end
+
+    @@method_cache = MethodCache.new
+  end
+end

data/lib/v8/conversion/object.rb

@@ -0,0 +1,28 @@
+class V8::Conversion
+  module Object
+    def to_v8
+      Reference.construct! self
+    end
+
+    def to_ruby
+      self
+    end
+  end
+
+  module NativeObject
+    def to_ruby
+      wrap = if IsArray()
+        ::V8::Array
+      elsif IsFunction()
+        ::V8::Function
+      else
+        ::V8::Object
+      end
+      wrap.new(self)
+    end
+
+    def to_v8
+      self
+    end
+  end
+end

data/lib/v8/conversion/primitive.rb

@@ -0,0 +1,7 @@
+class V8::Conversion
+  module Primitive
+    def to_v8
+      return self
+    end
+  end
+end

data/lib/v8/conversion/proc.rb

@@ -0,0 +1,5 @@
+class V8::Conversion
+  module Proc
+    include V8::Conversion::Code
+  end
+end

data/lib/v8/conversion/reference.rb

@@ -0,0 +1,16 @@
+class V8::Conversion
+  module Reference
+
+    def self.construct!(object)
+      context = V8::Context.current
+      constructor = context.to_v8(object.class)
+      reference = constructor.NewInstance([V8::C::External::New(object)])
+      return reference
+    end
+
+    def to_v8
+      Reference.construct! self
+    end
+
+  end
+end

data/lib/v8/conversion/string.rb

@@ -0,0 +1,12 @@
+class V8::Conversion
+  module String
+    def to_v8
+      V8::C::String::New(self)
+    end
+  end
+  module NativeString
+    def to_ruby
+      self.Utf8Value()
+    end
+  end
+end

data/lib/v8/conversion/symbol.rb

@@ -0,0 +1,7 @@
+class V8::Conversion
+  module Symbol
+    def to_v8
+      V8::C::String::NewSymbol(to_s)
+    end
+  end
+end

data/lib/v8/conversion/time.rb

@@ -0,0 +1,13 @@
+class V8::Conversion
+  module Time
+    def to_v8
+      V8::C::Date::New(to_f * 1000)
+    end
+  end
+
+  module NativeDate
+    def to_ruby
+      ::Time.at(self.NumberValue() / 1000)
+    end
+  end
+end

data/lib/v8/error.rb

@@ -0,0 +1,25 @@
+module V8
+  class Error < StandardError
+    attr_reader :value
+    def initialize(message, value)
+      super(message)
+      @value = value
+    end
+  end
+  const_set :JSError, Error
+
+  def self.Error(exception)
+    value = exception.to_ruby
+    if !exception.kind_of?(V8::C::Value)
+      raise V8::Error.new(exception.to_s, value)
+    elsif exception.IsNativeError()
+      if football = exception.GetHiddenValue("rr::Football")
+        raise football.Value()
+      else
+        raise V8::Error.new(exception.Get("message").to_ruby, value)
+      end
+    else
+      raise V8::Error.new(exception.ToString().to_ruby, value)
+    end
+  end
+end

data/lib/v8/error/protect.rb

@@ -0,0 +1,20 @@
+class V8::Error
+  module Protect
+    def protect
+      yield
+    rescue Football => e
+      e.kickoff!
+    rescue Exception => e
+      e.extend Football
+      e.kickoff!
+    end
+  end
+
+  module Football
+    def kickoff!
+      error = V8::C::Exception::Error(message)
+      error.SetHiddenValue("rr::Football", V8::C::External::New(self))
+      V8::C::ThrowException(error)
+    end
+  end
+end

data/lib/v8/error/try.rb

@@ -0,0 +1,15 @@
+class V8::Error
+  module Try
+    def try
+      context = V8::Context.current
+      V8::C::TryCatch() do |trycatch|
+        result = yield
+        if trycatch.HasCaught()
+          V8::Error(trycatch.Exception())
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/v8/function.rb

@@ -0,0 +1,28 @@
+class V8::Function < V8::Object
+  include V8::Error::Try
+
+  def initialize(native = nil)
+    super do
+      native || V8::C::FunctionTemplate::New().GetFunction()
+    end
+  end
+
+  def methodcall(this, *args)
+    @context.enter do
+      this ||= @context.native.Global()
+      @context.to_ruby try {native.Call(@context.to_v8(this), args.map {|a| @context.to_v8 a})}
+    end
+  end
+
+  def call(*args)
+    @context.enter do
+      methodcall @context.native.Global(), *args
+    end
+  end
+
+  def new(*args)
+    @context.enter do
+      @context.to_ruby try {native.NewInstance(args.map {|a| @context.to_v8 a})}
+    end
+  end
+end

data/lib/v8/helper.rb

@@ -0,0 +1,30 @@
+module V8
+  module_function
+
+  def find_file(name, where)
+    where.split(File::PATH_SEPARATOR).each do |path|
+    file = File.join(path, name)
+    return file if File.exist? file
+    end
+    false
+  end
+
+  def v8_path
+    begin
+      require 'libv8'
+      return Libv8.libv8_source_path
+    rescue LoadError
+    end
+
+    v8_path = find_file("libv8.a", ENV['PATH'])
+    File.dirname v8_path if v8_path
+  end
+
+  def darwin?
+    RUBY_PLATFORM =~ /darwin/
+  end
+
+  def mingw?
+    RUBY_PLATFORM =~ /mingw/
+  end
+end

data/lib/v8/object.rb

@@ -0,0 +1,79 @@
+class V8::Object
+  include Enumerable
+  attr_reader :native
+  alias_method :to_v8, :native
+
+  def initialize(native = nil)
+    @context = V8::Context.current or fail "tried to initialize a #{self.class} without being in an entered V8::Context"
+    @native = block_given? ? yield : native || V8::C::Object::New()
+    @context.link self, @native
+  end
+
+  def [](key)
+    @context.enter do
+      @context.to_ruby @native.Get(@context.to_v8(key))
+    end
+  end
+
+  def []=(key, value)
+    @context.enter do
+      @native.Set(@context.to_v8(key), @context.to_v8(value))
+    end
+    return value
+  end
+
+  def keys
+    @context.enter do
+      names = @native.GetPropertyNames()
+      0.upto( names.Length() - 1).to_enum.map {|i| @context.to_ruby names.Get(i)}
+    end
+  end
+
+  def values
+    @context.enter do
+      names = @native.GetPropertyNames()
+      0.upto( names.Length() - 1).to_enum.map {|i| @context.to_ruby @native.Get(names.Get(i))}
+    end
+  end
+
+  def each
+    @context.enter do
+      names = @native.GetPropertyNames()
+      0.upto(names.Length() - 1) do |i|
+        name = names.Get(i)
+        yield @context.to_ruby(name), @context.to_ruby(@native.Get(name))
+      end
+    end
+  end
+
+  def to_s
+    @context.enter do
+      @context.to_ruby @native.ToString()
+    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

data/lib/v8/util/weakcell.rb

@@ -0,0 +1,29 @@
+module V8
+  module Util
+    module Weakcell
+      def weakcell(name, &block)
+        unless storage = instance_variable_get("@#{name}")
+          storage = instance_variable_set("@#{name}", Storage.new)
+        end
+        storage.access(&block)
+      end
+      class Storage
+        def access(&block)
+          if @ref
+            @ref.object || populate(block)
+          else
+            populate(block)
+          end
+        end
+
+        private
+
+        def populate(block)
+          occupant = block.call()
+          @ref = Ref::WeakReference.new(occupant)
+          return occupant
+        end
+      end
+    end
+  end
+end