opal 0.3.15 → 0.3.16

data/runtime/gemlib/alpha.rb

@@ -1,5 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-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

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

data/runtime/kernel/class.js

@@ -1,256 +0,0 @@
-// 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

@@ -1,42 +0,0 @@
-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

@@ -1,114 +0,0 @@
-// 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; };

data/runtime/kernel/load_order

@@ -1,5 +0,0 @@
-runtime
-class
-loader
-debug
-init