opal 0.3.2 → 0.3.6

data/gems/rquery/lib/rquery/request.rb

@@ -1,138 +0,0 @@
-# The Request class wraps the native XMLHttpRequest object in the
-# browser and makes use of jQuery's ajax facilities to make requests.
-class Request
-
-  # Default options used by all Requests. Unless an option here is
-  # overrideen, then these defaults will be used on each request. This
-  # is not a full list of all options that can be used; these are just
-  # the bare essentials and useful defaults.
-  DEFAULT_OPTIONS = {
-    :url    => '',
-    :type   => 'GET'
-  }
- 
-  # Creates a new Request object. The passed options are merged with
-  # DEFAULT_OPTIONS and will be used as the base options for each
-  # request. Request specific options may be passed to {#send}, and
-  # these will be used in preference to the options passed here.
-  #
-  # Most of the options that can be set also have their own designated
-  # getters and setters as instance methods on this class. This allows
-  # for options to be set in a more independant manner instead of
-  # collecting all options into the initialization hash.
-  #
-  # @param [Hash] options request options
-  # @return [Request] returns new request instance 
-  def initialize(options = {})
-    @options          = DEFAULT_OPTIONS.merge options 
-    @complete_action  = nil
-    @failure_action   = nil
-    @success_action   = nil
-  end
-
-  # Creates attribute reader and writers for the given options that will
-  # set/retrieve the values from the options hash belonging to this
-  # instance. Each of these options may also be overriden by the final
-  # values sent to {#send}, or one of its aliases: {#get}, {#post},
-  # {#put} or {#delete}.
-  #
-  # @param [String, Symbol] names option names to set
-  def self.option_accessor(*names)
-    names.each do |name|
-      # define option getter
-      define_method(name) { @options[name] }
-      # define option setter
-      define_method("#{name}=") { |value| @options[name] = value }
-    end
-  end
- 
-  # By default all requests will be sent async, to avoid locking up the
-  # browser. Set this to `false` to send requests in a sync fashion.
-  # This defaults to `true` to send by async by default.
-  option_accessor :async
-
-  # Gets the type of the request, which is "GET" by default. This value
-  # may be "GET" or "POST", as they are well supported by the browser,
-  # but "PUT" and "DELETE" may also be used, but they are not supported
-  # within the browser.
-  option_accessor :type
-
-  # Holds the string representing the URL to which the request is sent.
-  # By default this is an empty string, so it needs to be set to get any
-  # useful requests back.
-  option_accessor :url    
-
-  # Sets the username to use when accessing the HTTP authentication
-  # requests.
-  option_accessor :username
-
-  # Sets the relevant password used in the HTTP authentication requests.
-  option_accessor :password
-
-  # Sends the request with the specified options. These options are
-  # merged with the options given to {#initialize}. There are also
-  # aliases for this method for automatically setting the request
-  # type; {#put}, {#post}, {#get} and {#delete} will automatically
-  # set the correct request type to avoid the need to set it in the
-  # options.
-  #
-  # @param [Hash] options the request options
-  # @return [Request] returns the receiver
-  def send(options = {})
-    `options = #{@options.merge options};
-
-    // native options object
-    var opts = {};
-
-    // we must have a url
-    opts.url = #{options[:url]}
-
-    // request type
-    opts.type = #{options[:type]}
-
-    // success callback
-    if (#{@success_action} != nil) {
-      opts.success = function(data, textStatus, jqXHR) {
-        var response = #{Response.new `jqXHR`};
-        #{@success_action.call `response`};
-      };
-    }
-
-    $.ajax(opts);
-
-    return self;`
-  end
-
-  def get(options = {})
-    options[:type] = 'GET'
-    send options
-  end
-
-  def post(options = {})
-    options[:type] = 'POST'
-    send options
-  end
-  
-  def put(options = {})
-    options[:type] = 'PUT'
-    send options
-  end
-
-  def delete(options = {})
-    options[:type] = 'DELETE'
-    send options
-  end
-
-  # Register a block that will be called if the request succeeds. 
-  def success(&block)
-    @success_action = block
-  end
-  
-  # Register a block that will be called if the request fails
-  
-  def failure(&block)
-    @failure_action = block
-  end
-end
-
-

data/gems/rquery/lib/rquery/response.rb

@@ -1,49 +0,0 @@
-# Instances of Response are automatically created by Request, so you do
-# not need to make them yourself. This is the object that will be passed
-# to each of the callbacks for a Request object. For this reason, this
-# object will be created if the request succeeds, or indeed fails.
-class Response
-  # Private initializer. This handles a native jquery requets object, so
-  # this should all probably be private.
-  def initialize(request)
-    `self.$xhr = request`
-  end
-
-  # Returns the numeric status code for the response.
-  #
-  # @return [Numeric]
-  def status
-    `return self.$xhr.status;`
-  end
-
-  # Returns the string status message for the response.
-  #
-  # @return [String]
-  def status_text
-    `return self.$xhr.statusText;`
-  end
-
-  # Returns the response text from the request.
-  #
-  # @return [String]
-  def text
-    `return self.$xhr.responseText;`
-  end
-
-  # Returns `true` if the response represents a successfull request,
-  # `false` otherwise.
-  #
-  # @return [true, false]
-  def success?
-    `return (self.$xhr.status >= 200 && self.$xhr.status < 300) ? Qtrue : Qfalse;`
-  end
-
-  # Returns `false` if the response was the result of an unsuccessful
-  # request, `true` otherwise.
-  #
-  # @return [true, false]
-  def failure?
-    !success?
-  end
-end
-

data/gems/rquery/rquery.gemspec

@@ -1,16 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name         = "rquery"
-  s.version      = "0.0.1"
-  s.authors      = ["Adam Beynon"]
-  s.email        = ["adam@adambeynon.com"]
-  s.homepage     = "http://github.com/adambeynon/opal"
-  s.summary      = "Rquery DOM library for ruby/opal"
-
-  s.files        = Dir.glob("{bin,lib}/**/*") + %w[README.md]
-  s.require_path = "lib"
-
-  s.add_dependency "json"
-end
-

data/lib/opal.js

@@ -1,1597 +0,0 @@
-/**
-  Incase we are in browser, wrap body to avoid global vars. Just opal can become
-  a top level var. We treat opal as our exports in nodejs, as we reassign them
-  at the bottom of this file.
-*/
-var opal = {};
-
-(function() {
-
-  // So we can minimize
-  var Op = opal;
-
-  /**
-    Core runtime classes, objects and literals.
-  */
-  var cBasicObject,     cObject,          cModule,          cClass,
-      mKernel,          cNilClass,        cTrueClass,       cFalseClass,
-      cFile,            cProc,            cNumeric,         cArray,
-      cHash,            cString,          cSymbol,          cRange,
-      cRegexp,          cMatch,           Qself,            Qnil,
-      Qfalse,           Qtrue;
-
-  /**
-    Exception classes. Some of these are used by runtime so they are here for
-    convenience.
-  */
-  var eException,       eStandardError,   eLocalJumpError,  eNameError,
-      eNoMethodError,   eArgError,        eScriptError,     eLoadError,
-      eRuntimeError,    eTypeError,       eIndexError,      eKeyError,
-      eRangeError;
-
-  /**
-    Standard jump exceptions to save re-creating them everytime they are needed
-  */
-  var rb_vm_return_instance,
-      rb_vm_loop_return_instance,
-      rb_vm_next_instance,
-      rb_vm_break_instance;
-
-  // ..........................................................
-  // VIRTUAL MACHINE
-  //
-
-  /**
-    This is the VM param that gets given to all files in opal. This contains
-    just the VM methods for opal, to keep the global opal namespace cleaner as
-    it is used just for external access.
-  */
-  Op.vm = {};
-
-  // for minimizng
-  var Vm = Op.vm;
-  Vm.opal = Op;
-
-  /**
-    Core object type flags. Added as local variables, and onto Opal prototype.
-  */
-  var T_CLASS       = Vm.T_CLASS       = 1,
-      T_MODULE      = Vm.T_MODULE      = 2,
-      T_OBJECT      = Vm.T_OBJECT      = 4,
-      T_BOOLEAN     = Vm.T_BOOLEAN     = 8,
-      T_STRING      = Vm.T_STRING      = 16,
-      T_ARRAY       = Vm.T_ARRAY       = 32,
-      T_NUMBER      = Vm.T_NUMBER      = 64,
-      T_PROC        = Vm.T_PROC        = 128,
-      T_SYMBOL      = Vm.T_SYMBOL      = 256,
-      T_HASH        = Vm.T_HASH        = 512,
-      T_RANGE       = Vm.T_RANGE       = 1024,
-      T_ICLASS      = Vm.T_ICLASS      = 2056,
-      FL_SINGLETON  = Vm.FL_SINGLETON  = 4112;
-
-  /**
-    For setting up method_missing methods. Each ruby file that has been compiled
-    with call this method with an array of all method_ids that it makes use of.
-    These only need to be from method calls. This allows us to make sure this
-    method exists on the base prototype, and is set to simply call method_missing
-    for the receiver. This adds overhead to the beginning of each file being
-    loaded, but is more more efficient than having to check for method_missing on
-    every method call in the file for the entirety of its lifetime.
-
-    @param {Array<String>} method_ids An array of method_ids to register
-  */
-  Vm.mm = function(method_ids) {
-    var prototype = cBasicObject.$m_prototype_tbl;
-
-    for (var i = 0, ii = method_ids.length; i < ii; i++) {
-      var method_id = method_ids[i];
-      // only add fake method if not already defined
-      if (!prototype.hasOwnProperty(method_id)) {
-        // our fake method implementation
-        var imp = (function(method_id) {
-          return function(self) {
-            var args = [].slice.call(arguments, 1);
-            args.unshift(Vm.Y(method_id));
-            args.unshift(self);
-            return self.$m.method_missing.apply(null, args);
-          };
-        })(method_id);
-        // mark as a fake method to help respond_to? and send, etc.
-        imp.$rbMM = true;
-        prototype[method_id] = imp;
-      }
-    }
-  };
-
-  /**
-    Define methods. Public method for defining a method on the given base.
-
-    @param {RObject} base The base to define method on
-    @param {String} method_id Ruby mid
-    @param {Function} body The method implementation
-    @param {Boolean} singleton Singleton or Normal method. true for singleton
-  */
-
-  Vm.dm = function(base, method_id, body, singleton) {
-    if (singleton) {
-      define_singleton_method(base, method_id, body);
-    } else {
-      // should this instead do a rb_singleton_method?? probably..
-      if (base.$flags & T_OBJECT) {
-        base = base.$klass;
-      }
-
-      define_method(base, method_id, body);
-    }
-
-    return Qnil;
-  };
-
-  /**
-    Define classes. This is the public API for defining classes, shit classes
-    and modules.
-
-    @param {RObject} base
-    @param {RClass} super_class
-    @param {String} id
-    @param {Function} body
-    @param {Number} flag
-  */
-  Vm.dc = function(base, super_class, id, body, flag) {
-    var klass;
-
-    switch (flag) {
-      case 0:
-        if (base.$flags & T_OBJECT) {
-          base = class_real(base.$klass);
-        }
-
-        if (super_class == Qnil) {
-          super_class = cObject;
-        }
-
-        klass = define_class_under(base, id, super_class);
-        break;
-
-      case 1:
-        klass = singleton_class(base);
-        break;
-
-      case 2:
-        if (base.$flags & T_OBJECT) {
-          base = class_real(base.$klass);
-        }
-        klass = define_module_under(base, id);
-        break;
-
-      default:
-        raise(eException, "define_class got a unknown flag " + flag);
-    }
-
-    return body.call(klass);
-  };
-
-  /**
-    Returns a new RHash instance constructed from the given arguments of
-    alternate key, value pairs.
-  */
-  Vm.H = function() {
-    return new RHash(Array.prototype.slice.call(arguments));
-  };
-
-  /**
-    Returns a new ruby symbol with the given intern value. Symbols are made
-    using the new String() constructor, and just have its klass and method
-    table reassigned. This makes dealing with strings/symbols internally
-    easier as both can be used as a string within opal.
-
-    @param {String} intern Symbol value
-    @return {RSymbol} symbol
-  */
-  Vm.Y = function(intern) {
-    if (symbol_table.hasOwnProperty(intern)) {
-      return symbol_table[intern];
-    }
-
-    var res = new String(intern);
-    res.$klass = cSymbol;
-    res.$m = cSymbol.$m_tbl;
-    symbol_table[intern] = res;
-    return res;
-  };
-
-  /**
-    Returns a new ruby range. 'G' for range... yeah.
-
-    @param {RObject} beg The start item for the range
-    @param {RObject} end The finish item for the range
-    @param {true, false} exclude_end Whether or not the range excludes the last item
-    @return {RRange} Returns the new range instance
-  */
-  Vm.G = function(beg, end, exclude_end) {
-    return new RRange(beg, end, exclude_end);
-  };
-
-  /**
-    Ruby break statement with the given value. When no break value is needed, nil
-    should be passed here. An undefined/null value is not valid and will cause an
-    internal error.
-
-    @param {RObject} value The break value.
-  */
-  Vm.B = function(value) {
-    rb_vm_break_instance.$value = value;
-    throw rb_vm_break_instance;
-  };
-
-  /**
-    Ruby return, with the given value. The func is the reference function which
-    represents the method that this statement must return from.
-  */
-  Vm.R = function(value, func) {
-    rb_vm_return_instance.$value = value;
-    rb_vm_return_instance.$func = func;
-    throw rb_vm_return_instance;
-  };
-
-  /**
-    Block passing. This holds the current block info for the runtime.
-
-      f: function
-      p: block
-      y: yield error
-
-  */
-  Vm.P = {
-    f: null,
-    p: null,
-    y: function() {
-      throw new Error("LocalJumpError - opal.P.y - no block given");
-    }
-  };
-
-  /**
-    Define a toll free bridged class.
-
-    @param {Object} prototype Native prototype to extend
-    @param {Number} flags The flags for instances of class
-    @param {String} id Class id
-    @param {RClass} super_klass
-  */
-  Vm.bridged_class = function(prototype, flags, id, super_klass) {
-    return bridge_class(prototype, flags || T_OBJECT, id, super_klass);
-  };
-
-  /**
-    Sets the constant value `val` on the given `klass` as `id`.
-
-    @param {RClass} klass
-    @param {String} id
-    @param {Object} val
-    @return {Object} returns the set value
-  */
-  function const_set(klass, id, val) {
-    klass.$c_prototype[id] = val;
-    return val;
-  }
-
-  /**
-    Lookup a constant named `id` on the `klass`. This will throw an error if
-    the constant cannot be found.
-
-    @param {RClass} klass
-    @param {String} id
-  */
-  function const_get(klass, id) {
-    if (klass.$c[id]) {
-      return (klass.$c[id]);
-    }
-
-    var parent = klass.$parent;
-
-    while (parent && parent != cObject) {
-      if (parent.$c[id]) {
-        return parent.$c[id];
-      }
-
-      parent = parent.$parent;
-    }
-
-    raise(eNameError, 'uninitialized constant ' + id);
-  };
-
-  /**
-    Returns true or false depending whether a constant named `id` is defined
-    on the receiver `klass`.
-
-    @param {RClass} klass
-    @param {String} id
-    @return {true, false}
-  */
-  function const_defined(klass, id) {
-    if (klass.$c[id]) {
-      return true;
-    }
-
-    return false;
-  };
-
-  /**
-    Set an instance variable on the receiver.
-  */
-  function ivar_set(obj, id, val) {
-    obj[id] = val;
-    return val;
-  };
-
-  /**
-    Return an instance variable set on the receiver, or nil if one does not
-    exist.
-  */
-  function ivar_get(obj, id) {
-    return obj.hasOwnProperty(id) ? obj[id] : Qnil;
-  };
-
-  /**
-    Determines whether and instance variable has been set on the receiver.
-  */
-  function ivar_defined(obj, id) {
-    return obj.hasOwnProperty(id) ? true : false;
-  };
-
-  /**
-    This table holds all the global variables accessible from ruby.
-
-    Entries are mapped by their global id => an object that contains the
-    given keys:
-
-      - name
-      - value
-      - getter
-      - setter
-  */
-  var global_tbl = {};
-
-  /**
-    Defines a hooked/global variable.
-
-    @param {String} name The global name (e.g. '$:')
-    @param {Function} getter The getter function to return the variable
-    @param {Function} setter The setter function used for setting the var
-    @return {null}
-  */
-  function define_hooked_variable(name, getter, setter) {
-    var entry = {
-      "name": name,
-      "value": Qnil,
-      "getter": getter,
-      "setter": setter
-    };
-
-    global_tbl[name] = entry;
-  };
-
-  /**
-    A default read only getter for a global variable. This will simply throw a
-    name error with the given id. This can be used for variables that should
-    not be altered.
-  */
-  function gvar_readonly_setter(id, value) {
-    raise(eNameError, id + " is a read-only variable");
-  };
-
-  /**
-    Retrieve a global variable. This will use the assigned getter.
-  */
-  function gvar_get(id) {
-    var entry = global_tbl[id];
-    if (!entry) { return Qnil; }
-    return entry.getter(id);
-  };
-
-  /**
-    Set a global. If not already set, then we assign basic getters and setters.
-  */
-  function gvar_set(id, value) {
-    var entry = global_tbl[id];
-    if (entry)  { return entry.setter(id, value); }
-
-    define_hooked_variable(id,
-
-      function(id) {
-        return global_tbl[id].value;
-      },
-
-      function(id, value) {
-        return (global_tbl[id].value = value);
-      }
-    );
-
-    return gvar_set(id, value);
-  };
-
-  /**
-    Every object has a unique id. This count is used as the next id for the
-    next created object. Therefore, first ruby object has id 0, next has 1 etc.
-  */
-  var hash_yield = 0;
-
-  /**
-    Yield the next object id, updating the count, and returning it.
-  */
-  function yield_hash() {
-    return hash_yield++;
-  };
-
-  /**
-    The root class. Every class in opal is an instance of RClass.
-
-    @constructor
-    @param {RClass} klass
-    @param {RClass} super_klass
-  */
-  var RClass = Vm.RClass = function(klass, super_klass) {
-    this.$id = yield_hash();
-    this.$super = super_klass;
-
-    if (super_klass) {
-      var ctor = function() {};
-      ctor.prototype = super_klass.$m_prototype_tbl;
-
-      var m_ctor = function() {};
-      m_ctor.prototype = new ctor();
-
-      this.$m_tbl = new m_ctor();
-      this.$m_prototype_tbl = m_ctor.prototype;
-
-      var cctor = function() {};
-      cctor.prototype = super_klass.$c_prototype;
-
-      var c_ctor = function() {};
-      c_ctor.prototype = new cctor();
-
-      this.$c = new c_ctor();
-      this.$c_prototype = c_ctor.prototype;
-    }
-    else {
-      var m_ctor = function() {};
-      this.$m_tbl = new m_ctor();
-      this.$m_prototype_tbl = m_ctor.prototype;
-
-      var c_ctor = function() {};
-      this.$c = new c_ctor();
-      this.$c_prototype = c_ctor.prototype;
-    }
-
-    this.$method_table = {};
-    return this;
-  };
-
-  // RClass protoype for minimizing
-  var Rp = RClass.prototype;
-
-  /**
-    Flags. Every RClass instance is simply a T_CLASS, so mark as so.
-  */
-  Rp.$flags = T_CLASS;
-
-  /**
-    RTest/truthiness - every RClass instance is true.
-  */
-  Rp.$r = true;
-
-  /**
-    The root object. Every object in opal (apart from toll free bridged classes
-    like array, string etc) are an instance of RObject.
-
-    @param {RClass} klass
-  */
-  var RObject = Vm.RObject = function(klass) {
-    this.$id = yield_hash();
-    this.$klass = klass;
-    this.$m = klass.$m_tbl;
-    return this;
-  };
-
-  // For minimizing
-  var Bp = RObject.prototype;
-
-  /**
-    Flags - every RObject instance is simply a T_OBJECT
-  */
-  Bp.$flags = T_OBJECT;
-
-  /**
-    RTest - every RObject instance is true.
-  */
-  Bp.$r = true;
-
-  /**
-    The hash of a class or object in ruby is simply it's id, as all objects and
-    classes have unique ids.
-  */
-  Bp.$hash = Rp.$hash = function() {
-    return this.$id;
-  };
-
-  /**
-    Internal method for defining a method.
-
-    @param {RClass} klass The klass to define the method on
-    @param {String} name The method id
-    @param {Function} body Method implementation
-    @return {Qnil}
-  */
-  function define_method(klass, name, body) {
-    klass.$m_prototype_tbl[name] = body;
-    klass.$method_table[name] = body;
-
-    if (klass.$included_in) {
-      for (var i = 0; i < klass.$included_in.length; i++) {
-        klass.$included_in[i].$m_prototype_tbl[name] = body;
-        klass.$included_in[i].$method_table[name] = body;
-      }
-    }
-
-    if (!body.$rbName) {
-      body.$rbName = name;
-    }
-
-    return Qnil;
-  };
-
-  Vm.define_method = define_method;
-
-  function define_singleton_method(klass, name, body) {
-    define_method(singleton_class(klass), name, body);
-  };
-
-  function define_alias(base, new_name, old_name) {
-    define_method(base, new_name, base.$m_tbl[old_name]);
-    return Qnil;
-  };
-
-  /**
-    Implementation for Class#allocate
-  */
-  function obj_alloc(klass) {
-    var result = new RObject(klass, T_OBJECT);
-    return result;
-  };
-
-  /**
-    Raise the exception class with the given string message.
-  */
-  function raise(exc, str) {
-    if (str === undefined) {
-      str = exc;
-      exc = eException;
-    }
-    var exception = exc.$m.allocate(exc);
-    exception.message = str;
-    vm_raise(exception);
-  };
-
-  /**
-    Raise an exception instance (DO NOT pass strings to this)
-  */
-  function vm_raise(exc) {
-    throw exc;
-  };
-
-  Vm.raise = vm_raise;
-
-  /**
-    Throw an argument error when the wrong number of arguments were given to a
-    method.
-
-    @param {Number} given The number of arguments actually given
-    @param {Number} expected The number of arguments we expected to have
-  */
-  function arg_error(given, expected) {
-    raise(eArgError,
-      "wrong number of arguments(" + given + " for " + expected + ")");
-  };
-
-  /**
-    Call a super method.
-
-    callee is the function that actually called super(). We use this to find
-    the right place in the tree to find the method that actually called super.
-    This is actually done in super_find.
-  */
-  Vm.S = function(callee, self, args) {
-    var mid = callee.$rbName;
-    var func = super_find(self.$klass, callee, callee.$rbName);
-
-    if (!func) {
-      raise(eNoMethodError, "super: no superclass method for " + mid);
-      raise(eNoMethodError, "super: no super class method `" + mid + "`" +
-        " for " + self.$m.inspect(self));
-    }
-
-    var args_to_send = [self, mid].concat(args);
-    return func.apply(null, args_to_send);
-  };
-
-  /**
-    Actually find super impl to call.  Returns null if cannot find it.
-  */
-  function super_find(klass, callee, mid) {
-    var cur_method;
-
-    while (klass) {
-      if (klass.$method_table[mid]) {
-        if (klass.$method_table[mid] == callee) {
-          break;
-        }
-      }
-      klass = klass.$super;
-    }
-
-    if (!klass) { return null; }
-
-    klass = klass.$super;
-
-    while (klass) {
-      if (klass.$method_table[mid]) {
-        return klass.$method_table[mid];
-      }
-
-      klass = klass.$super;
-    }
-
-    return null;
-  };
-
-  /**
-    VM method to get a contant from the given base.
-
-    @global
-  */
-  rb_vm_cg = function(base, id) {
-    if (base.$flags & T_OBJECT) {
-      base = class_real(base.$klass);
-    }
-    return const_get(base, id);
-  };
-
-  /**
-    VM method to set a contant in base.
-
-    @global
-  */
-  rb_vm_cs = function(base, id, val) {
-    if (base.$flags & T_OBJECT) {
-      base = class_real(base.$klass);
-    }
-    return const_set(base, id, val);
-  };
-
-  /**
-    Get global by id
-  */
-  Vm.gg = function(id) {
-    return gvar_get(id);
-  };
-
-  /**
-    Set global by id
-  */
-  Vm.gs = function(id, value) {
-    return gvar_set(id, value);
-  };
-
-  /**
-    Getter method for getting the load path for opal.
-
-    @param {String} id The globals id being retrieved.
-    @return {Array} Load paths
-  */
-  function load_path_getter(id) {
-    return opal.loader.paths;
-  };
-
-  /**
-    Getter method to get all loaded features.
-
-    @param {String} id Feature global id
-    @return {Array} Loaded features
-  */
-  function loaded_feature_getter(id) {
-    return loaded_features;
-  };
-
-  /**
-    Main init method. This is called once this file has fully loaded. It setups
-    all the core objects and classes and required runtime features.
-  */
-  function init() {
-
-    var metaclass;
-
-    Vm.BasicObject = cBasicObject = boot_defrootclass('BasicObject');
-    Vm.Object = cObject = boot_defclass('Object', cBasicObject);
-    Vm.Module = cModule = boot_defclass('Module', cObject);
-    Vm.Class = cClass = boot_defclass('Class', cModule);
-
-    const_set(cObject, 'BasicObject', cBasicObject);
-
-    metaclass = make_metaclass(cBasicObject, cClass);
-    metaclass = make_metaclass(cObject, metaclass);
-    metaclass = make_metaclass(cModule, metaclass);
-    metaclass = make_metaclass(cClass, metaclass);
-
-    boot_defmetametaclass(cModule, metaclass);
-    boot_defmetametaclass(cObject, metaclass);
-    boot_defmetametaclass(cBasicObject, metaclass);
-
-    define_method(cBasicObject, "!", obj_not);
-    define_method(cBasicObject, "!=", obj_not_equal);
-
-    mKernel = define_module('Kernel');
-
-    include_module(cObject, mKernel);
-
-    define_method(cClass, "allocate", obj_alloc);
-    define_method(cClass, "new", class_new_instance);
-    define_method(cClass, "initialize", class_initialize);
-    define_singleton_method(cClass, "new", class_s_new);
-
-    define_method(mKernel, "puts", obj_puts);
-
-    Qself = obj_alloc(cObject);
-    Vm.top = Qself;
-
-    cNilClass = define_class('NilClass', cObject);
-    Vm.Qnil = Qnil = obj_alloc(cNilClass);
-    Qnil.$r = false;
-
-    cTrueClass = define_class('TrueClass', cObject);
-    Vm.Qtrue = Qtrue = obj_alloc(cTrueClass);
-
-    cFalseClass = define_class('FalseClass', cObject);
-    Vm.Qfalse = Qfalse = obj_alloc(cFalseClass);
-    Qfalse.$r = false;
-
-    cArray = bridge_class(Array.prototype,
-      T_OBJECT | T_ARRAY, 'Array', cObject);
-
-    Array.prototype.$hash = function() {
-      return (this.$id || (this.$id = yield_hash()));
-    };
-
-    cNumeric = bridge_class(Number.prototype,
-      T_OBJECT | T_NUMBER, 'Numeric', cObject);
-
-    cHash = bridge_class(RHash.prototype,
-      T_OBJECT | T_HASH, 'Hash', cObject);
-
-    RHash.prototype.$hash = function() {
-      return (this.$id || (this.$id = yield_hash()));
-    };
-
-    define_singleton_method(cHash, '[]', hash_s_create);
-
-    cRegexp = bridge_class(RegExp.prototype, T_OBJECT,
-      'Regexp', cObject);
-
-    define_hooked_variable('$:', load_path_getter, gvar_readonly_setter);
-    define_hooked_variable('$LOAD_PATH', load_path_getter, gvar_readonly_setter);
-
-    const_set(cObject, 'ARGV', []);
-
-    eException = bridge_class(Error.prototype, T_OBJECT, 'Exception', cObject);
-
-    eStandardError = define_class("StandardError", eException);
-    eRuntimeError = define_class("RuntimeError", eException);
-    eLocalJumpError = define_class("LocalJumpError", eStandardError);
-    eTypeError = define_class("TypeError", eStandardError);
-    eNameError = define_class("NameError", eStandardError);
-    eNoMethodError = define_class('NoMethodError', eNameError);
-    eArgError = define_class('ArgumentError', eStandardError);
-    eScriptError = define_class('ScriptError', eException);
-    eLoadError = define_class('LoadError', eScriptError);
-
-    eIndexError = define_class("IndexError", eStandardError);
-    eKeyError = define_class("KeyError", eIndexError);
-    eRangeError = define_class("RangeError", eStandardError);
-
-    rb_vm_break_instance = new Error('unexpected break');
-    rb_vm_break_instance.$klass = eLocalJumpError;
-    rb_vm_break_instance.$keyword = 2;
-
-    rb_vm_return_instance = new Error('unexpected return');
-    rb_vm_return_instance.$klass = eLocalJumpError;
-    rb_vm_return_instance.$keyword = 1;
-
-    rb_vm_next_instance = new Error('unexpected next');
-    rb_vm_next_instance.$klass = eLocalJumpError;
-    rb_vm_next_instance.$keyword = 3;
-
-    cString = bridge_class(String.prototype,
-      T_OBJECT | T_STRING, 'String', cObject);
-
-    cSymbol = define_class('Symbol', cObject);
-
-    cProc = bridge_class(Function.prototype,
-      T_OBJECT | T_PROC, 'Proc', cObject);
-
-    Function.prototype.$hash = function() {
-      return (this.$id || (this.$id = yield_hash()));
-    };
-
-    cRange = bridge_class(RRange.prototype, T_OBJECT | T_RANGE,
-      'Range', cObject);
-
-    RRange.prototype.$hash = function() {
-      return (this.$id || (this.$id = yield_hash()));
-    };
-
-    const_set(cObject, 'RUBY_PLATFORM', 'opal');
-  };
-
-  /**
-    Define a top level module with the given id
-  */
-  function define_module(id) {
-    return define_module_under(cObject, id);
-  };
-
-  function define_module_under(base, id) {
-    var module;
-
-    if (const_defined(base, id)) {
-      module = const_get(base, id);
-      if (module.$flags & T_MODULE) {
-        return module;
-      }
-
-      throw id + " is not a module.";
-    }
-
-    module = define_module_id(id);
-    const_set(base, id, module);
-    module.$parent = base;
-    return module;
-  };
-
-  function define_module_id(id) {
-    var module = define_class_id(id, cModule);
-    module.$flags = T_MODULE;
-    name_class(module, id);
-    return module;
-  };
-
-  function mod_create() {
-    return class_boot(cModule);
-  };
-
-  function include_module(klass, module) {
-
-    if (!klass.$included_modules) {
-      klass.$included_modules = [];
-    }
-
-    if (klass.$included_modules.indexOf(module) != -1) {
-      return;
-    }
-    klass.$included_modules.push(module);
-
-    if (!module.$included_in) {
-      module.$included_in = [];
-    }
-
-    module.$included_in.push(klass);
-
-    for (var method in module.$method_table) {
-      if (module.$method_table.hasOwnProperty(method)) {
-        define_method(klass, method, module.$method_table[method]);
-      }
-    }
-  };
-
-  Vm.include_module = include_module;
-
-  function extend_module(klass, module) {
-    if (!klass.$extended_modules) {
-      klass.$extended_modules = [];
-    }
-
-    if (klass.$extended_modules.indexOf(module) != -1) {
-      return;
-    }
-    klass.$extended_modules.push(module);
-
-    if (!module.$extended_in) {
-      module.$extended_in = [];
-    }
-
-    module.$extended_in.push(klass);
-
-    var meta = klass.$klass;
-
-    for (var method in module.$method_table) {
-      if (module.$method_table.hasOwnProperty(method)) {
-        define_method(meta, method, module.$method_table[method]);
-      }
-    }
-  };
-
-  Vm.extend_module = extend_module;
-
-  /**
-    Boot a base class (only used for very core object classes)
-  */
-  function boot_defclass(id, super_klass) {
-    var result = class_boot(super_klass);
-    name_class(result, id);
-    const_set((cObject || result), id, result);
-    return result;
-  };
-
-  /**
-    Like boot_defclass, but for root object only (i.e. basicobject)
-  */
-  function boot_defrootclass(id) {
-    var result = new RClass(null, null);
-    result.$flags = T_CLASS;
-    name_class(result, id);
-    const_set((cObject || result), id, result);
-    return result;
-  };
-
-  function class_boot(super_class) {
-    if (super_class) {
-      var ctor = function() {};
-      ctor.prototype = super_class.constructor.prototype;
-
-      var result = function() {
-        RClass.call(this, null, super_class);
-        return this;
-      };
-      result.prototype = new ctor();
-
-      var klass = new result();
-      klass.$klass = cClass;
-      return klass;
-    }
-    else {
-      var result = new RClass(null, null);
-      return result;
-    }
-  };
-
-  /**
-    @global
-  */
-  function class_real(klass) {
-    while (klass.$flags & FL_SINGLETON) { klass = klass.$super; }
-    return klass;
-  };
-
-  Vm.class_real = class_real;
-
-  /**
-    Name the class with the given id.
-  */
-  function name_class(klass, id) {
-    klass.__classid__ = id;
-  };
-
-  /**
-    Make metaclass for the given class
-  */
-  function make_metaclass(klass, super_class) {
-    if ((klass.$flags & T_CLASS) && (klass.$flags & FL_SINGLETON)) {
-      return make_metametaclass(klass);
-    }
-    else {
-      var meta = class_boot(super_class);
-      meta.$flags |= FL_SINGLETON;
-      klass.$klass = meta;
-      klass.$m = meta.$m_tbl;
-      meta.$c = klass.$c;
-      singleton_class_attached(meta, klass);
-
-      return meta;
-    }
-  };
-
-  function singleton_class_attached(klass, obj) {
-    if (klass.$flags & FL_SINGLETON) {
-      ivar_set(klass, '__attached__', obj);
-    }
-  };
-
-  function make_metametaclass(metaclass) {
-    var metametaclass, super_of_metaclass;
-
-    if (metaclass.$klass == metaclass) {
-      metametaclass = class_boot(null);
-      metametaclass.$klass = metametaclass;
-    }
-    else {
-      metametaclass = class_boot(null);
-      metametaclass.$klass = metaclass.$klass.$klass == metaclass.$klass
-        ? make_metametaclass(metaclass.$klass)
-        : metaclass.$klass.$klass;
-    }
-
-    metametaclass.$flags |= FL_SINGLETON;
-
-    singleton_class_attached(metametaclass, metaclass);
-    metaclass.$klass = metametaclass;
-    metaclass.$m = metametaclass.$m_tbl;
-    super_of_metaclass = metaclass.$super;
-
-    metametaclass.$super = ivar_get(super_of_metaclass.$klass, '__attached__')
-      == super_of_metaclass
-      ? super_of_metaclass.$klass
-      : make_metametaclass(super_of_metaclass);
-
-    return metametaclass;
-  };
-
-  function boot_defmetametaclass(klass, metametaclass) {
-    klass.$klass.$klass = metametaclass;
-  };
-
-  /**
-    Define toll free bridged class
-  */
-  function bridge_class(prototype, flags, id, super_class) {
-    var klass = define_class(id, super_class);
-
-    prototype.$klass = klass;
-    prototype.$m = klass.$m_tbl;
-    prototype.$flags = flags;
-    prototype.$r = true;
-
-    prototype.$hash = function() {
-      return flags + '_' + this;
-    };
-
-    return klass;
-  };
-
-  /**
-    Define a new class (normal way), with the given id and superclass. Will be
-    top level.
-  */
-  function define_class(id, super_klass) {
-    return define_class_under(cObject, id, super_klass);
-  };
-
-  function define_class_under(base, id, super_klass) {
-    var klass;
-
-    if (const_defined(base, id)) {
-      return const_get(base, id);
-    }
-
-    klass = define_class_id(id, super_klass);
-
-    name_class(klass, id);
-    const_set(base, id, klass);
-    klass.$parent = base;
-    return klass;
-  };
-
-  /**
-    Actually create class
-  */
-  function define_class_id(id, super_klass) {
-    var klass;
-
-    if (!super_klass) {
-      super_klass = cObject;
-    }
-    klass = class_create(super_klass);
-    name_class(klass, id);
-    make_metaclass(klass, super_klass.$klass);
-    return klass;
-  };
-
-  function class_create(super_klass) {
-    return class_boot(super_klass);
-  };
-
-  /**
-    Get singleton class of obj
-  */
-  function singleton_class(obj) {
-    var obj;
-
-    if ((obj.$klass.$flags & FL_SINGLETON)&& ivar_get(obj.$klass, '__attached__') == obj) {
-      klass = obj.$klass;
-    }
-    else {
-      var class_id = obj.$klass.__classid__;
-      klass = make_metaclass(obj, obj.$klass);
-    }
-
-    return klass;
-  };
-
-  function RHash(args) {
-    var k, v;
-    this.$keys = [];
-    this.$assocs = {};
-    this.$default = Qnil;
-
-    for (var i = 0; i < args.length; i++) {
-      k = args[i];
-      v = args[i+1];
-      i++;
-      this.$keys.push(k);
-      this.$assocs[k.$hash()] = v;
-    }
-    return this;
-  };
-
-  /**
-    Symbol table. All symbols are stored here.
-  */
-  var symbol_table = { };
-
-  /**
-    Range ruby object
-  */
-  function RRange(beg, end, exclude_end) {
-    this.$beg = beg;
-    this.$end = end;
-    this.$exc = exclude_end;
-    return this;
-  };
-
-  /**
-    Creates a new hash populated with the given objects. Equivalent to the
-    literal `{ key => value, ... }`.
-
-    @example
-      Hash["a", 100, "b", 200]
-      # => {"a" =>100, "b"=>200}
-
-    @return [Hash]
-  */
-  function hash_s_create(obj, mid) {
-    return opalhash.apply(null, Array.prototype.slice.call(arguments, 2));
-  };
-
-  function class_s_new(cls, sup) {
-    var klass = define_class_id("AnonClass", sup || cObject);
-    return klass;
-  };
-
-  function class_new_instance(cls) {
-    var obj = cls.$m.allocate(cls);
-    var args = Array.prototype.slice.call(arguments, 1);
-    args.unshift(obj);
-
-    if (Vm.P.f == arguments.callee) {
-      VM.P.f = obj.$m.initialize;
-    }
-
-    obj.$m.initialize.apply(obj, args);
-    return obj;
-  };
-
-  function class_initialize(cla, mid, sup) {
-    var klass = define_class_id('', sup || cObject);
-    return klass;
-  };
-
-  /**
-    Prints each argument in turn to the browser console. Currently there is no
-    use of `$stdout`, so it is hardcoded into this method to write to the
-    console directly.
-
-    @param {Object} args objects to print using `inspect`
-    @return {nil}
-  */
-  function obj_puts(obj) {
-    var args = Array.prototype.slice.call(arguments, 1);
-
-    for (var i = 0; i < args.length; i++) {
-      console.log((args[i].$m.to_s(args[i])).toString());
-    }
-
-    return Qnil;
-  };
-
-  /**
-    @example
-      !obj  # => true or false
-  */
-  function obj_not(obj, mid) {
-    return obj.$r ? Qfalse : Qtrue;
-  };
-
-  /**
-    @example
-      obj != obj2  # => true or false
-  */
-  function obj_not_equal(obj1, mid, obj2) {
-    var res = obj1.$m['=='](obj1, obj2);
-    return res.$r ? Qfalse : Qtrue;
-  };
-
-  // ..........................................................
-  // FILESYSTEM
-  //
-
-  // added to main opal namespace, and Fs for minimizing here.
-  var Fs = Op.fs = {};
-
-  /**
-    Regular expression used for splitting filenames into their dirname,
-    basename and extension. This is unix style only, as filenames inside
-    opal in the browser will only ever have this style of filename. The gem
-    fs support will depend on the platform being run.
-  **/
-  var PATH_RE = /^(.+\/(?!$)|\/)?((?:.+?)?(\.[^.]*)?)$/;
-
-  /**
-    Holds the current working directory for the application. This is '/' by
-    default, but is usually set to the base directory of the main gem.
-
-    @type {String}
-  */
-  Fs.cwd = '/';
-
-  /**
-    Join the given args using the default seperator. The path returned is not
-    expanded.
-
-    @param {arguments<String<} args The arguments to join
-    @return {String}
-  */
-  var file_join = Fs.join = function() {
-    var parts = [].slice.call(arguments, 0);
-    return parts.join('/');
-  };
-
-  /**
-    Normalize the path by removing '..' and '.' parts, remove '//' etc to
-    return a nice normalized path.
-
-    @param {String} path The path needing normalization
-    @param {String} base Optional base to normalize to
-    @return {String} Normalized path
-  */
-  var file_expand_path = Fs.expand_path = function(path, base) {
-    path = file_join(base || Fs.cwd, path);
-
-    var parts = path.split('/'), result = [], part;
-
-    // initial /
-    if (parts[0] === '') result.push('');
-
-    for (var i = 0, ii = parts.length; i < ii; i++) {
-      part = parts[i];
-
-      if (part == '..') {
-        result.pop();
-      }
-      else if (part == '.' || part == '') {
-
-      }
-      else {
-        result.push(part);
-      }
-    }
-
-    return result.join('/');
-  };
-
-  /**
-    Returns all of the components of the given `file_name` except for the last
-    one.
-
-    @param {String} file_name
-    @return {String}
-  */
-  var file_dirname = Fs.dirname = function(file_name) {
-    var dirname = PATH_RE.exec(file_name)[1];
-
-    if (!dirname) return '.';
-    else if (dirname === '/') return dirname;
-    else return dirname.substring(0, dirname.length - 1);
-  };
-
-  /**
-    Returns the file extension of the given `file_name`.
-
-    @param {String} file_name
-    @return {String}
-  */
-  Fs.extname = function(file_name) {
-    var extname = PATH_RE.exec(file_name)[3];
-
-    if (!extname || extname === '.') return '';
-    else return extname;
-  };
-
-
-  // ..........................................................
-  // LOADER
-  //
-
-  /**
-    Require a module.
-
-    @param {String} id The module id
-    @return {Object} returns the exports
-  */
-  Op.require = function(id, parent) {
-    var resolved = Op.loader.resolve_module(id, null);
-    var cached = Op.cache[resolved];
-
-    if (cached) {
-      return true;
-    }
-
-    Op.cache[resolved] = true;
-    // try/catch?
-    load_file(Op.loader, resolved);
-
-    return true;
-  };
-
-  // Virtual machine must also be able to require..
-  Vm.require = Op.require;
-
-  /**
-    Register a package with the given package info.
-
-    This will probably (definately??) always be done only in the browser.
-
-    @param {String} name The package name
-    @param {Object} info The package info
-  */
-  Op.register = function(name, info) {
-
-    // make sure we get a string name
-    if (typeof name !== 'string') {
-      throw new Error("Cannot register a package without a proper name");
-    }
-
-    // registering a single module/file
-    if (typeof info === 'string' || typeof info === 'function') {
-      register_module(name, info);
-    }
-    // make sure info is a proper package
-    else if (typeof info === 'object') {
-      register_package(name, info);
-    }
-    // else, we have an error.. we can only register packages or modules
-    else {
-      throw new Error("Invalid package.json data for '" + name + "'");
-    }
-  };
-
-  /**
-    Private method to actually register the package. This is private to
-    avoid external interferance. This will be called from {opal#register}.
-
-    @param {String} name The package name
-    @param {Object} info The package information
-  */
-  var register_package = function(name, info) {
-    var factories = Op.loader.factories,
-        paths     = Op.loader.paths;
-
-    // register all files
-    var files = info.files || {};
-
-    // root dir for package is /package_name
-    var root_dir = '/' + name;
-
-    // assume './lib' dir for lib files (for now.. should be dynamic)
-    var lib_dir = './lib';
-
-    // add lib dir to paths
-    paths.unshift(file_expand_path(file_join(root_dir, lib_dir)));
-
-    for (var file in files) {
-      if (files.hasOwnProperty(file)) {
-        // full path to file; we use the root dir
-        var file_path = file_expand_path(file_join(root_dir, file));
-
-        factories[file_path] = files[file];
-      }
-    }
-
-    ////////////////////////////////////////
-    // Autobooting. Basically, autoload opal.
-    //
-    if (name === 'opal') {
-      Op.require(name);
-    }
-  };
-
-  /**
-    Private method to register a single module. These modules are added to the
-    very top level dir: /module_name.js
-  */
-  var register_module = function(name, factory) {
-    // name gets preceeded with a '/' for root files
-    var factory_name = '/' + name;
-
-    Op.loader.factories[factory_name] = factory;
-  };
-
-
-  // valid extensions for loading
-  var load_extensions = {};
-
-  load_extensions['.js'] = function(loader, filename) {
-    var source = loader.module_contents(filename);
-    return execute_file(loader, source, filename);
-  };
-
-  load_extensions['.rb'] = function(loader, filename) {
-    var source = loader.ruby_module_contents(filename);
-    return execute_file(loader, source, filename);
-  };
-
-  /**
-    The loader is the core machinery used for loading and executing modules
-    within opal. An instance of opal will have a .loader property, which
-    is an instance of this Loader class. A Loader is responsible for finding,
-    opening and reading the contents of modules on disk. Within the browser,
-    which is the default environment, a loader will use XHR requests or cached
-    modules from JSON to load the required modules.
-
-    Within the browser, the loader, currently, just looks at its opal
-    instance for registered files and packages and uses them as needed.
-    opal also has 'built in' packages from commonjs, like 'system' etc, so
-    all loaders must check opal first for registered packages.
-
-    @param {opal} opal The opal instance for this loader
-  */
-  var Loader = function(opal) {
-    this.opal = opal;
-    this.paths = [''];
-
-    this.factories = {};
-
-
-    return this;
-  };
-
-  // Loader prototype
-  var Lp = Loader.prototype;
-
-  /**
-    The paths property is an array of disk paths in which to search for
-    required modules. In the browser this functionality isn't really used.
-
-    This array is created within the constructor method for uniqueness
-    between instances for correct sandboxing.
-  */
-  Lp.paths = null;
-
-  /**
-    factories of registered packages, paths => function/string. This is
-    generic, but in reality only the browser uses this, and it is treated
-    as the mini filesystem. Not just factories can go here, anything can!
-    Images, text, json, whatever.
-  */
-  Lp.factories = {};
-
-  /**
-    Valid factory format for use in require();
-  */
-  Lp.valid_extensions = ['.js', '.rb'];
-
-  /**
-    Resolves the path to the module, which can then be used to load. This
-    method will throw an error if the module cannot be found. If this method
-    returns a successful filename, then subsequent methods like load_module
-    should be successful and should not throw errors.
-
-    @param {String} id The id to look for
-    @param {Module} parent The module that has requested the id
-  */
-  Lp.resolve_module = function(id, parent) {
-    var resolved = this.find_module(id, this.paths);
-
-    if (!resolved) {
-      throw new Error("Cannot find module '" + id + "'");
-    }
-
-    return resolved;
-  };
-
-  Lp.find_module = function(id, paths) {
-    var extensions = this.valid_extensions, factories = this.factories, candidate;
-
-    for (var i = 0, ii = paths.length; i < ii; i++) {
-      for (var j = 0, jj = extensions.length; j < jj; j++) {
-        candidate = file_join(paths[i], id + extensions[j]);
-
-        console.log(candidate);
-        if (factories[candidate]) {
-          return candidate;
-        }
-      }
-    }
-
-    return null;
-  };
-
-  /**
-    Module contents
-  */
-  Lp.module_contents = function(filename) {
-    return this.factories[filename];
-  };
-
-  /**
-    Actually load the file with the given resolved filename. This filename has
-    been checked, and is known to exist.
-  */
-  function load_file(loader, filename) {
-    var extension = load_extensions[PATH_RE.exec(filename)[3] || '.js'];
-
-    if (!extension) {
-      throw new Error("Loader.load - Bad extension for resolved path");
-    }
-
-    extension(loader, filename);
-  };
-
-  /**
-    Run content, which by now must be javascript. If the content is a string,
-    then it is simply evaluated. Within the browser it might be a function, so
-    we call it, passing our standard args.
-
-    The arguments we pass are standardised as:
-
-      VM - Our opal vm variable which exposes runtime methods
-      Qself - the top level ruby object, which is the 'self' for files
-      filename - the Filename to run the file as for __FILE__
-
-    @param {String, Function} content The javascript content to be run.
-    @param {String} filename Filename to run content as.
-  */
-  function execute_file(loader, content, filename) {
-
-    var args = [Vm, Qself, filename];
-
-    if (typeof content === 'function') {
-      return content.apply(Op, args);
-
-    } else if (typeof content === 'string') {
-      var func = loader.wrap(content, filename);
-      return func.apply(Op, args);
-
-    } else {
-      throw new Error(
-        "Loader.execute - bad content sent for '" + filename + "'");
-    }
-  };
-
-  // ..........................................................
-  // FINAL INITILIZATION
-  //
-
-  // init ruby runtime
-  init();
-
-  // browser based loader - overriden by v8 context
-  Op.loader = new Loader(Op);
-
-  // cache of filenames already evaluated
-  Op.cache = {};
-
-})();
-
-// if in a commonjs system already (node etc), exports become our opal
-// object. Otherwise, in the browser, we just get a top level opal var
-if ((typeof require !== 'undefined') && (typeof module !== 'undefined')) {
-  module.exports = opal;
-}
-