opal 0.3.11 → 0.3.15

data/runtime/corelib/top_self.rb

@@ -0,0 +1,7 @@
+def self.to_s
+  'main'
+end
+
+def self.include(mod)
+  Object.include mod
+end

data/runtime/gemlib/alpha.rb

@@ -0,0 +1,5 @@
+# In gem, use 'opal-ruby'. Browser uses 'opal-browser'.
+RUBY_ENGINE = 'opal-ruby'
+
+# Gvars do not currently support aliasing - so we need to change both.
+$: = $LOAD_PATH = `opal_filesystem.find_paths`

data/runtime/gemlib/kernel.rb

@@ -0,0 +1,17 @@
+module Kernel
+  def require(path)
+    %x{
+      var resolved = opal_filesystem.require(#{path}, #{$:});
+
+      if (resolved === false) {
+        return false;
+      }
+      else if (!resolved) {
+        #{ raise LoadError, "cannot load file -- #{path}" };
+      }
+      else {
+        return true;
+      }
+    }
+  end
+end

data/runtime/gemlib/load_order

@@ -0,0 +1,2 @@
+alpha
+kernel

data/runtime/kernel/class.js

@@ -0,0 +1,256 @@
+// Root of all objects and classes inside opal
+function RootObject() {};
+
+RootObject.prototype.toString = function() {
+  if (this.$flags & T_OBJECT) {
+    return "#<" + (this.$klass).__classid__ + ":0x" + this.$id + ">";
+  }
+  else {
+    return '<' + this.__classid__ + ' ' + this.$id + '>';
+  }
+};
+
+// Boot a base class (makes instances).
+function boot_defclass(superklass) {
+  var cls = function() {
+    this.$id = unique_id++;
+
+    return this;
+  };
+
+  if (superklass) {
+    var ctor           = function() {};
+        ctor.prototype = superklass.prototype;
+
+    cls.prototype = new ctor();
+  }
+  else {
+    cls.prototype = new RootObject();
+  }
+
+  cls.prototype.constructor = cls;
+  cls.prototype.$flags          = T_OBJECT;
+
+  return cls;
+}
+
+// Boot actual (meta classes) of core objects.
+function boot_makemeta(id, klass, superklass) {
+  var meta = function() {
+    this.$id = unique_id++;
+
+    return this;
+  };
+
+  var ctor           = function() {};
+      ctor.prototype = superklass.prototype;
+
+  meta.prototype = new ctor();
+
+  var proto              = meta.prototype;
+      proto.$included_in = [];
+      proto.$m           = {};
+      proto.$methods     = [];
+      proto.$allocator   = klass;
+      proto.$flags       = T_CLASS;
+      proto.__classid__  = id;
+      proto.$s           = superklass;
+      proto.constructor  = meta;
+
+  var result = new meta();
+  klass.prototype.$klass = result;
+  result.$proto = klass.prototype;
+
+  return result;
+}
+
+// Create generic class with given superclass.
+function boot_class(superklass) {
+  // instances
+  var cls = function() {
+    this.$id = unique_id++;
+
+    return this;
+  };
+
+  var ctor = function() {};
+      ctor.prototype = superklass.$allocator.prototype;
+
+  cls.prototype = new ctor();
+
+  var proto             = cls.prototype;
+      proto.constructor = cls;
+      proto.$flags          = T_OBJECT;
+
+  // class itself
+  var meta = function() {
+    this.$id = unique_id++;
+
+    return this;
+  };
+
+  var mtor = function() {};
+      mtor.prototype = superklass.constructor.prototype;
+
+  meta.prototype = new mtor();
+
+  proto                            = meta.prototype;
+  proto.$allocator                 = cls;
+  proto.$flags                     = T_CLASS;
+  proto.$m                         = {};
+  proto.$methods                   = [];
+  proto.constructor                = meta;
+  proto.$s                         = superklass;
+
+  var result = new meta();
+  cls.prototype.$klass = result;
+  
+  result.$proto = cls.prototype;
+
+  return result;
+}
+
+function boot_module() {
+  // where module "instance" methods go. will never be instantiated so it
+  // can be a regular object
+  var module_cons = function(){};
+  var module_inst = module_cons.prototype;
+  
+  // Module itself
+  var meta = function() {
+    this.$id = unique_id++;
+    return this;
+  };
+  
+  var mtor = function(){};
+  mtor.prototype = RubyModule.constructor.prototype;
+  meta.prototype = new mtor();
+  
+  var proto = meta.prototype;
+  proto.$allocator  = module_cons;
+  proto.$flags      = T_MODULE;
+  proto.constructor = meta;
+  proto.$s          = RubyModule;
+  
+  var module          = new meta();
+  module.$proto       = module_inst;
+  
+  return module;
+}
+
+// Get actual class ignoring singleton classes and iclasses.
+function class_real(klass) {
+  while (klass.$flags & FL_SINGLETON) {
+    klass = klass.$s;
+  }
+
+  return klass;
+}
+
+// Make metaclass for the given class
+function make_metaclass(klass, superklass) {
+  if (klass.$flags & T_CLASS) {
+    if ((klass.$flags & T_CLASS) && (klass.$flags & FL_SINGLETON)) {
+      raise(RubyException, "too much meta: return klass?");
+    }
+    else {
+      var class_id = "#<Class:" + klass.__classid__ + ">",
+          meta     = boot_class(superklass);
+
+      meta.__classid__ = class_id;
+      meta.$allocator.prototype = klass.constructor.prototype;
+      meta.$flags |= FL_SINGLETON;
+
+      klass.$klass = meta;
+
+      meta.$const = klass.$const;
+      meta.__attached__ = klass;
+
+      return meta;
+    }
+  }
+  else {
+    return make_singleton_class(klass);
+  }
+}
+
+function make_singleton_class(obj) {
+  var orig_class = obj.$klass,
+      class_id   = "#<Class:#<" + orig_class.__classid__ + ":" + orig_class.$id + ">>";
+
+  klass             = boot_class(orig_class);
+  klass.__classid__ = class_id;
+
+  klass.$flags                |= FL_SINGLETON;
+  klass.$bridge_prototype  = obj;
+
+  obj.$klass = klass;
+
+  klass.__attached__ = obj;
+
+  klass.$klass = class_real(orig_class).$k;
+
+  return klass;
+}
+
+function bridge_class(constructor, flags, id) {
+  var klass     = define_class(RubyObject, id, RubyObject),
+      prototype = constructor.prototype;
+
+  klass.$allocator = constructor;
+  klass.$proto = prototype;
+
+  bridged_classes.push(klass);
+
+  prototype.$klass = klass;
+  prototype.$flags = flags;
+
+  return klass;
+}
+
+// Define new ruby class
+function define_class(base, id, superklass) {
+  var klass;
+
+  var class_id = (base === RubyObject ? id : base.__classid__ + '::' + id);
+
+  klass             = boot_class(superklass);
+  klass.__classid__ = class_id;
+
+  make_metaclass(klass, superklass.$klass);
+
+  var const_alloc   = function() {};
+  var const_scope   = const_alloc.prototype = new base.$const.alloc();
+  klass.$const      = const_scope;
+  const_scope.alloc = const_alloc;
+
+  base.$const[id] = klass;
+
+  if (superklass.m$inherited) {
+    superklass.m$inherited(null, klass);
+  }
+
+  return klass;
+}
+
+// Get singleton class of obj
+function singleton_class(obj) {
+  var klass;
+
+  if (obj.$flags & T_OBJECT) {
+    if ((obj.$flags & T_NUMBER) || (obj.$flags & T_STRING)) {
+      raise(RubyTypeError, "can't define singleton");
+    }
+  }
+
+  if ((obj.$klass.$flags & FL_SINGLETON) && obj.$klass.__attached__ == obj) {
+    klass = obj.$klass;
+  }
+  else {
+    var class_id = obj.$klass.__classid__;
+
+    klass = make_metaclass(obj, obj.$klass);
+  }
+
+  return klass;
+}

data/runtime/kernel/debug.js

@@ -0,0 +1,42 @@
+function exc_backtrace(err) {
+  var old = Error.prepareStackTrace;
+  Error.prepareStackTrace = prepare_backtrace;
+
+  var backtrace = err.stack;
+  Error.prepareStackTrace = old;
+
+  if (backtrace && backtrace.join) {
+    return backtrace;
+  }
+
+  return ["No backtrace available"];
+}
+
+function prepare_backtrace(error, stack) {
+  var code = [], f, b, k, name, self;
+
+  for (var i = 0; i < stack.length; i++) {
+    f = stack[i];
+    b = f.getFunction();
+    name = f.getMethodName();
+    self = f.getThis();
+    
+    if (!self.$klass || !name) {
+      continue;
+    }
+    
+    self  = (self.$flags & T_OBJECT ?
+           class_real(self.$klass).__classid__ + '#' :
+           self.__classid__ + '.');
+
+    code.push("from " + self + jsid_to_mid(name) + ' at ' + f.getFileName() + ":" + f.getLineNumber());
+  }
+
+  return code;
+}
+
+// Print error backtrace to console
+opal.backtrace = opal.bt = function(err) {
+  console.log(err.$klass.__classid__ + ": " + err.message);
+  console.log("\t" + exc_backtrace(err).join("\n\t"));
+};

data/runtime/kernel/init.js

@@ -0,0 +1,114 @@
+// Initialization
+// --------------
+
+// The *instances* of core objects
+var BootObject = boot_defclass();
+var BootModule = boot_defclass(BootObject);
+var BootClass  = boot_defclass(BootModule);
+
+// The *classes' of core objects
+var RubyObject = boot_makemeta('Object', BootObject, BootClass);
+var RubyModule = boot_makemeta('Module', BootModule, RubyObject.constructor);
+var RubyClass = boot_makemeta('Class', BootClass, RubyModule.constructor);
+
+// Fix boot classes to use meta class
+RubyObject.$klass = RubyClass;
+RubyModule.$klass = RubyClass;
+RubyClass.$klass = RubyClass;
+
+// fix superclasses
+RubyObject.$s = null;
+RubyModule.$s = RubyObject;
+RubyClass.$s = RubyModule;
+
+opal.Object = RubyObject;
+opal.Module = RubyModule;
+opal.Class  = RubyClass;
+
+// make object act like a module
+var bridged_classes = RubyObject.$included_in = [];
+
+// Top level Object scope (used by object and top_self).
+var top_const_alloc     = function(){};
+var top_const_scope     = top_const_alloc.prototype;
+top_const_scope.alloc   = top_const_alloc; 
+
+RubyObject.$const = opal.constants = top_const_scope;
+
+var module_const_alloc = function(){};
+var module_const_scope = new top_const_alloc();
+module_const_scope.alloc = module_const_alloc;
+RubyModule.$const = module_const_scope;
+
+var class_const_alloc = function(){};
+var class_const_scope = new top_const_alloc();
+class_const_scope.alloc = class_const_alloc;
+RubyClass.$const = class_const_scope;
+
+RubyObject.$const.BasicObject = RubyObject;
+RubyObject.$const.Object = RubyObject;
+RubyObject.$const.Module = RubyModule;
+RubyObject.$const.Class = RubyClass;
+
+RubyModule.$allocator.prototype.$donate = function(methods) {
+  var included_in = this.$included_in, includee, method, table = this.$proto, dest;
+
+  if (included_in) {
+    for (var i = 0, length = included_in.length; i < length; i++) {
+      includee = included_in[i];
+      dest = includee.$proto;
+      for (var j = 0, jj = methods.length; j < jj; j++) {
+        method = methods[j];
+        // if (!dest[method]) {
+          dest[method] = table[method];
+        // }
+      }
+      // if our includee is itself included in another module/class then it
+      // should also donate its new methods
+      if (includee.$included_in) {
+        includee.$donate(methods);
+      }
+    }
+  }
+};
+
+var top_self = opal.top = new RubyObject.$allocator();
+
+var RubyNilClass  = define_class(RubyObject, 'NilClass', RubyObject);
+var nil = opal.nil = new RubyNilClass.$allocator();
+
+var RubyArray     = bridge_class(Array, T_OBJECT | T_ARRAY, 'Array');
+var RubyNumeric   = bridge_class(Number, T_OBJECT | T_NUMBER, 'Numeric');
+
+var RubyHash      = bridge_class(Hash, T_OBJECT, 'Hash');
+
+var RubyString    = bridge_class(String, T_OBJECT | T_STRING, 'String');
+var RubyBoolean   = bridge_class(Boolean, T_OBJECT | T_BOOLEAN, 'Boolean');
+var RubyProc      = bridge_class(Function, T_OBJECT | T_PROC, 'Proc');
+var RubyRegexp    = bridge_class(RegExp, T_OBJECT, 'Regexp');
+
+var RubyMatch     = define_class(RubyObject, 'MatchData', RubyObject);
+var RubyRange     = define_class(RubyObject, 'Range', RubyObject);
+
+var RubyException      = bridge_class(Error, T_OBJECT, 'Exception');
+var RubyStandardError  = define_class(RubyObject, 'StandardError', RubyException);
+var RubyRuntimeError   = define_class(RubyObject, 'RuntimeError', RubyException);
+var RubyLocalJumpError = define_class(RubyObject, 'LocalJumpError', RubyStandardError);
+var RubyTypeError      = define_class(RubyObject, 'TypeError', RubyStandardError);
+var RubyNameError      = define_class(RubyObject, 'NameError', RubyStandardError);
+var RubyNoMethodError  = define_class(RubyObject, 'NoMethodError', RubyNameError);
+var RubyArgError       = define_class(RubyObject, 'ArgumentError', RubyStandardError);
+var RubyScriptError    = define_class(RubyObject, 'ScriptError', RubyException);
+var RubyLoadError      = define_class(RubyObject, 'LoadError', RubyScriptError);
+var RubyIndexError     = define_class(RubyObject, 'IndexError', RubyStandardError);
+var RubyKeyError       = define_class(RubyObject, 'KeyError', RubyIndexError);
+var RubyRangeError     = define_class(RubyObject, 'RangeError', RubyStandardError);
+var RubyNotImplError   = define_class(RubyObject, 'NotImplementedError', RubyException);
+
+RubyException.$allocator.prototype.toString = function() {
+  return this.$klass.__classid__ + ': ' + this.message;
+};
+
+var breaker = opal.breaker  = new Error('unexpected break');
+    breaker.$klass              = RubyLocalJumpError;
+    breaker.$t              = function() { throw this; };