johnson 1.1.2 → 1.2.0

data/ext/spidermonkey/js_land_proxy.c

@@ -559,17 +559,22 @@ static void finalize(JSContext* js_context, JSObject* obj)
 
 JSBool make_js_land_proxy(JohnsonRuntime* runtime, VALUE value, jsval* retval)
 {
-  *retval = (jsval)JS_HashTableLookup(runtime->rbids, (void *)value);
-  
-  if (*retval)
+  jsval base_value = (jsval)JS_HashTableLookup(runtime->rbids, (void *)value);
+
+  JSContext * context = johnson_get_current_context(runtime);
+  PREPARE_JROOTS(context, 2);
+
+  jsval johnson = JSVAL_NULL;
+  JCHECK(evaluate_js_property_expression(runtime, "Johnson", &johnson));
+  JROOT(johnson);
+
+  if (base_value)
   {
-    return JS_TRUE;
+    JCHECK(JS_CallFunctionName(context, johnson, "applyConversions", 1, &base_value, retval));
+    JRETURN;
   }
   else
   {
-    JSContext * context = johnson_get_current_context(runtime);
-    PREPARE_JROOTS(context, 1);
-
     JSObject *jsobj;
     
     JSClass *klass = &JSLandProxyClass;
@@ -596,15 +601,20 @@ JSBool make_js_land_proxy(JohnsonRuntime* runtime, VALUE value, jsval* retval)
     JCHECK(JS_DefineFunction(context, jsobj, "toArray", to_array, 0, 0));
     JCHECK(JS_DefineFunction(context, jsobj, "toString", to_string, 0, 0));
 
-    *retval = OBJECT_TO_JSVAL(jsobj);
+    base_value = OBJECT_TO_JSVAL(jsobj);
 
-    // put the proxy OID in the id map
-    JCHECK(JS_HashTableAdd(runtime->rbids, (void *)value, (void *)(*retval)));
-    
     // root the ruby value for GC
     VALUE ruby_runtime = (VALUE)JS_GetRuntimePrivate(runtime->js);
     rb_funcall(ruby_runtime, rb_intern("add_gcthing"), 1, value);
 
+    jsval wrapped_value = JSVAL_NULL;
+    JCHECK(JS_CallFunctionName(context, johnson, "applyWrappers", 1, &base_value, &wrapped_value));
+
+    // put the proxy OID in the id map
+    JCHECK(JS_HashTableAdd(runtime->rbids, (void *)value, (void *)(wrapped_value)));
+    
+    JCHECK(JS_CallFunctionName(context, johnson, "applyConversions", 1, &wrapped_value, retval));
+
     JRETURN;
   }
 }

data/ext/spidermonkey/ruby_land_proxy.c

@@ -7,7 +7,16 @@ DEFINE_RUBY_WRAPPER(rb_call_super, rb_call_super, ARGLIST2(argc, argv))
 DECLARE_RUBY_WRAPPER(rb_yield, VALUE v)
 DEFINE_RUBY_WRAPPER(rb_yield, rb_yield, ARGLIST1(v))
 
+DECLARE_RUBY_WRAPPER(rb_check_type, VALUE o; int t)
+DEFINE_VOID_RUBY_WRAPPER(rb_check_type, rb_check_type, ARGLIST2(o, t))
+
+DEFINE_RUBY_WRAPPER(rb_string_value, rb_string_value, ARGLIST1(v))
+DEFINE_VOID_RUBY_WRAPPER(rb_string_value_cstr, rb_string_value_cstr, ARGLIST1(v))
+
+DEFINE_RUBY_WRAPPER(make_ruby_land_proxy, make_ruby_land_proxy, ARGLIST3(runtime, value, root_name))
+
 static VALUE proxy_class = Qnil;
+static VALUE script_class = Qnil;
 
 static inline JSBool get_jsval_for_proxy(RubyLandProxy* proxy, jsval* jv)
 {
@@ -45,7 +54,8 @@ static VALUE call_js_function_value(JohnsonRuntime* runtime, jsval target, jsval
  * call-seq:
  *   [](name)
  *
- * Returns the property with +name+.
+ * Retrieves the current value of the +name+ property of this JavaScript
+ * object.
  */
 static VALUE
 get(VALUE self, VALUE name)
@@ -67,8 +77,10 @@ get(VALUE self, VALUE name)
       JCHECK(JS_GetElement(context,
           JSVAL_TO_OBJECT(proxy_value), (jsint)(NUM2INT(name)), &js_value));
       break;
+    case T_SYMBOL:
+      name = RB_FUNCALL_0(name, RB_INTERN("to_s"));
     default:
-      Check_Type(name, T_STRING);
+      CALL_RUBY_WRAPPER(rb_string_value_cstr, &name);
       JCHECK(JS_GetProperty(context,
           JSVAL_TO_OBJECT(proxy_value), StringValueCStr(name), &js_value));
       break;
@@ -79,9 +91,9 @@ get(VALUE self, VALUE name)
 
 /*
  * call-seq:
- *   []=(name,value)
+ *   []=(name, value)
  *
- * Sets the property with +name+ to +value+.
+ * Sets this JavaScript object's +name+ property to +value+.
  */
 static VALUE
 set(VALUE self, VALUE name, VALUE value)
@@ -106,8 +118,10 @@ set(VALUE self, VALUE name, VALUE value)
       JCHECK(JS_SetElement(context,
               JSVAL_TO_OBJECT(proxy_value), (jsint)(NUM2INT(name)), &js_value));
       break;
+    case T_SYMBOL:
+      name = RB_FUNCALL_0(name, RB_INTERN("to_s"));
     default:
-      Check_Type(name, T_STRING);
+      CALL_RUBY_WRAPPER(rb_string_value_cstr, &name);
       JCHECK(JS_SetProperty(context,
             JSVAL_TO_OBJECT(proxy_value), StringValueCStr(name), &js_value));
       break;
@@ -118,9 +132,9 @@ set(VALUE self, VALUE name, VALUE value)
 
 /*
  * call-seq:
- *   function?
+ *   function?()
  *
- * Returns <code>true</code> if this is a function.
+ * Returns <code>true</code> if this JavaScript object is a function.
  */
 static VALUE
 function_p(VALUE self)
@@ -135,11 +149,18 @@ function_p(VALUE self)
   JRETURN_RUBY(JS_TypeOfValue(context, proxy_value) == JSTYPE_FUNCTION ? Qtrue : Qfalse);
 }
 
+static VALUE
+callable_test_p(VALUE self, VALUE proxy)
+{
+  return function_p(proxy);
+}
+
 /*
  * call-seq:
  *   respond_to?(symbol)
  *
- * Returns <code>true</code> if _obj_ responds to given method.
+ * Returns <code>true</code> if this JavaScript object responds to the
+ * named method.
  */
 static VALUE
 respond_to_p(int argc, const VALUE* argv, VALUE self)
@@ -178,9 +199,10 @@ respond_to_p(int argc, const VALUE* argv, VALUE self)
 
 /*
  * call-seq:
- *   native_call(global, *args)
+ *   native_call(this, *args)
  *
- * Call as a function with given +global+ using *args.
+ * Call this Ruby Object as a function, with the given +this+ object and
+ * arguments. Equivalent to the call method in JavaScript.
  */
 static VALUE
 native_call(int argc, VALUE* argv, VALUE self)
@@ -217,9 +239,12 @@ destroy_id_array(JSContext* context, void* data)
 
 /*
  * call-seq:
- *   each { |obj| block }
+ *   each {| element | block }
+ *   each {| name, value | block }
  *
- * Calls <em>block</em> with each item in the collection.
+ * Calls <em>block</em> with each item in this JavaScript array, or with
+ * each +name+/+value+ pair (like a Hash) for any other JavaScript
+ * object.
  */
 static VALUE
 each(VALUE self)
@@ -248,7 +273,7 @@ each(VALUE self)
     {
       jsval element;
       JCHECK(JS_GetElement(context, value, (signed) i, &element));
-      CALL_RUBY_WRAPPER(rb_yield, convert_to_ruby(proxy->runtime, element));
+      CALL_RUBY_WRAPPER(rb_yield, CONVERT_TO_RUBY(proxy->runtime, element));
     }
   }
   else
@@ -296,9 +321,10 @@ each(VALUE self)
 
 /*
  * call-seq:
- *   length
+ *   length()
  *
- * Returns the length of the collection.
+ * Returns the number of entries in the JavaScript array, or the number
+ * of properties on the JavaScript object.
  */
 static VALUE
 length(VALUE self)
@@ -337,9 +363,10 @@ length(VALUE self)
 
 /*
  * call-seq:
- *   runtime
+ *   runtime()
  *
- * Returns runtime.
+ * Returns the Johnson::SpiderMonkey::Runtime against which this object
+ * is registered.
  */
 static VALUE
 runtime(VALUE self)
@@ -353,13 +380,17 @@ runtime(VALUE self)
  * call-seq:
  *   function_property?(name)
  *
- * Returns <code>true</code> if +name+ is a function property.
+ * Returns <code>true</code> if this JavaScript object's +name+ property
+ * is a function.
  */
 static VALUE
 function_property_p(VALUE self, VALUE name)
 {
-  Check_Type(name, T_STRING);
-  
+  if (TYPE(name) == T_SYMBOL)
+    name = rb_funcall(name, rb_intern("to_s"), 0);
+
+  rb_string_value_cstr(&name);
+
   RubyLandProxy* proxy;
   Data_Get_Struct(self, RubyLandProxy, proxy);
   JSContext * context = johnson_get_current_context(proxy->runtime);
@@ -386,7 +417,11 @@ function_property_p(VALUE self, VALUE name)
  * call-seq:
  *   call_function_property(name, arguments)
  *
- * Calls function +name+ with +arguments+.
+ * Calls this JavaScript object's +name+ method, passing the given
+ * arguments.
+ *
+ * Equivalent to:
+ *    proxy[name].native_call(proxy, *arguments)
  */
 static VALUE
 call_function_property(int argc, VALUE* argv, VALUE self)
@@ -405,26 +440,30 @@ call_function_property(int argc, VALUE* argv, VALUE self)
   JROOT(proxy_value);
 
   jsval function;
+
+  VALUE name = argv[0];
+  CALL_RUBY_WRAPPER(rb_string_value_cstr, &name);
   
   JCHECK(JS_GetProperty(context,
-    JSVAL_TO_OBJECT(proxy_value), StringValueCStr(argv[0]), &function));
+    JSVAL_TO_OBJECT(proxy_value), StringValueCStr(name), &function));
 
   JROOT(function);
 
-  JSType funtype = JS_TypeOfValue(context, function);
-  
   // should never be anything but a function
-  if (funtype != JSTYPE_FUNCTION)
-    JERROR("Specified property \"%s\" isn't a function.", StringValueCStr(argv[0]));
+  if (!JS_ObjectIsFunction(context, function))
+    JERROR("Specified property \"%s\" isn't a function.", StringValueCStr(name));
+
+  REMOVE_JROOTS;
 
-  JRETURN_RUBY(call_js_function_value(proxy->runtime, proxy_value, function, argc - 1, &(argv[1])));
+  return call_js_function_value(proxy->runtime, proxy_value, function, argc - 1, &(argv[1]));
 }
 
 /*
  * call-seq:
- *   to_s
+ *   to_s()
  *
- * Converts object to a string.
+ * Converts the JavaScript object to a string, using its toString method
+ * if available.
  */
 static VALUE to_s(VALUE self)
 {
@@ -439,7 +478,7 @@ static VALUE to_s(VALUE self)
   JROOT(proxy_value);
   
   JSString* str = JS_ValueToString(context, proxy_value);
-  JRETURN_RUBY(convert_js_string_to_ruby(proxy->runtime, str));
+  JRETURN_RUBY(CONVERT_JS_STRING_TO_RUBY(proxy->runtime, str));
 }
 
 ///////////////////////////////////////////////////////////////////////////
@@ -468,7 +507,26 @@ static void finalize(RubyLandProxy* proxy)
 
 bool ruby_value_is_proxy(VALUE maybe_proxy)
 {
-  return proxy_class == CLASS_OF(maybe_proxy); 
+  return rb_obj_is_kind_of(maybe_proxy, proxy_class);
+}
+
+bool ruby_value_is_script_proxy(VALUE maybe_proxy)
+{
+  return rb_obj_is_kind_of(maybe_proxy, script_class);
+}
+
+VALUE apply_wrappers(VALUE proxy)
+{
+  VALUE johnson = rb_const_get(rb_mKernel, rb_intern("Johnson"));
+  VALUE johnson_proxy = rb_const_get(johnson, rb_intern("RubyLandProxy"));
+  return rb_funcall(johnson_proxy, rb_intern("apply_wrappers"), 1, proxy);
+}
+
+VALUE apply_conversions(VALUE proxy)
+{
+  VALUE johnson = rb_const_get(rb_mKernel, rb_intern("Johnson"));
+  VALUE johnson_proxy = rb_const_get(johnson, rb_intern("RubyLandProxy"));
+  return rb_funcall(johnson_proxy, rb_intern("apply_conversions"), 1, proxy);
 }
 
 JSBool unwrap_ruby_land_proxy(JohnsonRuntime* runtime, VALUE wrapped, jsval* retval)
@@ -487,34 +545,41 @@ JSBool unwrap_ruby_land_proxy(JohnsonRuntime* runtime, VALUE wrapped, jsval* ret
 
 VALUE make_ruby_land_proxy(JohnsonRuntime* runtime, jsval value, const char const* root_name)
 {
-  VALUE id = (VALUE)JS_HashTableLookup(runtime->jsids, (void *)value);
+  RubyLandProxy * our_proxy = (RubyLandProxy *)JS_HashTableLookup(runtime->jsids, (void *)value);
   
-  if (id)
+  if (our_proxy)
   {
     // if we already have a proxy, return it
-    return id;
+    return apply_conversions(our_proxy->self);
   }
   else
   {    
     // otherwise make one and cache it
-    RubyLandProxy* our_proxy; 
-    VALUE proxy = Data_Make_Struct(proxy_class, RubyLandProxy, 0, finalize, our_proxy);
+    VALUE proxy = Data_Make_Struct((strncmp(root_name, "JSScriptProxy", strlen("JSScriptProxy")) ? proxy_class : script_class), RubyLandProxy, 0, finalize, our_proxy);
 
     JSContext * context = johnson_get_current_context(runtime);
 
     PREPARE_RUBY_JROOTS(context, 1);
     JROOT(value);
 
+    VALUE rb_runtime = (VALUE)JS_GetRuntimePrivate(runtime->js);
+    rb_iv_set(proxy, "@runtime", rb_runtime);
+
     our_proxy->runtime = runtime;
     our_proxy->key = (void *)value;
+    our_proxy->self = proxy;
 
     // root the value for JS GC and lookups
     JCHECK(JS_AddNamedRootRT(runtime->js, &(our_proxy->key), root_name));
 
     // put the proxy OID in the id map
-    JCHECK(JS_HashTableAdd(runtime->jsids, (void *)value, (void *)proxy));
-    
-    JRETURN_RUBY(proxy);
+    JCHECK(JS_HashTableAdd(runtime->jsids, (void *)value, (void *)our_proxy));
+
+    VALUE final_proxy = JPROTECT(apply_wrappers, proxy);
+
+    our_proxy->self = final_proxy;
+
+    JRETURN_RUBY(JPROTECT(apply_conversions, final_proxy));
   }
 }
 
@@ -525,8 +590,11 @@ void init_Johnson_SpiderMonkey_Proxy(VALUE spidermonkey)
   VALUE spidermonkey = rb_define_module_under(johnson, "SpiderMonkey");
   */
 
+  VALUE johnson = rb_const_get(rb_mKernel, rb_intern("Johnson"));
+  VALUE johnson_proxy = rb_const_get(johnson, rb_intern("RubyLandProxy"));
+
   /* RubyLandProxy class. */
-  proxy_class = rb_define_class_under(spidermonkey, "RubyLandProxy", rb_cObject);
+  proxy_class = rb_define_class_under(spidermonkey, "RubyLandProxy", johnson_proxy);
 
   rb_define_method(proxy_class, "[]", get, 1);
   rb_define_method(proxy_class, "[]=", set, 2);
@@ -536,8 +604,15 @@ void init_Johnson_SpiderMonkey_Proxy(VALUE spidermonkey)
   rb_define_method(proxy_class, "length", length, 0);
   rb_define_method(proxy_class, "to_s", to_s, 0);
 
-  rb_define_private_method(proxy_class, "native_call", native_call, -1);
   rb_define_private_method(proxy_class, "runtime", runtime, 0);
   rb_define_private_method(proxy_class, "function_property?", function_property_p, 1);
   rb_define_private_method(proxy_class, "call_function_property", call_function_property, -1);
+
+  VALUE callable = rb_define_module_under(proxy_class, "Callable");
+  rb_define_singleton_method(callable, "test?", callable_test_p, 1);
+  rb_define_private_method(callable, "native_call", native_call, -1);
+
+  rb_funcall(johnson_proxy, rb_intern("insert_wrapper"), 1, callable);
+
+  script_class = rb_define_class_under(spidermonkey, "RubyLandScript", proxy_class);
 }

data/ext/spidermonkey/ruby_land_proxy.h

@@ -4,12 +4,33 @@
 #include "spidermonkey.h"
 #include "runtime.h"
 
+#ifdef LEAK_ROOT_NAMES
+#define LEAKY_ROOT_NAME(static_string, dynamic_detail) \
+  ({\
+    const char * const _leaky_root__detail = (dynamic_detail);\
+    char * _leaky_root__leaked = malloc(strlen(static_string) + strlen(_leaky_root__detail) + 2);\
+    strcpy(_leaky_root__leaked, static_string);\
+    _leaky_root__leaked[strlen(static_string)] = ':';\
+    strcpy(_leaky_root__leaked + strlen(static_string) + 1, _leaky_root__detail);\
+    _leaky_root__leaked;\
+  })
+#else
+#define LEAKY_ROOT_NAME(static_string, dynamic_detail) (static_string)
+#endif
+
+DECLARE_RUBY_WRAPPER(make_ruby_land_proxy, JohnsonRuntime* runtime; jsval value; const char const* root_name)
+
+DECLARE_RUBY_WRAPPER(rb_string_value, VALUE v)
+DECLARE_RUBY_WRAPPER(rb_string_value_cstr, VALUE v)
+
 typedef struct {
   void* key;
   JohnsonRuntime* runtime;
+  VALUE self;
 } RubyLandProxy;
 
 bool ruby_value_is_proxy(VALUE maybe_proxy);
+bool ruby_value_is_script_proxy(VALUE maybe_proxy);
 JSBool unwrap_ruby_land_proxy(JohnsonRuntime* runtime, VALUE proxy, jsval* retval);
 VALUE make_ruby_land_proxy(JohnsonRuntime* runtime, jsval value, const char const* root_name);
 void init_Johnson_SpiderMonkey_Proxy(VALUE spidermonkey);

data/ext/spidermonkey/runtime.c

@@ -2,13 +2,13 @@
 #include "global.h"
 #include "idhash.h"
 #include "conversions.h"
-#include "jsdbgapi.h"
+#include "debugger.h"
 #include "jroot.h"
 #include "ruby_land_proxy.h"
 
 /*
  * call-seq:
- *   global
+ *   global()
  *
  * Returns the global object used for this context.
  */
@@ -19,14 +19,15 @@ static VALUE global(VALUE self)
   return convert_to_ruby(runtime, OBJECT_TO_JSVAL(runtime->global));
 }
 
-static JSTrapStatus trap_handler( JSContext *UNUSED(context),
+static JSTrapStatus trap_handler( JSContext *context,
                                   JSScript *UNUSED(script),
                                   jsbytecode *UNUSED(pc),
                                   jsval *UNUSED(rval),
                                   void *block_closure )
 {
+  PREPARE_JROOTS(context, 0);
   VALUE block = (VALUE)block_closure;
-  rb_funcall(block, rb_intern("call"), 0);
+  RB_FUNCALL_0(block, rb_intern("call"));
   return JSTRAP_CONTINUE;
 }
 
@@ -34,7 +35,7 @@ static JSTrapStatus trap_handler( JSContext *UNUSED(context),
  * call-seq:
  *   clear_trap(script, line_num)
  *
- * Set the trap at +script+ and +line_num+ to +block+
+ * Clear the trap previously set at +line_num+ of +script+.
  */
 static VALUE clear_trap(VALUE self, VALUE script, VALUE linenum)
 {
@@ -56,9 +57,10 @@ static VALUE clear_trap(VALUE self, VALUE script, VALUE linenum)
 
 /*
  * call-seq:
- *   set_trap(script, parsecode, block)
+ *   set_trap(script, line_num, block)
  *
- * Set the trap at +script+ and +parsecode+ to +block+
+ * Set a trap to invoke +block+ when execution of +script+ reaches
+ * +line_num+.
  */
 static VALUE set_trap(VALUE self, VALUE script, VALUE linenum, VALUE block)
 {
@@ -77,9 +79,10 @@ static VALUE set_trap(VALUE self, VALUE script, VALUE linenum, VALUE block)
 
 /*
  * call-seq:
- *   native_compile(script, filename, linenum)
+ *   native_compile(script_string, filename, linenum)
  *
- * Compile +script+ with +filename+ using +linenum+
+ * Compile the JavaScript code in +script_string+, marked as originating
+ * from +filename+ starting at +linenum+.
  */
 static VALUE native_compile(VALUE self, VALUE script, VALUE filename, VALUE linenum)
 {
@@ -113,20 +116,23 @@ static VALUE native_compile(VALUE self, VALUE script, VALUE filename, VALUE line
 
   JSObject * script_object = JS_NewScriptObject(context, compiled_js);
 
-  PREPARE_RUBY_JROOTS(context, 1);
-  JROOT(script_object);
-  JRETURN_RUBY(make_ruby_land_proxy(runtime, OBJECT_TO_JSVAL(script_object), "JSScriptProxy"));
+  return make_ruby_land_proxy(runtime, OBJECT_TO_JSVAL(script_object), LEAKY_ROOT_NAME("JSScriptProxy", RTEST(filename) ? RSTRING(rb_inspect(filename))->ptr : "(?)"));
 }
 
 /*
  * call-seq:
- *   evaluate_compiled_script(script)
+ *   evaluate_compiled_script(script_proxy)
  *
- * Evaluate +script+
+ * Evaluate previously compiled +script_proxy+, returning the final
+ * result from that script.
  */
 static VALUE evaluate_compiled_script(VALUE self, VALUE compiled_script)
 {
   JohnsonRuntime* runtime;
+
+  if (!ruby_value_is_script_proxy(compiled_script))
+    rb_raise(rb_eArgError, "Compiled JS Script expected");
+
   Data_Get_Struct(self, JohnsonRuntime, runtime);
 
   JSContext * context = johnson_get_current_context(runtime);
@@ -163,12 +169,16 @@ static VALUE evaluate_compiled_script(VALUE self, VALUE compiled_script)
   return convert_to_ruby(runtime, js);
 }
 
+#ifdef JS_GC_ZEAL
 /*
  * call-seq:
  *   gc_zeal=(level)
  *
  * Sets the GC zeal.
- * 0 = normal, 1 = Very Frequent, 2 = Extremely Frequent
+ *
+ * 0:: Normal
+ * 1:: Very Frequent
+ * 2:: Extremely Frequent
  */
 static VALUE
 set_gc_zeal(VALUE self, VALUE zeal)
@@ -182,12 +192,33 @@ set_gc_zeal(VALUE self, VALUE zeal)
 
   return zeal;
 }
+#endif
+
+/*
+ * call-seq:
+ *   gc()
+ *
+ * Manually initiates a SpiderMonkey Garbage Collection run.
+ */
+static VALUE
+gc(VALUE self)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  JSContext* context = johnson_get_current_context(runtime);
+
+  JS_GC(context);
+
+  return Qnil;
+}
 
 /*
  * call-seq:
  *   debugger=(debugger)
  *
- * Sets a debugger object
+ * Directs the runtime to install a full set of debug hooks, using the
+ * given +debugger+, which must be a Johnson::SpiderMonkey::Debugger.
  */
 static VALUE
 set_debugger(VALUE self, VALUE debugger)
@@ -195,6 +226,9 @@ set_debugger(VALUE self, VALUE debugger)
   JohnsonRuntime* runtime;
   JSDebugHooks* debug_hooks;
 
+  if (!ruby_value_is_debugger(debugger))
+    rb_raise(rb_eTypeError, "Expected Johnson::SpiderMonkey::Debugger instance");
+
   rb_iv_set(self, "@debugger", debugger);
   Data_Get_Struct(self, JohnsonRuntime, runtime);
   Data_Get_Struct(debugger, JSDebugHooks, debug_hooks);
@@ -247,6 +281,13 @@ JSBool gc_callback(JSContext *context, JSGCStatus status)
   return JS_FALSE;
 }
 
+/**
+ * call-seq:
+ *   initialize_native(options)
+ *
+ * Create the underlying SpiderMonkey runtime. This must be called
+ * first, and only once. Called by +initialize+ by default.
+ */
 static VALUE
 initialize_native(VALUE self, VALUE UNUSED(options))
 {
@@ -262,7 +303,7 @@ initialize_native(VALUE self, VALUE UNUSED(options))
 
     JSContext* context = johnson_get_current_context(runtime);
 
-    if (runtime->global = JS_GetGlobalObject(context))
+    if ((runtime->global = JS_GetGlobalObject(context)))
       return self;
   }
 
@@ -289,6 +330,16 @@ JSContext* johnson_get_current_context(JohnsonRuntime * runtime)
   return context->js;
 }
 
+static int proxy_cleanup_enumerator(JSHashEntry *entry, int i, void* arg)
+{
+  JohnsonRuntime *runtime = (JohnsonRuntime*)(arg);
+  // entry->key is jsval; entry->value is RubyLandProxy*
+  RubyLandProxy * proxy = (RubyLandProxy *)(entry->value);
+  JS_RemoveRootRT(runtime->js, &(proxy->key));
+  proxy->runtime = NULL;
+  return 0;
+}
+
 static void deallocate(JohnsonRuntime* runtime)
 {
   // our gc callback can create ruby objects, so disable it
@@ -303,6 +354,10 @@ static void deallocate(JohnsonRuntime* runtime)
     iterator = NULL;
   }
 
+  JSContext* cleanup = JS_NewContext(runtime->js, 8192L);
+  JS_HashTableEnumerateEntries(runtime->jsids, proxy_cleanup_enumerator, runtime);
+  JS_DestroyContext(cleanup);
+
   JS_DestroyRuntime(runtime->js);
   free(runtime);
 }
@@ -315,16 +370,27 @@ static VALUE allocate(VALUE klass)
 
 void init_Johnson_SpiderMonkey_Runtime(VALUE spidermonkey)
 {
-  VALUE klass = rb_define_class_under(spidermonkey, "Runtime", rb_cObject);
+  /* HACK:  These comments are *only* to make RDoc happy.
+  VALUE johnson = rb_define_module("Johnson");
+  VALUE spidermonkey = rb_define_module_under(johnson, "SpiderMonkey");
+  */
+
+  VALUE johnson = rb_const_get(rb_mKernel, rb_intern("Johnson"));
+  VALUE johnson_runtime = rb_const_get(johnson, rb_intern("Runtime"));
+
+  VALUE klass = rb_define_class_under(spidermonkey, "Runtime", johnson_runtime);
 
   rb_define_alloc_func(klass, allocate);
   rb_define_private_method(klass, "initialize_native", initialize_native, 1);
 
   rb_define_method(klass, "global", global, 0);
   rb_define_method(klass, "debugger=", set_debugger, 1);
+  rb_define_method(klass, "gc", gc, 0);
+#ifdef JS_GC_ZEAL
   rb_define_method(klass, "gc_zeal=", set_gc_zeal, 1);
+#endif
   rb_define_method(klass, "evaluate_compiled_script", evaluate_compiled_script, 1);
   rb_define_private_method(klass, "native_compile", native_compile, 3);
-  rb_define_private_method(klass, "set_trap", set_trap, 3);
+  rb_define_method(klass, "set_trap", set_trap, 3);
   rb_define_private_method(klass, "clear_trap", clear_trap, 2);
 }