jbarnette-johnson 1.0.0.200806240111

data/ext/spidermonkey/ruby_land_proxy.h

@@ -0,0 +1,17 @@
+#ifndef JOHNSON_SPIDERMONKEY_RUBY_LAND_PROXY_H
+#define JOHNSON_SPIDERMONKEY_RUBY_LAND_PROXY_H
+
+#include "spidermonkey.h"
+#include "runtime.h"
+
+typedef struct {
+  void* key;
+  JohnsonRuntime* runtime;
+} RubyLandProxy;
+
+bool ruby_value_is_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);
+
+#endif

data/ext/spidermonkey/runtime.c

@@ -0,0 +1,304 @@
+#include "runtime.h"
+#include "global.h"
+#include "idhash.h"
+#include "conversions.h"
+#include "jsdbgapi.h"
+#include "jroot.h"
+#include "ruby_land_proxy.h"
+
+/*
+ * call-seq:
+ *   global
+ *
+ * Returns the global object used for this context.
+ */
+static VALUE global(VALUE self)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+  return convert_to_ruby(runtime, OBJECT_TO_JSVAL(runtime->global));
+}
+
+static JSTrapStatus trap_handler( JSContext *UNUSED(context),
+                                  JSScript *UNUSED(script),
+                                  jsbytecode *UNUSED(pc),
+                                  jsval *UNUSED(rval),
+                                  void *block_closure )
+{
+  VALUE block = (VALUE)block_closure;
+  rb_funcall(block, rb_intern("call"), 0);
+  return JSTRAP_CONTINUE;
+}
+
+/*
+ * call-seq:
+ *   set_trap(script, parsecode, block)
+ *
+ * Set the trap at +script+ and +parsecode+ to +block+
+ */
+static VALUE set_trap(VALUE self, VALUE script, VALUE linenum, VALUE block)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  JSContext * context = johnson_get_current_context(runtime);
+  jsval compiled_js;
+  if(!convert_to_js(runtime, script, &compiled_js))
+    rb_raise(rb_eRuntimeError, "Couldn't get compiled script.");
+  JSScript * js_script = (JSScript *)JS_GetPrivate(context, JSVAL_TO_OBJECT(compiled_js));
+
+  jsbytecode * pc = JS_LineNumberToPC(context, js_script, (uintN)NUM2INT(linenum));
+  return JS_SetTrap(context, js_script, pc, trap_handler, (void*)block) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   native_compile(script, filename, linenum)
+ *
+ * Compile +script+ with +filename+ using +linenum+
+ */
+static VALUE native_compile(VALUE self, VALUE script, VALUE filename, VALUE linenum)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  JSContext * context = johnson_get_current_context(runtime);
+  JohnsonContext * johnson_context = OUR_CONTEXT(context);
+
+  JSScript * compiled_js = JS_CompileScript(
+      context,
+      runtime->global,
+      StringValuePtr(script),
+      (size_t)StringValueLen(script),
+      StringValueCStr(filename),
+      (unsigned)NUM2INT(linenum)
+  );
+  if(compiled_js == NULL) {
+    if (JS_IsExceptionPending(context))
+    {
+      // If there's an exception pending here, it's a syntax error.
+      JS_GetPendingException(context, &johnson_context->ex);
+      JS_ClearPendingException(context);
+    }
+
+    if (johnson_context->ex) {
+      RAISE_JS_ERROR(self, johnson_context->ex);
+      return Qnil;
+    }
+  }
+
+  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"));
+}
+
+/*
+ * call-seq:
+ *   evaluate_compiled_script(script)
+ *
+ * Evaluate +script+
+ */
+static VALUE evaluate_compiled_script(VALUE self, VALUE compiled_script)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  JSContext * context = johnson_get_current_context(runtime);
+  JohnsonContext * johnson_context = OUR_CONTEXT(context);
+
+  // clean things up first
+  johnson_context->ex = 0;
+  memset(johnson_context->msg, 0, MAX_EXCEPTION_MESSAGE_SIZE);
+
+  jsval compiled_js;
+  if(!convert_to_js(runtime, compiled_script, &compiled_js))
+    rb_raise(rb_eRuntimeError, "Script compilation failed");
+
+  JSScript * js_script = (JSScript *)JS_GetPrivate(context, JSVAL_TO_OBJECT(compiled_js));
+
+  jsval js;
+  JSBool ok = JS_ExecuteScript(context, runtime->global, js_script, &js);
+
+  if (!ok)
+  {
+    if (JS_IsExceptionPending(context))
+    {
+      // If there's an exception pending here, it's a syntax error.
+      JS_GetPendingException(context, &johnson_context->ex);
+      JS_ClearPendingException(context);
+    }
+
+    if (johnson_context->ex) {
+      RAISE_JS_ERROR(self, johnson_context->ex);
+      return Qnil;
+    }
+  }
+
+  return convert_to_ruby(runtime, js);
+}
+
+/*
+ * call-seq:
+ *   gc_zeal=(level)
+ *
+ * Sets the GC zeal.
+ * 0 = normal, 1 = Very Frequent, 2 = Extremely Frequent
+ */
+static VALUE
+set_gc_zeal(VALUE self, VALUE zeal)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  JSContext* context = johnson_get_current_context(runtime);
+
+  JS_SetGCZeal(context, NUM2INT(zeal));
+
+  return zeal;
+}
+
+/*
+ * call-seq:
+ *   debugger=(debugger)
+ *
+ * Sets a debugger object
+ */
+static VALUE
+set_debugger(VALUE self, VALUE debugger)
+{
+  JohnsonRuntime* runtime;
+  JSDebugHooks* debug_hooks;
+
+  rb_iv_set(self, "@debugger", debugger);
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+  Data_Get_Struct(debugger, JSDebugHooks, debug_hooks);
+
+  JSContext * context = johnson_get_current_context(runtime);
+
+  JS_SetInterrupt(          runtime->js,
+                            debug_hooks->interruptHandler,
+                            debug_hooks->interruptHandlerData);
+  JS_SetNewScriptHook(      runtime->js,
+                            debug_hooks->newScriptHook,
+                            debug_hooks->newScriptHookData);
+  JS_SetDestroyScriptHook(  runtime->js,
+                            debug_hooks->destroyScriptHook,
+                            debug_hooks->destroyScriptHookData);
+  JS_SetDebuggerHandler(    runtime->js,
+                            debug_hooks->debuggerHandler,
+                            debug_hooks->debuggerHandlerData);
+  JS_SetSourceHandler(      runtime->js,
+                            debug_hooks->sourceHandler,
+                            debug_hooks->sourceHandlerData);
+  JS_SetExecuteHook(        runtime->js,
+                            debug_hooks->executeHook,
+                            debug_hooks->executeHookData);
+  JS_SetCallHook(           runtime->js,
+                            debug_hooks->callHook,
+                            debug_hooks->callHookData);
+  JS_SetObjectHook(         runtime->js,
+                            debug_hooks->objectHook,
+                            debug_hooks->objectHookData);
+  JS_SetThrowHook(          runtime->js,
+                            debug_hooks->throwHook,
+                            debug_hooks->throwHookData);
+  JS_SetDebugErrorHook(     runtime->js,
+                            debug_hooks->debugErrorHook,
+                            debug_hooks->debugErrorHookData);
+
+  JS_SetContextDebugHooks(context, debug_hooks);
+
+  return debugger;
+}
+
+JSBool gc_callback(JSContext *context, JSGCStatus status)
+{
+  if(status == JSGC_BEGIN) {
+    VALUE ruby_runtime = (VALUE)JS_GetRuntimePrivate(JS_GetRuntime(context));
+    if(rb_funcall(ruby_runtime, rb_intern("should_sm_gc?"), 0) == Qtrue)
+      return JS_TRUE;
+  }
+  return JS_FALSE;
+}
+
+static VALUE
+initialize_native(VALUE self, VALUE UNUSED(options))
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+  
+  if ((runtime->js = JS_NewRuntime(0x100000))
+    && (runtime->jsids = create_id_hash())
+    && (runtime->rbids = create_id_hash())
+  )
+  {
+    JS_SetRuntimePrivate(runtime->js, (void *)self);
+    JS_SetGCCallbackRT(runtime->js, gc_callback);
+
+    JSContext* context = johnson_get_current_context(runtime);
+    if(
+        (runtime->global = JS_GetGlobalObject(context))
+        && (JS_AddNamedRoot(context, &(runtime->global), "runtime->global"))
+    ) {
+      return self;
+    }
+  }
+
+
+  if (runtime->rbids)
+    JS_HashTableDestroy(runtime->rbids);
+
+  if (runtime->jsids)
+    JS_HashTableDestroy(runtime->jsids);
+
+  if (runtime->js)
+    JS_DestroyRuntime(runtime->js);
+    
+  rb_raise(rb_eRuntimeError, "Couldn't initialize the runtime!");
+  return Qnil;
+}
+
+JSContext* johnson_get_current_context(JohnsonRuntime * runtime)
+{
+  JohnsonContext * context = NULL;
+  VALUE self = (VALUE)JS_GetRuntimePrivate(runtime->js);
+  Data_Get_Struct(rb_funcall(self, rb_intern("current_context"), 0), JohnsonContext, context);
+  return context->js;
+}
+
+static void deallocate(JohnsonRuntime* runtime)
+{
+  JS_RemoveRoot(johnson_get_current_context(runtime), &(runtime->global));
+  
+  JSContext *context;
+  JSContext *iterator = NULL;
+
+  while ((context = JS_ContextIterator(runtime->js, &iterator)) != NULL)
+    JS_DestroyContext(context);
+  
+  JS_DestroyRuntime(runtime->js);
+  free(runtime);
+}
+
+static VALUE allocate(VALUE klass)
+{
+  JohnsonRuntime* runtime = calloc(1, sizeof(JohnsonRuntime));
+  return Data_Wrap_Struct(klass, 0, deallocate, runtime);
+}
+
+void init_Johnson_SpiderMonkey_Runtime(VALUE spidermonkey)
+{
+  VALUE klass = rb_define_class_under(spidermonkey, "Runtime", rb_cObject);
+
+  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_zeal=", set_gc_zeal, 1);
+  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);
+}

data/ext/spidermonkey/runtime.h

@@ -0,0 +1,25 @@
+#ifndef JOHNSON_SPIDERMONKEY_RUNTIME_H
+#define JOHNSON_SPIDERMONKEY_RUNTIME_H
+
+#include "spidermonkey.h"
+
+#define RAISE_JS_ERROR(rb_runtime, ex) \
+  do {\
+    JohnsonRuntime * _rt = NULL;\
+    Data_Get_Struct(rb_runtime, JohnsonRuntime, _rt);\
+    rb_funcall(CLASS_OF(rb_runtime), rb_intern("raise_js_exception"), 1,\
+      convert_to_ruby(_rt, ex)); \
+  } while(0)
+
+typedef struct {
+  JSObject* global;
+  JSRuntime* js;
+
+  JSHashTable *jsids; // jsid -> rbid
+  JSHashTable *rbids; // rbid -> jsid
+} JohnsonRuntime;
+
+JSContext* johnson_get_current_context(JohnsonRuntime* runtime);
+void init_Johnson_SpiderMonkey_Runtime(VALUE spidermonkey);
+
+#endif

data/ext/spidermonkey/spidermonkey.c

@@ -0,0 +1,20 @@
+#include "spidermonkey.h"
+#include "context.h"
+#include "ruby_land_proxy.h"
+#include "debugger.h"
+#include "immutable_node.h"
+
+void Init_spidermonkey()
+{
+  VALUE johnson = rb_define_module("Johnson"); // FIXME: this belongs outside the extension
+  VALUE spidermonkey = rb_define_module_under(johnson, "SpiderMonkey");
+  
+  init_Johnson_SpiderMonkey_Context(spidermonkey);
+  init_Johnson_SpiderMonkey_Proxy(spidermonkey);
+  init_Johnson_SpiderMonkey_Debugger(spidermonkey);
+  init_Johnson_SpiderMonkey_Immutable_Node(spidermonkey);
+  init_Johnson_SpiderMonkey_Runtime(spidermonkey);
+  
+  rb_define_const(spidermonkey, "VERSION",
+    rb_obj_freeze(rb_str_new2(JS_GetImplementationVersion())));
+}

data/ext/spidermonkey/spidermonkey.h

@@ -0,0 +1,29 @@
+#ifndef JOHNSON_SPIDERMONKEY_H
+#define JOHNSON_SPIDERMONKEY_H
+
+#include <assert.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <ruby.h>
+
+#include "jsapi.h"
+#include "jshash.h"
+#include "jsregexp.h"
+
+#include "jroot.h"
+
+#ifndef StringValueLen
+#define StringValueLen(v) (RSTRING(v)->len)
+#endif
+
+#ifndef UNUSED
+# if defined(__GNUC__)
+#  define MAYBE_UNUSED(name) name __attribute__((unused))
+#  define UNUSED(name) MAYBE_UNUSED(UNUSED_ ## name)
+# else
+#  define MAYBE_UNUSED(name) name
+#  define UNUSED(name) name
+# endif
+#endif
+
+#endif

data/js/johnson/browser.js

@@ -0,0 +1,9 @@
+Ruby.require('net/http');
+Johnson.require("johnson/browser/xmlw3cdom");
+Johnson.require("johnson/browser/xmlsax");
+Johnson.require("johnson/browser/env");
+
+DOMElement.prototype.toString = function() {
+  return "<" + this.tagName + (this.className !== "" ? " class='" + this.className + "'" : "") + 
+    (this.id !== "" ? " id='" + this.id + "'" : "") + ">";
+};

data/js/johnson/browser/env.js

@@ -0,0 +1,687 @@
+/*
+ * Simulated browser environment for Rhino
+ *   By John Resig <http://ejohn.org/>
+ * Copyright 2007 John Resig, under the MIT License
+ */
+
+// The window Object
+var window = this;
+
+Ruby.require("uri");
+
+print = function(txt) { Ruby.puts(txt); };
+
+(function(){
+
+  // Browser Navigator
+
+  window.navigator = {
+    get userAgent(){
+      return "Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en-US; rv:1.8.1.3) Gecko/20070309 Firefox/2.0.0.3";
+    }
+  };
+  
+  var fileToUrl = function(file) {
+    return Ruby.URI.parse("file://" + Ruby.File.expand_path(file));
+  };
+  
+  var curLocation = fileToUrl(".");
+  
+  window.__defineSetter__("location", function(url){
+    var xhr = new XMLHttpRequest();
+    xhr.open("GET", url);
+    xhr.onreadystatechange = function(){
+      curLocation = curLocation.merge(url);
+      window.document = xhr.responseXML;
+
+      if(window.document) {
+        var event = document.createEvent();
+        event.initEvent("load");
+        window.dispatchEvent( event );
+      }
+    };
+    xhr.send();
+  });
+  
+  window.__defineGetter__("location", function(url){
+    return {
+      get protocol(){
+        return curLocation.scheme() + ":";
+      },
+      get href(){
+        return curLocation.toString();
+      },
+      toString: function(){
+        return this.href.toString();
+      }
+    };
+  });
+  
+  // Timers
+
+  var timers = [];
+  
+  window.setTimeout = function(fn, time){
+    var num;
+    return num = setInterval(function(){
+      fn();
+      clearInterval(num);
+    }, time);
+  };
+  
+  window.setInterval = function(fn, time){
+    var num = timers.length;
+    
+    timers[num] = new Ruby.Thread(function() {
+      while(true) {
+        Ruby.sleep(time);
+        fn();
+      }
+    });
+  
+    return num;
+  };
+  
+  window.clearInterval = function(num){
+    if ( timers[num] ) {
+      timers[num].kill();
+      delete timers[num];
+    }
+  };
+  
+  // Window Events
+  
+  var events = [{}];
+
+  window.addEventListener = function(type, fn){
+    if ( !this.uuid || this == window ) {
+      this.uuid = events.length;
+      events[this.uuid] = {};
+    }
+     
+    if ( !events[this.uuid][type] )
+      events[this.uuid][type] = [];
+    
+    if ( events[this.uuid][type].indexOf( fn ) < 0 )
+      events[this.uuid][type].push( fn );
+  };
+  
+  window.removeEventListener = function(type, fn){
+     if ( !this.uuid || this == window ) {
+         this.uuid = events.length;
+         events[this.uuid] = {};
+     }
+     
+     if ( !events[this.uuid][type] )
+      events[this.uuid][type] = [];
+      
+    events[this.uuid][type] =
+      events[this.uuid][type].filter(function(f){
+        return f != fn;
+      });
+  };
+  
+  window.dispatchEvent = function(event){
+    if ( event.type ) {
+      if ( this.uuid && events[this.uuid][event.type] ) {
+        var self = this;
+      
+        events[this.uuid][event.type].forEach(function(fn){
+          fn.call( self, event );
+        });
+      }
+      
+      if ( this["on" + event.type] )
+        this["on" + event.type].call( self, event );
+    }
+  };
+  
+  // DOM Document
+  
+  window.DOMDocument = function(file){
+    this._file = file;
+    var parser = new W3CDOMImplementation();
+    try {
+      this._dom = parser.loadXML(file);
+    } catch(e) {
+      Ruby.puts("*** wycats to fix: " + parser.translateErrCode(e.code));
+      throw parser.translateErrCode(e.code);
+    }
+    
+    if ( !obj_nodes["key?"]( this._dom ) )
+      obj_nodes[this._dom] = this;
+  };
+  
+  DOMDocument.prototype = {
+    nodeType: 1,
+    createTextNode: function(text){
+      return makeNode( this._dom.createTextNode(
+        text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")) );
+    },
+    createElement: function(name){
+      return makeNode( this._dom.createElement(name.toLowerCase()) );
+    },
+    getElementsByTagName: function(name){
+      return new DOMNodeList( this._dom.getElementsByTagName(
+        name.toLowerCase()) );
+    },
+    getElementById: function(id){
+      return makeNode( this._dom.getElementById(id) );
+    },
+    get body(){
+      return this.getElementsByTagName("body")[0];
+    },
+    get documentElement(){
+      return makeNode( this._dom.getDocumentElement() );
+    },
+    get ownerDocument(){
+      return null;
+    },
+    addEventListener: window.addEventListener,
+    removeEventListener: window.removeEventListener,
+    dispatchEvent: window.dispatchEvent,
+    get nodeName() {
+      return "#document";
+    },
+    importNode: function(node, deep){
+      return makeNode( this._dom.importNode(node._dom, deep) );
+    },
+    toString: function(){
+      return "Document" + (typeof this._file == "string" ?
+        ": " + this._file : "");
+    },
+    get innerHTML(){
+      return this.documentElement.outerHTML;
+    },
+    
+    get defaultView(){
+      return {
+        getComputedStyle: function(elem){
+          return {
+            getPropertyValue: function(prop){
+              prop = prop.replace(/\-(\w)/g,function(m,c){
+                return c.toUpperCase();
+              });
+              var val = elem.style[prop];
+              
+              if ( prop === "opacity" && val === "" )
+                val = "1";
+                
+              return val;
+            }
+          };
+        }
+      };
+    },
+    
+    createEvent: function(){
+      return {
+        type: "",
+        initEvent: function(type){
+          this.type = type;
+        }
+      };
+    }
+  };
+  
+  function getDocument(node){
+    return obj_nodes[node];
+  }
+  
+  // DOM NodeList
+  
+  window.DOMNodeList = function(list){
+    this._dom = list;
+    this.length = list.getLength();
+    
+    for ( var i = 0; i < this.length; i++ ) {
+      var node = list.item(i);
+      this[i] = makeNode( node );
+    }
+  };
+  
+  DOMNodeList.prototype = {
+    toString: function(){
+      return "[ " +
+        Array.prototype.join.call( this, ", " ) + " ]";
+    },
+    get outerHTML(){
+      return Array.prototype.map.call(
+        this, function(node){return node.outerHTML;}).join('');
+    }
+  };
+  
+  // DOM Node
+  
+  window.DOMNode = function(node){
+    this._dom = node;
+  };
+  
+  DOMNode.prototype = {
+    get nodeType(){
+      return this._dom.getNodeType();
+    },
+    get nodeValue(){
+      return this._dom.getNodeValue();
+    },
+    get nodeName() {
+      return this._dom.getNodeName();
+    },
+    cloneNode: function(deep){
+      return makeNode( this._dom.cloneNode(deep) );
+    },
+    get ownerDocument(){
+      return getDocument( this._dom.getOwnerDocument() );
+    },
+    get documentElement(){
+      return makeNode( this._dom.getDocumentElement() );
+    },
+    get parentNode() {
+      return makeNode( this._dom.getParentNode() );
+    },
+    get nextSibling() {
+      return makeNode( this._dom.getNextSibling() );
+    },
+    get previousSibling() {
+      return makeNode( this._dom.getPreviousSibling() );
+    },
+    toString: function(){
+      return '"' + this.nodeValue + '"';
+    },
+    get outerHTML(){
+      return this.nodeValue;
+    }
+  };
+
+  // DOM Element
+
+  window.DOMElement = function(elem){
+    this._dom = elem;
+    this.style = {
+      get opacity(){ return this._opacity; },
+      set opacity(val){ this._opacity = val + ""; }
+    };
+    
+    // Load CSS info
+    var styles = (this.getAttribute("style") || "").split(/\s*;\s*/);
+    
+    for ( var i = 0; i < styles.length; i++ ) {
+      var style = styles[i].split(/\s*:\s*/);
+      if ( style.length == 2 )
+        this.style[ style[0] ] = style[1];
+    }
+  };
+  
+  DOMElement.prototype = extend( new DOMNode(), {
+    get nodeName(){
+      return this.tagName.toUpperCase();
+    },
+    get tagName(){
+      return this._dom.getTagName().toUpperCase();
+    },
+    toString: function(){
+      return "<" + this.tagName + (this.id ? "#" + this.id : "" ) + ">";
+    },
+    get outerHTML(){
+      var ret = "<" + this.tagName, attr = this.attributes;
+      
+      for ( var i in attr )
+        ret += " " + i + "='" + attr[i] + "'";
+        
+      if ( this.childNodes.length || this.nodeName == "SCRIPT" )
+        ret += ">" + this.childNodes.outerHTML + 
+          "</" + this.tagName + ">";
+      else
+        ret += "/>";
+      
+      return ret;
+    },
+    
+    get attributes(){
+      var attr = {}, attrs = this._dom.getAttributes();
+      
+      for ( var i = 0; i < attrs.getLength(); i++ )
+        attr[ attrs.item(i).nodeName ] = attrs.item(i).nodeValue;
+        
+      return attr;
+    },
+    
+    get innerHTML(){
+      return this.childNodes.outerHTML; 
+    },
+    set innerHTML(html){
+      html = html.replace(/<\/?([A-Z]+)/g, function(m){
+        return m.toLowerCase();
+      });
+      
+      var nodes = this.ownerDocument.importNode(
+        new DOMDocument( html ).documentElement, true
+      ).childNodes;
+        
+      while (this.firstChild)
+        this.removeChild( this.firstChild );
+      
+      for ( var i = 0; i < nodes.length; i++ )
+        this.appendChild( nodes[i] );
+    },
+    
+    get textContent(){
+      function nav(nodes){
+        var str = "";
+        for ( var i = 0; i < nodes.length; i++ ) {
+          if ( nodes[i].nodeType == 3 )
+            str += nodes[i].nodeValue;
+          else if ( nodes[i].nodeType == 1 )
+            str += nav(nodes[i].childNodes);
+        }
+        return str;
+      }
+      
+      return nav(this.childNodes);
+    },
+    set textContent(text){
+      while (this.firstChild)
+        this.removeChild( this.firstChild );
+      this.appendChild( this.ownerDocument.createTextNode(text) );
+    },
+    
+    style: {},
+    clientHeight: 0,
+    clientWidth: 0,
+    offsetHeight: 0,
+    offsetWidth: 0,
+    
+    get disabled() {
+      var val = this.getAttribute("disabled");
+      return val != "false" && !!val;
+    },
+    set disabled(val) { return this.setAttribute("disabled",val); },
+    
+    get checked() {
+      var val = this.getAttribute("checked");
+      return val != "false" && !!val;
+    },
+    set checked(val) { return this.setAttribute("checked",val); },
+    
+    get selected() {
+      if ( !this._selectDone ) {
+        this._selectDone = true;
+        
+        if ( this.nodeName == "OPTION" && !this.parentNode.getAttribute("multiple") ) {
+          var opt = this.parentNode.getElementsByTagName("option");
+          
+          if ( this == opt[0] ) {
+            var select = true;
+            
+            for ( var i = 1; i < opt.length; i++ ) {
+              if ( opt[i].selected ) {
+                select = false;
+                break;
+              }
+            }
+              
+            if ( select )
+              this.selected = true;
+          }
+        }
+      }
+      
+      var val = this.getAttribute("selected");
+      return val != "false" && !!val;
+    },
+    set selected(val) { return this.setAttribute("selected",val); },
+
+    get className() { return this.getAttribute("class") || ""; },
+    set className(val) {
+      return this.setAttribute("class",
+        val.replace(/(^\s*|\s*$)/g,""));
+    },
+    
+    get type() { return this.getAttribute("type") || ""; },
+    set type(val) { return this.setAttribute("type",val); },
+    
+    get value() { return this.getAttribute("value") || ""; },
+    set value(val) { return this.setAttribute("value",val); },
+    
+    get src() { return this.getAttribute("src") || ""; },
+    set src(val) { return this.setAttribute("src",val); },
+    
+    get id() { return this.getAttribute("id") || ""; },
+    set id(val) { return this.setAttribute("id",val); },
+    
+    getAttribute: function(name){
+      return this._dom.hasAttribute(name) ?
+        new String( this._dom.getAttribute(name) ) :
+        null;
+    },
+    setAttribute: function(name,value){
+      this._dom.setAttribute(name,value);
+    },
+    removeAttribute: function(name){
+      this._dom.removeAttribute(name);
+    },
+    
+    get childNodes(){
+      return new DOMNodeList( this._dom.getChildNodes() );
+    },
+    get firstChild(){
+      return makeNode( this._dom.getFirstChild() );
+    },
+    get lastChild(){
+      return makeNode( this._dom.getLastChild() );
+    },
+    appendChild: function(node){
+      this._dom.appendChild( node._dom );
+    },
+    insertBefore: function(node,before){
+      this._dom.insertBefore( node._dom, before ? before._dom : before );
+    },
+    removeChild: function(node){
+      this._dom.removeChild( node._dom );
+    },
+
+    getElementsByTagName: DOMDocument.prototype.getElementsByTagName,
+    
+    addEventListener: window.addEventListener,
+    removeEventListener: window.removeEventListener,
+    dispatchEvent: window.dispatchEvent,
+    
+    click: function(){
+      var event = document.createEvent();
+      event.initEvent("click");
+      this.dispatchEvent(event);
+    },
+    submit: function(){
+      var event = document.createEvent();
+      event.initEvent("submit");
+      this.dispatchEvent(event);
+    },
+    focus: function(){
+      var event = document.createEvent();
+      event.initEvent("focus");
+      this.dispatchEvent(event);
+    },
+    blur: function(){
+      var event = document.createEvent();
+      event.initEvent("blur");
+      this.dispatchEvent(event);
+    },
+    get elements(){
+      return this.getElementsByTagName("*");
+    },
+    get contentWindow(){
+      return this.nodeName == "IFRAME" ? {
+        document: this.contentDocument
+      } : null;
+    },
+    get contentDocument(){
+      if ( this.nodeName == "IFRAME" ) {
+        if ( !this._doc )
+          this._doc = new DOMDocument(
+            "<html><head><title></title></head><body></body></html>"
+          );
+        return this._doc;
+      } else
+        return null;
+    }
+  });
+  
+  // Helper method for extending one object with another
+  
+  function extend(a,b) {
+    for ( var i in b ) {
+      var g = b.__lookupGetter__(i), s = b.__lookupSetter__(i);
+      
+      if ( g || s ) {
+        if ( g )
+          a.__defineGetter__(i, g);
+        if ( s )
+          a.__defineSetter__(i, s);
+      } else
+        a[i] = b[i];
+    }
+    return a;
+  }
+  
+  // Helper method for generating the right
+  // DOM objects based upon the type
+  
+  var obj_nodes = new Ruby.Hash;
+  
+  function makeNode(node){
+    if ( node ) {
+      if ( !obj_nodes['key?']( node ) )
+        obj_nodes[node] = node.getNodeType() == 
+          W3CDOMNode.ELEMENT_NODE ?
+            new DOMElement( node ) : new DOMNode( node );
+      
+      return obj_nodes[node];
+    } else
+      return null;
+  }
+  
+  // XMLHttpRequest
+  // Originally implemented by Yehuda Katz
+
+  window.XMLHttpRequest = function(){
+    this.headers = {};
+    this.responseHeaders = {};
+  };
+  
+  XMLHttpRequest.prototype = {
+    open: function(method, url, async, user, password){ 
+      this.readyState = 1;
+      if (async)
+        this.async = true;
+      this.method = method || "GET";
+      this.url = url;
+      this.onreadystatechange();
+    },
+    setRequestHeader: function(header, value){
+      this.headers[header] = value;
+    },
+    getResponseHeader: function(header){ },
+    send: function(data){
+      var self = this;
+
+      function makeRequest(){
+        var url = curLocation.merge(self.url);
+        var connection;
+        
+        if ( url.scheme == "file" ) {
+          if ( self.method == "PUT" ) {
+            var out = new Ruby.File(url.path);
+            var text = data || "";
+            
+            out.puts( text );
+            out.flush();
+            out.close();
+          } else if ( self.method == "DELETE" ) {
+            var file = new Ruby.File(url.path());
+            file["delete"]();
+          } else if ( self.method == "GET" ) {
+            var file = Ruby.File.read(url.path);
+            connection = {
+              code: "200",
+              message: "Ok",
+              body: file,
+            }
+            handleResponse();
+          } else {
+            connection = Ruby.Net.HTTP.start(url.host, url.port, function(http) {
+              http.get(url.path);
+            });
+            handleResponse();
+          }
+        } else { 
+          var http = Ruby.Net.HTTP.new(url.host, url.port);
+          var request = new Ruby.Net.HTTP.Get(url.path);
+          for (var header in self.headers)
+            request.add_field(header, self.headers[header]);
+
+          var connection = http.request(request);
+          connection.each_header(function(k,v) {
+            self.responseHeaders[k] = v;
+          });
+
+          handleResponse();
+        }
+        
+        function handleResponse(){
+          self.readyState = 4;
+          self.status = parseInt(connection.code) || undefined;
+          self.statusText = connection.message || "";
+          
+          self.responseText = connection.body;
+            
+          self.responseXML = null;
+          
+          if ( self.responseText.match(/^\s*</) ) {
+            self.responseXML = new DOMDocument( self.responseText );
+          }
+        }
+        
+        self.onreadystatechange();
+      }
+
+      if (this.async)
+        new Ruby.Thread(function() { makeRequest(); });
+      else
+        makeRequest();
+    },
+    abort: function(){},
+    onreadystatechange: function(){},
+    getResponseHeader: function(header){
+      if (this.readyState < 3)
+        throw new Error("INVALID_STATE_ERR");
+      else {
+        var returnedHeaders = [];
+        for (var rHeader in this.responseHeaders) {
+          if (rHeader.match(new Regexp(header, "i")))
+            returnedHeaders.push(this.responseHeaders[rHeader]);
+        }
+      
+        if (returnedHeaders.length)
+          return returnedHeaders.join(", ");
+      }
+      
+      return null;
+    },
+    getAllResponseHeaders: function(header){
+      if (this.readyState < 3)
+        throw new Error("INVALID_STATE_ERR");
+      else {
+        var returnedHeaders = [];
+        
+        for (var aHeader in this.responseHeaders)
+          returnedHeaders.push( aHeader + ": " + this.responseHeaders[aHeader] );
+        
+        return returnedHeaders.join("\r\n");
+      }
+    },
+    async: true,
+    readyState: 0,
+    responseText: "",
+    status: 0
+  };
+})();