gtk-webkit-ruby 0.0.3 → 0.0.4

data/Rakefile

@@ -22,10 +22,10 @@ spec = Gem::Specification.new do |s|
 	s.name = "gtk-webkit-ruby"
 	s.author = "Geoff Youngs"
 	s.email = "git@intersect-uk.co.uk"
-	s.version = "0.0.3"
+	s.version = "0.0.4"
 	s.homepage = "http://github.com/geoffyoungs/gtk-webkit-ruby"
 	s.summary = "Webkit bindings using rubber-generate"
-	s.add_dependency("rubber-generate", ">= 0.0.12")
+	s.add_dependency("rubber-generate", ">= 0.0.17")
 	s.platform = Gem::Platform::RUBY
 	s.extensions = FileList["ext/*/extconf.rb"]
 	s.files = FileList['ext/*/*.{c,h,cr,rd}'] + ['Rakefile', 'README.md']

data/ext/webkit/extconf.rb

@@ -1,9 +1,46 @@
 require 'mkmf'
-require 'mkmf-gnome2'
+use_gems = false
+begin
+  require 'mkmf-gnome2'
+rescue LoadError
+  use_gems = true
+end
+
+if use_gems or Object.const_defined?('Gem')
+  require 'rubygems'
+  gem 'glib2'
+  require 'mkmf-gnome2'
+  %w[rbglib.h rbgtk.h rbpango.h rbatk.h].each do |header|
+  	Gem.find_files(header).each do |f|
+		$CFLAGS += " '-I#{File.dirname(f)}'"
+	end
+  end
+end
+  %w[
+ glib2 gdk_pixbuf2 atk gtk2].each do |package|
+  require package
+  $CFLAGS += " -I"+Gem.loaded_specs[package].full_gem_path+"/ext/"+package
+end
+if RbConfig::CONFIG.has_key?('rubyhdrdir')
+$CFLAGS += " -I" + RbConfig::CONFIG['rubyhdrdir']+'/ruby'
+end
+
+have_func("rb_errinfo")
 PKGConfig.have_package("gtk+-2.0") or exit(-1)
 PKGConfig.have_package("webkit-1.0") or exit(-1)
+have_header("dlfcn.h") or exit(-1)
+have_header("errno.h") or exit(-1)
+have_header("ffi.h") or exit(-1)
+have_header("rbgobject.h") or exit(-1)
+have_header("sys/mman.h") or exit(-1)
+have_header("intern.h") or exit(-1)
 have_header("webkit/webkit.h") or exit(-1)
+have_header("webkit/webkitenumtypes.h") or exit(-1)
 have_header("JavaScriptCore/JavaScript.h") or exit(-1)
+have_library("dl") or exit(-1)
+$LIBS += " -ldl"
+have_library("ffi") or exit(-1)
+$LIBS += " -lffi"
 
 STDOUT.print("checking for new allocation framework... ") # for ruby-1.7
 if Object.respond_to? :allocate

data/ext/webkit/javascript-type-convert.h

@@ -0,0 +1,152 @@
+static JSValueRef
+convert_string_to_jsval(JSContextRef ctx, char *str) {
+  JSStringRef js_s_ref;
+  JSValueRef js_val_ref;
+
+  js_s_ref  = JSStringCreateWithUTF8CString(str);
+  js_val_ref = JSValueMakeString(ctx, js_s_ref);
+  JSStringRelease(js_s_ref);
+
+  return js_val_ref;
+}
+
+static char *jsstrref_to_charp(JSStringRef str, size_t *out_len)
+{
+  size_t max = 0, len;
+  char *buf;
+
+  max = JSStringGetMaximumUTF8CStringSize(str);
+  buf = malloc(max);
+  len = JSStringGetUTF8CString(str, buf, max);
+
+  if (out_len) {
+    *out_len = len;
+  }
+
+  return buf;
+}
+
+static char *
+convert_javascript_to_utf8_string(JSContextRef ctx, JSValueRef val, size_t* out_len)
+{
+  JSStringRef str = JSValueToStringCopy(ctx, val, NULL);
+  char *buf;
+
+  buf = jsstrref_to_charp(str, out_len);
+
+  JSStringRelease(str);
+
+  return buf;
+}
+
+static ID
+convert_javascript_to_intern(JSStringRef str)
+{
+  ID id;
+  size_t max = 0, len;
+  char *buf;
+
+  max = JSStringGetMaximumUTF8CStringSize(str);
+  buf = malloc(max);
+  len = JSStringGetUTF8CString(str, buf, max);
+  buf[len-1] = 0;
+  id = rb_intern(buf);
+
+  free(buf);
+
+  return id;
+}
+
+static inline VALUE conv_jsstrref_to_value(JSStringRef str)
+{
+  VALUE       output = Qnil;
+  size_t      len = 0, max = 0;
+  char     *buf;
+
+  max = JSStringGetMaximumUTF8CStringSize(str);
+  buf = malloc(max);
+  len = JSStringGetUTF8CString(str, buf, max);
+
+  output = rb_str_new(buf, len-1); // Ignore terminator
+
+  free(buf);
+
+  return output;
+
+}
+
+static inline VALUE
+convert_javascript_string_to_ruby(JSContextRef ctx, JSValueRef val)
+{
+  VALUE       output = Qnil;
+  JSStringRef str;
+
+  str = JSValueToStringCopy(ctx, val, NULL);
+
+  output = conv_jsstrref_to_value(str);
+
+  JSStringRelease(str);
+
+  return output;
+}
+
+static VALUE
+convert_javascript_to_ruby(JSContextRef ctx, JSValueRef val)
+{
+  VALUE output = Qnil;
+  JSValueRef *_exception = NULL;
+
+  switch (JSValueGetType(ctx, val)) {
+    case kJSTypeUndefined:
+    case kJSTypeNull:
+      output = Qnil;
+      break;
+    case kJSTypeBoolean:
+      output = JSValueToBoolean(ctx, val) ? Qtrue : Qfalse;
+      break;
+    case kJSTypeNumber:
+        output = rb_float_new(JSValueToNumber(ctx, val, _exception));
+      break;
+    case kJSTypeString:
+      output = convert_javascript_string_to_ruby(ctx, val);
+      break;
+    case kJSTypeObject:
+      output = convert_javascript_string_to_ruby(ctx, val);
+      break;
+  }
+
+  return output;
+}
+
+
+static JSValueRef
+convert_ruby_to_javascript(JSContextRef ctx, VALUE value)
+{
+  JSStringRef str;
+  JSValueRef jsval;
+
+  switch (TYPE(value)) {
+    case T_FIXNUM:
+      return JSValueMakeNumber(ctx, (double) FIX2LONG(value));
+    case T_FLOAT:
+      return JSValueMakeNumber(ctx, (double) NUM2DBL(value));
+    case T_BIGNUM:
+      return JSValueMakeNumber(ctx, (double) rb_big2long(value));
+    case T_TRUE:
+    case T_FALSE:
+      return JSValueMakeBoolean(ctx, RTEST(value));
+    case T_UNDEF:
+      return JSValueMakeUndefined(ctx);
+    case T_NIL:
+      return JSValueMakeNull(ctx);
+    default:
+      if (TYPE(value) != T_STRING) {
+        value = rb_funcall(value, rb_intern("to_s"), 0);
+      }
+      str   = JSStringCreateWithUTF8CString(RSTRING_PTR(value));
+      jsval = JSValueMakeString(ctx, str);
+      JSStringRelease(str);
+      return jsval;
+  }
+}
+

data/ext/webkit/javascript.h

@@ -1,9 +1,19 @@
 #include <alloca.h>
+#include "javascript-type-convert.h"
 
 #define STRINGIZE(s) #s
 
 #define JS_fn(f) _JS_fn(ctx, STRINGIZE(f), f)
 
+
+typedef struct {
+	JSClassDefinition definition;
+	JSClassRef class_ref;
+	VALUE rbObject;
+	JSContextRef ctx;
+} ruby_js_class_def;
+static ruby_js_class_def *jsrb_newClass(VALUE robject);
+
 JSObjectRef _JS_fn(JSContextRef ctx, const char *name, JSObjectCallAsFunctionCallback f)
 {
     JSStringRef nameStr = JSStringCreateWithUTF8CString(name);
@@ -27,118 +37,6 @@ js_obj_set_value(JSContextRef ctx, JSObjectRef object, char *name, JSObjectRef v
 	return true;
 }
 
-static JSValueRef
-convert_string_to_jsval(JSContextRef ctx, char *str) {
-	JSStringRef js_s_ref;
-	JSValueRef js_val_ref;
-
-	js_s_ref  = JSStringCreateWithUTF8CString(str);
-	js_val_ref = JSValueMakeString(ctx, js_s_ref);
-	JSStringRelease(js_s_ref);
-
-	return js_val_ref;
-}
-
-static char *
-convert_javascript_to_utf8_string(JSContextRef ctx, JSValueRef val, size_t* out_len)
-{
-	JSStringRef str = JSValueToStringCopy(ctx, val, NULL);
-	size_t max = 0, len;
-	char *buf;
-
-	max = JSStringGetMaximumUTF8CStringSize(str);
-	buf = malloc(max);
-	len = JSStringGetUTF8CString(str, buf, max);
-
-	if (out_len) {
-		*out_len = len;
-	}
-
-	JSStringRelease(str);
-
-	return buf;
-}
-
-static inline VALUE
-convert_javascript_string_to_ruby(JSContextRef ctx, JSValueRef val)
-{
-	VALUE       output = Qnil;
-	JSStringRef str;
-	size_t      len = 0, max = 0;
-	char 		*buf;
-
-	str = JSValueToStringCopy(ctx, val, NULL);
-	max = JSStringGetMaximumUTF8CStringSize(str);
-	buf = malloc(max);
-	len = JSStringGetUTF8CString(str, buf, max);
-
-	output = rb_str_new(buf, len-1); // Ignore terminator
-
-	free(buf);
-	JSStringRelease(str);
-
-	return output;
-}
-
-static VALUE
-convert_javascript_to_ruby(JSContextRef ctx, JSValueRef val)
-{
-	VALUE output = Qnil;
-	JSValueRef *_exception = NULL;
-
-	switch (JSValueGetType(ctx, val)) {
-		case kJSTypeUndefined:
-		case kJSTypeNull:
-			output = Qnil;
-			break;
-		case kJSTypeBoolean:
-			output = JSValueToBoolean(ctx, val) ? Qtrue : Qfalse;
-			break;
-		case kJSTypeNumber:
-	    	output = rb_float_new(JSValueToNumber(ctx, val, _exception));
-			break;
-        case kJSTypeString:
-			output = convert_javascript_string_to_ruby(ctx, val);
-			break;
-		case kJSTypeObject:
-			output = convert_javascript_string_to_ruby(ctx, val);
-			break;
-	}
-
-	return output;
-}
-
-
-static JSValueRef
-convert_ruby_to_javascript(JSContextRef ctx, VALUE value)
-{
-	JSStringRef str;
-	JSValueRef jsval;
-
-	switch (TYPE(value)) {
-		case T_FIXNUM:
-			return JSValueMakeNumber(ctx, (double) FIX2LONG(value));
-		case T_FLOAT:
-			return JSValueMakeNumber(ctx, (double) NUM2DBL(value));
-		case T_BIGNUM:
-			return JSValueMakeNumber(ctx, (double) rb_big2long(value));
-		case T_TRUE:
-		case T_FALSE:
-			return JSValueMakeBoolean(ctx, RTEST(value));
-		case T_UNDEF:
-			return JSValueMakeUndefined(ctx);
-		case T_NIL:
-			return JSValueMakeNull(ctx);
-		default:
-			if (TYPE(value) != T_STRING) {
-				value = rb_funcall(value, rb_intern("to_s"), 0);
-			}
-			str   = JSStringCreateWithUTF8CString(RSTRING_PTR(value));
-			jsval = JSValueMakeString(ctx, str);
-			JSStringRelease(str);
-			return jsval;
-	}
-}
 
 static JSValueRef
 js_call_ruby_eval (JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject,
@@ -178,8 +76,6 @@ js_ruby_fn(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject,
 		ruby_fn = (VALUE)g_hash_table_lookup(ruby_fns, (gpointer)function);
 	}
 
-	//printf("Hmm.  Found: %p\n", function);
-
 	for (i = 0; i < argumentCount; i++) {
 		args[i] = convert_javascript_to_ruby(ctx, arguments[i]);
 	}
@@ -192,9 +88,283 @@ js_ruby_fn(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject,
 	return retval;
 }
 
+static void jsrb_class_init(JSContextRef ctx, JSObjectRef object)
+{
+	// Do something here?
+}
+
+static void jsrb_class_final(JSObjectRef object) {
+	// Clean up?
+	VALUE robject = JSObjectGetPrivate(object);
+	if (RTEST(robject)) {
+		ruby_js_class_def *def = (ruby_js_class_def*)DATA_PTR(rb_iv_get(robject, "_js_ref"));
+		rb_iv_set(robject, "_js_ref", Qnil);
+		free(def);
+		RUBYFUNC_DEL(object);
+	}
+}
+
+/**
+ * Heuristic:
+ *  - return true if obj.respond_to?(property) # i.e. method
+ *  - return true if obj.respond_to?("#{property}=") # ie. setter
+ *  - return true if obj.instance_variables.includj?("@#{property}") # ? maybe ?
+ */
+
+static bool jsrb_has_prop(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName)
+{
+	VALUE robject = JSObjectGetPrivate(object);
+
+	if (RTEST(robject)) {
+		ID prop = convert_javascript_to_intern(propertyName);
+		if (rb_respond_to(robject, prop)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+/**
+ * Heuristic:
+ *  - return method(property) if obj.method(property).arity > 0
+ *  - return send(property) if obj.respond_to?("#{property}=") # ie. setter - implemented as property
+ *  - return send(property) if obj.instance_variables.includj?("@#{property}") # ? maybe ?
+ *  - return send(property) if obj.respond_to?(property) # i.e. method
+ */
+
+static JSObjectRef jsrb_get_prop(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
+{
+	VALUE robject = JSObjectGetPrivate(object);
+
+	if (RTEST(robject)) {
+		ID prop = convert_javascript_to_intern(propertyName);
+		if (rb_respond_to(robject, prop)) {
+			VALUE rbo = rb_funcall(robject, rb_intern("method"), 1, conv_jsstrref_to_value(propertyName));
+			ruby_js_class_def *def = jsrb_newClass(rbo);
+			def->ctx = ctx;
+			return JSObjectMake(def->ctx, def->class_ref, (void*)rbo);
+		}
+	}
+	
+	return false;
+}
+
+static bool jsrb_set_prop(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
+{
+	return false;
+}
+
+static bool jsrb_del_prop(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
+{
+	return false;
+}
+
+static void jsrb_get_prop_names(JSContextRef ctx, JSObjectRef object, JSPropertyNameAccumulatorRef propertyNames)
+{
+}
+
+static JSValueRef jsrb_call_fn(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
+{
+	// 
+	VALUE robject = JSObjectGetPrivate(function);
+	VALUE self    = JSObjectGetPrivate(thisObject);
+	if (RTEST(robject)) {
+		VALUE rbo = rb_funcall2(robject, rb_intern("call"), 0, NULL);
+		JSValueRef retval = convert_ruby_to_javascript(ctx, rbo);
+		return retval;
+	}
+	return JSValueMakeUndefined(ctx);
+}
+
+typedef struct {
+	JSContextRef ctx;
+	JSObjectRef constructor;
+	size_t argumentCount;
+	JSValueRef *arguments;
+	JSValueRef* exception;
+} construct_args;
+
+static JSObjectRef wrapRubyObject(JSContextRef ctx, VALUE value)
+{
+	ruby_js_class_def *def;
+	JSObjectRef object;
+
+	def = jsrb_newClass(value);
+	def->ctx = ctx;
+	rb_iv_set(value, "_js_ref", Data_Wrap_Struct(cJsPtr, NULL, NULL, def));
+	object = JSObjectMake(ctx, def->class_ref, value);
+	return object;
+}
+
+static void jsrb_class_construct_ffi(ffi_cif* cif,
+	void** resp,
+	void** vargs,
+	void* userdata) {
+
+	ruby_js_class_def *def = (ruby_js_class_def*)userdata;
+	construct_args *args = (construct_args*)vargs;
+	
+	{
+		int no_args = 0;
+		VALUE *arg_list = NULL;
+		JSObjectRef object;
+		VALUE value = Qnil;
+
+
+		if (is_ruby_native_thread()) {
+			value = rb_class_new_instance(no_args, arg_list, def->rbObject);
+			// Convert JS values...
+
+			RUBYFUNC_ADD(value);
+		}
+		
+
+		object = JSObjectMake(def->ctx, def->class_ref, (void*)value);
+
+
+		*resp = (void*)object;
+	}
+}
+
+
+static JSObjectRef jsrb_call_create(JSContextRef ctx, JSObjectRef constructor, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
+{
+	int no_args = 0;
+	VALUE *arg_list = NULL;
+	JSObjectRef object;
+	VALUE value = Qnil;
+
+	VALUE robject = JSObjectGetPrivate(constructor);
+
+	if (RTEST(robject)) {
+		value = rb_class_new_instance(no_args, arg_list, robject);
+		RUBYFUNC_ADD(value);
+		
+		return wrapRubyObject(ctx, value);
+	}
+
+	return NULL;
+}
+
+static bool jsrb_has_instance(JSContextRef ctx, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception)
+{
+	return false;
+}
+
+static JSValueRef jsrb_convert(JSContextRef ctx, JSObjectRef object, JSType type, JSValueRef* exception)
+{
+	return false;
+}
+
+static ruby_js_class_def *jsrb_newClass(VALUE robject) {
+	JSClassDefinition *jclass;
+	ruby_js_class_def *def;
+
+	def = ALLOC_N(ruby_js_class_def,1);
+	def->definition = kJSClassDefinitionEmpty;
+	jclass = &(def->definition);
+
+	jclass->version    = 0;
+	jclass->attributes = kJSClassAttributeNoAutomaticPrototype;
+
+	// Check this?  It should probably be a valid JS name...
+
+	// ignore
+	// staticValues
+	// staticFunctions
+
+	/* Basics */
+	jclass->initialize        = jsrb_class_init;
+
+	jclass->finalize          = jsrb_class_final;
+
+	/* Property accessors... */
+	jclass->hasProperty       = jsrb_has_prop;
+	jclass->getProperty       = jsrb_get_prop;
+	jclass->setProperty       = jsrb_set_prop;
+	jclass->deleteProperty    = jsrb_del_prop;
+	jclass->getPropertyNames  = jsrb_get_prop_names;
+
+	/* Function */
+	//rb_p(robject);
+	if (rb_respond_to(robject, rb_intern("call"))) {
+		jclass->callAsFunction    = jsrb_call_fn;
+	} else {
+
+		jclass->callAsFunction    = NULL;
+	}
+
+	if (rb_obj_is_instance_of(robject, rb_cClass)) {
+		jclass->className     = rb_class2name(robject);
+		jclass->callAsConstructor = jsrb_call_create;
+		/*ffi_cif *cif;
+		ffi_closure *closure;
+		void *code;
+		ffi_type **types;
+		int args_len = 5;
+
+		cif      = ALLOC_N(ffi_cif, 1);
+		closure  = ffi_closure_alloc(sizeof(ffi_closure), &code);
+		types	 = ALLOC_N(ffi_type*, args_len);
+
+		types[0] = &ffi_type_pointer;
+		types[1] = &ffi_type_pointer;
+		types[2] = &ffi_type_uint32;
+		types[3] = &ffi_type_pointer;
+		types[4] = &ffi_type_pointer;
+
+		if (ffi_prep_cif(cif, FFI_DEFAULT_ABI, args_len, &ffi_type_pointer, types) == FFI_OK) {
+			if (ffi_prep_closure_loc(closure, cif, jsrb_class_construct_ffi, (void*)def, code) == FFI_OK) {
+				jclass->callAsConstructor = closure;
+			}
+		}*/
+	} else {
+		jclass->className     = rb_class2name(rb_obj_class(robject));
+		jclass->callAsConstructor = NULL;
+	}
+
+	//jclass->callAsConstructor = jsrb_call_create;
+	jclass->hasInstance       = jsrb_has_instance;
+	jclass->convertToType     = jsrb_convert;
+
+	def->rbObject   = robject;
+	def->class_ref = JSClassCreate(jclass);
+
+	return def;
+}
+
+/*static void jsrb_create_class(VALUE robject) {
+	//JSClassDefinition *def = jsrb_newClass(robject);
+}*/
+
+
+
+
 /**
  * Javascript functions called directly from binding
  **/
+static void javascript_add_class(JSGlobalContextRef ctx, char *name, VALUE robject)
+{
+	JSObjectRef global = JSContextGetGlobalObject(ctx), object;
+
+	// Should we store this on the class?
+/*	VALUE v = Qfalse;
+	ruby_js_class_def *def;
+
+	if (0 && RTEST(v = rb_iv_get(robject, "_js_ref"))) {
+		def = (ruby_js_class_def*)v;
+	} else {
+		def = jsrb_newClass(robject);
+		def->ctx = ctx;
+		rb_iv_set(robject, "_js_ref", (VALUE)def);
+	}*/
+
+/*	object = JSObjectMake(ctx, def->class_ref, NULL);*/
+
+	js_obj_set_value(ctx, global, name, wrapRubyObject(ctx, robject)); // Check failure?
+}
 static void *
 javascript_add_ruby_fn(JSGlobalContextRef ctx, char *name, VALUE ruby_fn)
 {