therubyracer 0.7.1 → 0.7.2.pre

data/ext/v8/convert_v8.cpp

@@ -1,9 +0,0 @@
-#include "convert_v8.h"
-
-V8LocalDest::V8LocalDest() {
-    
-}
-
-V8LocalDest::~V8LocalDest() {
-    
-}

data/ext/v8/convert_v8.h

@@ -1,124 +0,0 @@
-#ifndef __convert_v8_h__
-#define __convert_v8_h__
-
-#include <v8.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string>
-
-template<class T, class R> class V8HandleSource {
-
-  T dest;
-
- public:
-
-  V8HandleSource() {}
-  ~V8HandleSource() {}
-
-  bool operator() (v8::Handle<v8::Value>& value, R& result) {
-
-    // a bit klunky, but alternative is to evaluate what type the
-    // object is twice, which is unappealing
-    
-    if (value.IsEmpty()) {
-      result = dest.pushNull();
-      return true;
-    }
-
-    if (value->IsUndefined()) {
-      result = dest.pushNull();
-      return true;
-    }
-
-    if(value->IsNull()) {
-      result = dest.pushNull();
-      return true;
-    }
-    
-    if(value->IsTrue()) {
-      result = dest.pushBool(true);
-      return true;
-    }
-
-    if(value->IsFalse()) {
-      result = dest.pushBool(false);
-      return true;
-    }
-
-    if(value->IsString()) {
-      v8::Local<v8::String> str = value->ToString();
-      result = convertString(str);
-      return true;
-    }
-
-    if(value->IsInt32()) {
-      result = dest.pushInt(value->Int32Value());
-      return true;
-    }
-
-    if(value->IsNumber()) {
-      result = dest.pushDouble(value->NumberValue());
-      return true;
-    }
-    
-    result = dest.pushNull();
-    return false;
-  }
-
-  R convertString(v8::Local<v8::String>& str) {
-    char buffer[1024];
-    int total = 0;
-    int remaining = str->Length();
-    std::string output;
-    while (remaining > 0) {
-      int toCopy = remaining > sizeof(buffer) ? sizeof(buffer) : remaining;
-      str->WriteAscii(buffer, total, toCopy);
-      output.append(buffer, toCopy);
-      total += toCopy;
-      remaining -= toCopy;
-    }
-    return dest.pushString(output);    
-  }
-
-
-};
-
-/**
- * StringDest is a data type conversion destination that converts
- * any argument into a string.  It should have all methods listed
- * in data_conversion.txt so it can be used as a template argument
- * for a conversion source class.
- */
-class V8LocalDest {
-
-public:
-    V8LocalDest();
-    ~V8LocalDest();
-
-    v8::Local<v8::Value> pushString(const std::string& value) {
-        return v8::Local<v8::Value>::New(v8::String::New(value.c_str()));
-    }
-
-    v8::Local<v8::Value> pushInt(int64_t value) {
-        return v8::Local<v8::Value>::New(v8::Integer::New(value));
-    }
-
-    v8::Local<v8::Value> pushDouble(double value) {
-        return v8::Local<v8::Value>::New(v8::Number::New(value));
-    }
-
-    v8::Local<v8::Value> pushBool(bool value) {
-        return v8::Local<v8::Value>::New(v8::Boolean::New(value));
-    }
-
-    v8::Local<v8::Value> pushNull() {
-      return v8::Local<v8::Value>::New(v8::Null());
-    }
-    
-    v8::Local<v8::Value> pushUndefined() {
-      return v8::Local<v8::Value>::New(v8::Undefined());
-    }
-};
-
-
-#endif

data/ext/v8/converters.cpp

@@ -1,84 +0,0 @@
-#include "converters.h"
-#include "callbacks.h"
-#include "v8_ref.h"
-#include "v8_obj.h"
-#include "v8_cxt.h"
-#include "v8_func.h"
-#include "v8_template.h"
-#include "v8_external.h"
-
-using namespace v8;
-
-namespace {
-  std::string UNDEFINED_STR("undefined");
-}
-
-VALUE V82RB(Handle<Value>& value) {
-  convert_v8_to_rb_t convert;
-  VALUE result;
-  VALUE type = rr_cV8_C_Object;
-  if(convert(value, result)) {
-    return result;
-  }
-  
-  if (value->IsArray()) {  
-    Local<Array> array(Array::Cast(*value));
-    VALUE rb_array = rb_ary_new2(array->Length());
-    for (unsigned int i = 0; i < array->Length(); i++) {
-      Local<Value> value = array->Get(Integer::New(i));
-      rb_ary_push(rb_array, V82RB(value));
-    }
-    return rb_array;
-  }
-  
-  if (value->IsFunction()) {
-    type = rr_cV8_C_Function;
-  }
-
-  if (value->IsObject()) {
-    Local<Object> object(Object::Cast(*value));
-    Local<Value> peer = object->GetHiddenValue(String::New("TheRubyRacer::RubyObject"));
-    if (peer.IsEmpty()) {
-      VALUE context_ref = V8_Ref_Create(V8_C_Context, Context::GetEntered());
-      object->SetHiddenValue(String::New("TheRubyRacer::Context"), rr_v8_external_create(context_ref));
-      return V8_Ref_Create(type, value, context_ref);
-    } else {      
-      return (VALUE)External::Unwrap(peer);
-    }
-  }
-  return Qnil;
-}
-
-Local<Value> RB2V8(VALUE value) {  
-  VALUE valueClass = rb_class_of(value);
-  if(valueClass == rb_cProc || valueClass == rb_cMethod) {
-    Local<FunctionTemplate> t = FunctionTemplate::New(RacerRubyInvocationCallback, rr_v8_external_create(value));
-    return t->GetFunction();  
-  }
-  convert_rb_to_v8_t convert;
-  Local<Value> result;
-  if (convert(value, result)) {
-    return result;
-  }
-  Local<Object> o = Racer_Create_V8_ObjectTemplate(value)->NewInstance();
-  o->SetHiddenValue(String::New("TheRubyRacer::RubyObject"), rr_v8_external_create(value));
-  return o;
-}
-
-std::string V82String(Handle<Value>& value) {
-  convert_v8_to_string_t convert;
-  std::string result;
-  if(convert(value, result)) {
-    return result;
-  }
-  
-  if (value->IsObject()) {
-    Local<Object> object(Object::Cast(*value));
-    Local<String> str = object->ToString();
-    if(convert(value, result)) {
-      return result;
-    }
-  }  
-  
-  return UNDEFINED_STR;
-}

data/ext/v8/converters.h

@@ -1,21 +0,0 @@
-#ifndef __converters_h__
-#define __converters_h__
-
-#include "convert_ruby.h"
-#include "convert_string.h"
-#include "convert_v8.h"
-#include <cstring>
-
-typedef RubyValueSource<V8LocalDest, v8::Local<v8::Value> > convert_rb_to_v8_t; 
-typedef V8HandleSource<RubyValueDest, VALUE> convert_v8_to_rb_t;
-
-typedef RubyValueSource<StringDest, std::string> convert_rb_to_string_t;
-typedef V8HandleSource<StringDest, std::string> convert_v8_to_string_t;
-
-VALUE V82RB(v8::Handle<v8::Value>& value);
-v8::Local<v8::Value> RB2V8(VALUE value);
-
-std::string RB2String(VALUE value);
-std::string V82String(v8::Handle<v8::Value>& value);
-
-#endif

data/lib/v8/callbacks.rb

@@ -1,88 +0,0 @@
-
-module V8
-  module C
-    class MethodInfo
-      
-      attr_reader :perl_methods, :camel_methods
-      
-      def initialize(object)
-        @object = object
-        @methods = Set.new
-        for name in object.public_methods(false) do
-          @methods << name.to_s
-        end
-      end
-      
-      def find(name)
-        for format in [name, To.perl_case(name), To.camel_case(name)]
-          return @object.method(format) if @methods.include?(format)
-        end
-      end
-    end
-  end
-  
-  class NamedPropertyGetter
-    def self.call(property, info)
-      methods = MethodInfo(To.rb(info.This()))
-      
-      if method = methods.find(To.rb(property))
-        if method.arity == 0
-          To.v8(method.call)
-        else
-          To.v8(method)
-        end
-      else
-        C::Empty
-      end
-
-    #   method_name = if methods.include?(name)
-    #     name
-    #   elsif methods.include?(perl_name)
-    #     perl_name
-    #   end
-    #   if method_name
-    #     method = obj.method(method_name)
-    #     if method.arity == 0
-    #       To.v8(method.call())
-    #     else
-    #       To.v8(method)
-    #     end
-    #   else
-    #     C::Empty
-    #   end
-    # end
-  end
-
-  class NamedPropertySetter
-    def self.call(property, value, info)
-      obj = To.rb(info.This())
-      setter = To.rb(property) + "="
-      camel_name = To.camel_case(setter)
-      perl_name = To.perl_case(setter)
-      methods = obj.public_methods(false).map(&:to_s)
-      if methods.include?(perl_name)
-        obj.send(perl_name, To.rb(value))
-      elsif methods.include?(camel_name)
-        obj.send(camel_name, To.rb(value))
-      else
-         C::Empty
-      end
-    end
-  end
-  
-  class NamedPropertyEnumerator
-    def self.call(info)
-      obj = To.rb(info.This())
-      camel_methods = obj.public_methods(false).inject(Set.new) do |set, name|
-        set.tap do
-          set << To.camel_case(name)
-        end
-      end
-      names = V8::C::Array::New(camel_methods.length)
-      camel_methods.each_with_index do |name, i|
-        names.Set(i, C::String::New(name))
-      end
-      return names
-    end
-  end
-end