step 2: make templated converters handle simple things only, and have complicated conversions occur in the converter functions.

ext/v8/convert_ruby.h

@@ -2,9 +2,6 @@
 #define __convert_ruby_h__
 
 #include <ruby.h>
-#include <v8.h>
-#include "v8_ref.h"
-#include "v8_obj.h"
 #include <string>
 
 /**
@@ -44,16 +41,6 @@ template<class DEST, class RET> class RubyValueSource {
           return dest.pushBool(true);
         case T_FALSE:
           return dest.pushBool(false);
-        case T_DATA:
-/*
-            VALUE clsProc = rb_eval_string("::Proc");
-            VALUE clsMethod = rb_eval_string("::Method");
-            VALUE smartMatch = rb_intern("===");
-            if (RTEST(rb_funcall(clsProc, smartMatch, value)) || RTEST(rb_funcall(clsMethod, smartMatch, value))) {
-          
-            }
-*/
-            break;
         }
         return dest.pushUndefined();
     }
@@ -99,10 +86,6 @@ class RubyValueDest {
     VALUE pushUndefined() {
         return Qnil;
     }
-    
-    VALUE pushObject(v8::Handle<v8::Object>& value) {
-      return V8_Ref_Create(V8_C_Object, value);
-    }
 };
 
 

ext/v8/convert_string.h

@@ -57,10 +57,6 @@ public:
         return "undefined"; // this too
     }
 
-    std::string pushObject(v8::Local<v8::Object>& foo) {
-      return "";
-    }
-
 private:
 
     /**

ext/v8/convert_v8.h

@@ -15,57 +15,69 @@ template<class T, class R> class V8HandleSource {
   V8HandleSource() {}
   ~V8HandleSource() {}
 
-  R operator() (v8::Handle<v8::Value>& value) {
+  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()) {
-      return dest.pushNull();
+      result = dest.pushNull();
+      return true;
     }
 
     if (value->IsUndefined()) {
-      return dest.pushNull();
+      result = dest.pushNull();
+      return true;
     }
 
     if(value->IsNull()) {
-      return dest.pushNull();
+      result = dest.pushNull();
+      return true;
     }
     
     if(value->IsTrue()) {
-      return dest.pushBool(true);
+      result = dest.pushBool(true);
+      return true;
     }
 
     if(value->IsFalse()) {
-      return dest.pushBool(false);
+      result = dest.pushBool(false);
+      return true;
     }
 
     if(value->IsString()) {
       v8::Local<v8::String> str = value->ToString();
-      char buffer[1024];
-      int strlen = str->Length();
-      std::string output(strlen, 0);
-      for (int total = 0; total < strlen;) {
-        int written = str->WriteAscii(buffer, total, 1024);
-        output.replace(total, written, buffer);
-        total += written;
-      }
-      return dest.pushString(output);
+      result = convertString(str);
+      return true;
     }
 
     if(value->IsInt32()) {
-      return dest.pushInt(value->Int32Value());
+      result = dest.pushInt(value->Int32Value());
+      return true;
     }
 
     if(value->IsNumber()) {
-      return dest.pushDouble(value->NumberValue());
+      result = dest.pushDouble(value->NumberValue());
+      return true;
     }
     
-    if (value->IsObject()) {
-      v8::Local<v8::Object> object(v8::Object::Cast(*value));
-      return dest.pushObject(object);
-    }
-    
-    return dest.pushNull();
+    result = dest.pushNull();
+    return false;
   }
 
+  R convertString(v8::Local<v8::String>& str) {
+    char buffer[1024];
+    int strlen = str->Length();
+    std::string output(strlen, 0);
+    for (int total = 0; total < strlen;) {
+      int written = str->WriteAscii(buffer, total, 1024);
+      output.replace(total, written, buffer);
+      total += written;
+    }
+    return dest.pushString(output);    
+  }
+
+
 };
 
 /**
@@ -103,10 +115,6 @@ public:
     v8::Local<v8::Value> pushUndefined() {
       return v8::Local<v8::Value>::New(v8::Undefined());
     }
-    
-    // v8:Local<v8:Value> pushFunction(Function) {
-    //   
-    // }
 };
 
 

ext/v8/converters.cpp

@@ -1,8 +1,25 @@
 #include "converters.h"
 
+#include "v8_ref.h"
+#include "v8_obj.h"
+
+namespace {
+  std::string UNDEFINED_STR("undefined");
+}
+
 VALUE V82RB(v8::Handle<v8::Value>& value) {
   convert_v8_to_rb_t convert;
-  return convert(value);
+  VALUE result;
+  if(convert(value, result)) {
+    return result;
+  }
+  
+  if (value->IsObject()) {
+    v8::Local<v8::Object> object(v8::Object::Cast(*value));
+    return V8_Ref_Create(V8_C_Object, value);
+  }
+  
+  return Qnil;
 }
 
 v8::Local<v8::Value> RB2V8(VALUE value) {
@@ -17,5 +34,18 @@ std::string RB2String(VALUE value) {
 
 std::string V82String(v8::Handle<v8::Value>& value) {
   convert_v8_to_string_t convert;
-  return convert(value);
+  std::string result;
+  if(convert(value, result)) {
+    return result;
+  }
+  
+  if (value->IsObject()) {
+    v8::Local<v8::Object> object(v8::Object::Cast(*value));
+    v8::Local<v8::String> str = object->ToString();
+    if(convert(value, result)) {
+      return result;
+    }
+  }  
+  
+  return UNDEFINED_STR;
 }

ext/v8/v8_script.cpp

@@ -16,5 +16,5 @@ VALUE v8_script_Run(VALUE self) {
   HandleScope handles;
   Local<Script> script = V8_Ref_Get<Script>(self);
   Local<Value> result = script->Run();
-  return RB2V8(result);  
+  return V82RB(result);
 }