opal 0.3.6 → 0.3.9

data/{opal_lib/opal/ruby/ruby_parser.y → lib/opal/parser.y}

@@ -1,4 +1,4 @@
-class Opal::RubyParser
+class Opal::Parser < Racc::Parser
 
 token CLASS MODULE DEF UNDEF BEGIN RESCUE ENSURE END IF UNLESS
       THEN ELSIF ELSE CASE WHEN WHILE UNTIL FOR BREAK NEXT
@@ -14,7 +14,7 @@ token CLASS MODULE DEF UNDEF BEGIN RESCUE ENSURE END IF UNLESS
       '~' '%' '/' '+' '-' '<' '>' '|' '!' '^'
       '{@' '}' BACK_REF2 SYMBOL_BEG STRING_BEG XSTRING_BEG REGEXP_BEG
       WORDS_BEG AWORDS_BEG STRING_DBEG STRING_DVAR STRING_END STRING
-      SYMBOL '\\n' '?' ':' ',' SPACE ';' LABEL
+      SYMBOL '\\n' '?' ':' ',' SPACE ';' LABEL UNDEFINED NULL
 
 prechigh
   right    '!' '~' '+@'
@@ -150,11 +150,11 @@ expr:
     }
   | NOT expr
     {
-      result = CallNode.new val[1], {:value => '!', :line => 0}, []
+      result = UnaryNode.new({:line => val[0][:line], :value => '!'} , val[1])
     }
   | '!' command_call
     {
-      result = CallNode.new val[1], val[0], []
+      result = UnaryNode.new({:line => val[0][:line], :value => '!'} , val[1])
     }
   | arg
 
@@ -399,15 +399,13 @@ arg:
     {
       result = CallNode.new val[0], val[1], [[val[2]]]
     }
-  | '-@NUM' INTEGER '**' arg
-  | '-@NUM' FLOAT '**' arg
   | '+@' arg
     {
-      result = CallNode.new val[1], val[0], []
+      result = UnaryNode.new({:line => val[0][:line], :value => '+'} , val[1])
     }
   | '-@' arg
     {
-      result = CallNode.new val[1], val[0], []
+      result = UnaryNode.new({:line => val[0][:line], :value => '-'} , val[1])
     }
   | arg '|' arg
     {
@@ -427,23 +425,23 @@ arg:
     }
   | arg '>' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ComparisonNode.new val[1], val[0], val[2]
     }
   | arg '>=' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ComparisonNode.new val[1], val[0], val[2]
     }
   | arg '<' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ComparisonNode.new val[1], val[0], val[2]
     }
   | arg '<=' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ComparisonNode.new val[1], val[0], val[2]
     }
   | arg '==' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ComparisonNode.new val[1], val[0], val[2]
     }
   | arg '===' arg
     {
@@ -451,7 +449,7 @@ arg:
     }
   | arg '!=' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = ComparisonNode.new val[1], val[0], val[2]
     }
   | arg '=~' arg
     {
@@ -463,7 +461,7 @@ arg:
     }
   | '!' arg
     {
-      result = CallNode.new val[1], val[0], []
+      result = UnaryNode.new({:line => val[0][:line], :value => '!'} , val[1])
     }
   | '~' arg
     {
@@ -751,13 +749,16 @@ primary:
   | CASE opt_terms ELSE compstmt END
   | FOR block_var IN
     {
-      result = "this.cond_push(1);"
+      cond_push 1
     }
     expr_value do
     {
-      result = "this.cond_pop();"
+      cond_pop
     }
     compstmt END
+    {
+      result = ForNode.new val[0], val[1], val[4], val[7], val[8]
+    }
   | CLASS cpath superclass bodystmt END
     {
       result = ClassNode.new val[0], val[1], val[2], val[3], val[4]
@@ -1003,7 +1004,13 @@ exc_var:
 
 opt_ensure:
     ENSURE compstmt
+    {
+      result = val[1]
+    }
   | none
+    {
+      result = nil
+    }
 
 literal:
     numeric
@@ -1183,12 +1190,20 @@ variable:
     }
   | CVAR
     {
-      result = "result = ['cvar', val[0]];"
+      result = CvarNode.new val[0]
     }
   | NIL
     {
       result = NilNode.new val[0]
     }
+  | UNDEFINED
+    {
+      result = UndefinedNode.new val[0]
+    }
+  | NULL
+    {
+      result = NullNode.new val[0]
+    }
   | SELF
     {
       result = SelfNode.new val[0]
@@ -1451,4 +1466,9 @@ none_block_pass:
 
 end
 
+---- header
+
+require 'opal/lexer'
+require 'opal/nodes'
+
 ---- inner

data/lib/rbp.rb

@@ -0,0 +1,2 @@
+require 'rbp/package'
+

data/lib/rbp/package.rb

@@ -0,0 +1,49 @@
+require 'yaml'
+
+module RBP
+
+  class Package
+
+    attr_reader :root
+
+    def initialize(root = Dir.getwd)
+      @root = root
+      __load_yml
+    end
+
+    def __load_yml
+      yml_path = File.join @root, 'package.yml'
+
+      unless File.exists? yml_path
+        raise "Missing package.yml in `#{@root}'"
+      end
+
+      @yml = YAML.load File.read(yml_path)
+
+      raise "Bad package.yml" unless @yml and @yml['name'] and @yml['version']
+    end
+
+    # Returns an array of lib files relative to the root of
+    # this package
+    def lib_files
+      libs = nil
+
+      Dir.chdir(File.join @root, 'lib') do
+        libs = Dir['**/*.rb']
+      end
+
+      libs
+    end
+
+    # package name
+    def name
+      @yml['name']
+    end
+
+    # package version
+    def version
+      @yml['version']
+    end
+  end
+end
+

data/runtime/class.js

@@ -1,303 +1,333 @@
 /**
-  Every class in opal is an instance of RClass
+  Root of all objects and classes inside opalscript, except for
+  native toll free bridges.
+*/
+var rb_boot_root = function() {};
 
-  @param {RClass} klass
-  @param {RClass} superklass
+/**
+  Returns the hash value for the receiver. By default on regular
+  objects this is just the objects' id
 */
-var RClass = Rt.RClass = function(klass, superklass) {
-  this.$id = yield_hash();
-  this.$super = superklass;
+rb_boot_root.$h = function() {
+  return this.$id;
+};
 
-  if (superklass) {
-    var mtor = function() {};
-    mtor.prototype = new superklass.$m_tor();
-    this.$m_tbl = mtor.prototype;
-    this.$m_tor = mtor;
+/**
+  To benefit javascript debug consoles, the toString of any ruby
+  object is its' #inspect method.
+*/
+rb_boot_root.toString = function() {
+  return this.m$inspect();
+};
 
-    var cctor = function() {};
-    cctor.prototype = superklass.$c_prototype;
+/**
+  Boot a base class. This is only used for the very core ruby
+  objects and classes (Object, Module, Class). This returns
+  what will be the actual instances of our root classes.
 
-    var c_tor = function(){};
-    c_tor.prototype = new cctor();
+  @param {String} id The class id
+  @param {RubyClass} superklass The super
+*/
+function rb_boot_defclass(id, superklass) {
+  var cls = function() {
+    this.$id = rb_yield_hash();
+    return this;
+  };
 
-    this.$c = new c_tor();
-    this.$c_prototype = c_tor.prototype;
+  if (superklass) {
+    var ctor = function() {};
+    ctor.prototype = superklass.prototype;
+    cls.prototype = new ctor();
   }
   else {
-    var mtor = function() {};
-    this.$m_tbl = mtor.prototype;
-    this.$m_tor = mtor;
-
-    var ctor = function() {};
-    this.$c = new ctor();
-    this.$c_prototype = ctor.prototype;
+    cls.prototype = new rb_boot_root();
   }
 
-  this.$method_table = {};
-  this.$const_table = {};
+  cls.prototype.constructor = cls;
+  cls.prototype.$f = T_OBJECT;
 
-  return this;
-};
+  cls.prototype.$h = function() {
+    return this.$id;
+  };
 
-// RClass prototype for minimizing
-var Rp = RClass.prototype;
+  return cls;
+};
 
 /**
-  Every RClass instance is just a T_CLASS.
-*/
-Rp.$flags = T_CLASS;
+  Make the actual (meta) classes: Object, Class, Module.
 
-/**
-  RClass truthiness
+  @param {String} id The class id
+  @param {RubyClass} klass The class of the result
+  @param {RubyClass} superklass The superklass
 */
-Rp.$r = true;
+function rb_boot_makemeta(id, klass, superklass) {
+  var meta = function() {
+    this.$id = rb_yield_hash();
+    return this;
+  };
 
-/**
-  Every object in opal (except toll free objects) are instances of RObject
+  var ctor = function() {};
+  ctor.prototype = superklass.prototype;
+  meta.prototype = new ctor();
+
+  var proto = meta.prototype;
+  proto.$included_in = [];
+  proto.$m           = {};
+  proto.$methods     = [];
+
+  proto.$a           = klass;
+  proto.$f           = T_CLASS;
+  proto.__classid__  = id;
+  proto.$s           = superklass;
+  proto.constructor  = meta;
+
+  // constants
+  if (superklass.prototype.$constants_alloc) {
+    proto.$c = new superklass.prototype.$constants_alloc();
+    proto.$constants_alloc = function() {};
+    proto.$constants_alloc.prototype = proto.$c;
+  }
+  else {
+    proto.$constants_alloc = function() {};
+    proto.$c = proto.$constants_alloc.prototype;
+  }
 
-  @param {RClass} klass
-*/
-var RObject = Rt.RObject = function(klass) {
-  this.$id = yield_hash();
-  this.$klass = klass;
-  this.$m = klass.$m_tbl;
-  return this;
+  var result = new meta();
+  klass.prototype.$k = result;
+  return result;
 };
 
-// For minimizing
-var Bp = RObject.prototype;
-
 /**
-  Every RObject is a T_OBJECT
+  Fixes the class of boot classes to their meta.
 */
-Bp.$flags = T_OBJECT;
-
-/**
-  RObject truthiness
-*/
-Bp.$r = true;
-
-/**
-  The hash of all objects and classes is sinple its id
-*/
-Bp.$hash = Rp.$hash = function() {
-  return this.$id;
+function rb_boot_defmetameta(klass, meta) {
+  klass.$k = meta;
 };
 
 /**
-  Like boot_defclass but for root object only (i.e. BasicObject)
-*/
-function boot_defrootclass(id) {
-  var cls = new RClass(null, null);
-  cls.$flags = T_CLASS;
-  name_class(cls, id);
-  const_set((cObject || cls), id, cls);
-  return cls;
-}
+  Boot class
 
-/**
-  Boots core classes - Object, Module and Class
+  @param {RubyClass} superklass Class to inherit from
 */
-function boot_defclass(id, superklass) {
-  var cls = class_boot(superklass);
-  name_class(cls, id);
-  const_set((cObject || cls), id, cls);
-  return cls;
-}
+function rb_class_boot(superklass) {
+  // instances
+  var cls = function() {
+    this.$id = rb_yield_hash();
+    return this;
+  };
 
-function class_boot(superklass) {
-  if (superklass) {
-    var ctor = function() {};
-    ctor.prototype = superklass.constructor.prototype;
+  var ctor = function() {};
+  ctor.prototype = superklass.$a.prototype;
+  cls.prototype = new ctor();
 
-    var result = function() {
-      RClass.call(this, null, superklass);
-      return this;
-    };
-    result.prototype = new ctor();
+  var proto = cls.prototype;
+  proto.constructor = cls;
+  proto.$f = T_OBJECT;
 
-    var klass = new result();
-    klass.$klass = cClass;
-    return klass;
-  }
-  else {
-    var result = new RClass(null, null);
-    return result;
-  }
-}
+  // class itself
+  var meta = function() {
+    this.$id = rb_yield_hash();
+    return this;
+  };
 
-function class_real(klass) {
-  while (klass.$flags & FL_SINGLETON) { klass = klass.$super; }
-  return klass;
+  var mtor = function() {};
+  mtor.prototype = superklass.constructor.prototype;
+  meta.prototype = new mtor();
+
+  proto = meta.prototype;
+  proto.$a = cls;
+  proto.$f = T_CLASS;
+  proto.$m = {};
+  proto.$methods = [];
+  proto.constructor = meta;
+  proto.$s = superklass;
+
+  // constants
+  proto.$c = new superklass.$constants_alloc();
+  proto.$constants_alloc = function() {};
+  proto.$constants_alloc.prototype = proto.$c;
+
+  var result = new meta();
+  cls.prototype.$k = result;
+  return result;
 };
 
-Rt.class_real = class_real;
+/**
+  Get actual class ignoring singleton classes and iclasses.
+*/
+function rb_class_real(klass) {
+  while (klass.$f & FL_SINGLETON) { klass = klass.$s; }
+  return klass;
+};
 
 /**
   Name the class with the given id.
 */
-function name_class(klass, id) {
+function rb_name_class(klass, id) {
   klass.__classid__ = id;
 };
 
 /**
   Make metaclass for the given class
 */
-function make_metaclass(klass, super_class) {
-  if (klass.$flags & T_CLASS) {
-    if ((klass.$flags & T_CLASS) && (klass.$flags & FL_SINGLETON)) {
-      return make_metametaclass(klass);
+function rb_make_metaclass(klass, super_class) {
+  if (klass.$f & T_CLASS) {
+    if ((klass.$f & T_CLASS) && (klass.$f & FL_SINGLETON)) {
+      return rb_make_metametaclass(klass);
     }
     else {
       // FIXME this needs fixinfg to remove hacked stuff now in make_singleton_class
-      var meta = class_boot(super_class);
+      var meta = rb_class_boot(super_class);
       // remove this??!
-      meta.$m = meta.$klass.$m_tbl;
-      meta.$c = meta.$klass.$c_prototype;
-      meta.$flags |= FL_SINGLETON;
+      meta.$a.prototype = klass.constructor.prototype;
+      meta.$c = meta.$k.$c_prototype;
+      meta.$f |= FL_SINGLETON;
       meta.__classid__ = "#<Class:" + klass.__classid__ + ">";
-      klass.$klass = meta;
-      klass.$m = meta.$m_tbl;
+      klass.$k = meta;
       meta.$c = klass.$c;
-      singleton_class_attached(meta, klass);
+      rb_singleton_class_attached(meta, klass);
       // console.log("meta id: " + klass.__classid__);
       return meta;
     }
   } else {
     // if we want metaclass of an object, do this
-    return make_singleton_class(klass);
+    return rb_make_singleton_class(klass);
   }
 };
 
-function make_singleton_class(obj) {
-  var orig_class = obj.$klass;
-  var klass = class_boot(orig_class);
+function rb_make_singleton_class(obj) {
+  var orig_class = obj.$k;
+  var klass = rb_class_boot(orig_class);
 
-  klass.$flags |= FL_SINGLETON;
+  klass.$f |= FL_SINGLETON;
 
-  obj.$klass = klass;
-  obj.$m = klass.$m_tbl;
+  obj.$k = klass;
 
   // make methods we define here actually point to instance
   // FIXME: we could just take advantage of $bridge_prototype like we
   // use for bridged classes?? means we can make more instances...
   klass.$bridge_prototype = obj;
 
-  singleton_class_attached(klass, obj);
+  rb_singleton_class_attached(klass, obj);
 
-  klass.$klass = class_real(orig_class).$klass;
-  klass.$m = klass.$klass.$m_tbl;
+  klass.$k = rb_class_real(orig_class).$k;
   klass.__classid__ = "#<Class:#<" + orig_class.__classid__ + ":" + klass.$id + ">>";
 
   return klass;
 };
 
-function singleton_class_attached(klass, obj) {
-  if (klass.$flags & FL_SINGLETON) {
+function rb_singleton_class_attached(klass, obj) {
+  if (klass.$f & FL_SINGLETON) {
     klass.__attached__ = obj;
   }
 };
 
-function make_metametaclass(metaclass) {
+function rb_make_metametaclass(metaclass) {
   var metametaclass, super_of_metaclass;
 
-  if (metaclass.$klass == metaclass) {
-    metametaclass = class_boot(null);
-    metametaclass.$klass = metametaclass;
+  if (metaclass.$k == metaclass) {
+    metametaclass = rb_class_boot(null);
+    metametaclass.$k = metametaclass;
   }
   else {
-    metametaclass = class_boot(null);
-    metametaclass.$klass = metaclass.$klass.$klass == metaclass.$klass
-      ? make_metametaclass(metaclass.$klass)
-      : metaclass.$klass.$klass;
+    metametaclass = rb_class_boot(null);
+    metametaclass.$k = metaclass.$k.$k == metaclass.$k
+      ? rb_make_metametaclass(metaclass.$k)
+      : metaclass.$k.$k;
   }
 
-  metametaclass.$flags |= FL_SINGLETON;
+  metametaclass.$f |= FL_SINGLETON;
 
-  singleton_class_attached(metametaclass, metaclass);
-  metaclass.$klass = metametaclass;
-  metaclsss.$m = metametaclass.$m_tbl;
-  super_of_metaclass = metaclass.$super;
+  rb_singleton_class_attached(metametaclass, metaclass);
+  rb_metaclass.$k = metametaclass;
+  metaclass.$m = metametaclass.$m_tbl;
+  super_of_metaclass = metaclass.$s;
 
-  metametaclass.$super = super_of_metaclass.$klass.__attached__
+  metametaclass.$s = super_of_metaclass.$k.__attached__
     == super_of_metaclass
-    ? super_of_metaclass.$klass
-    : make_metametaclass(super_of_metaclass);
+    ? super_of_metaclass.$k
+    : rb_make_metametaclass(super_of_metaclass);
 
   return metametaclass;
 };
 
-function boot_defmetametaclass(klass, metametaclass) {
-  klass.$klass.$klass = metametaclass;
+function rb_boot_defmetametaclass(klass, metametaclass) {
+  klass.$k.$k = metametaclass;
 };
 
 // Holds an array of all prototypes that are bridged. Any method defined on
 // Object in ruby will also be added to the bridge classes.
-var bridged_classes = [];
+var rb_bridged_classes = [];
 
 /**
   Define toll free bridged class
 */
-function bridge_class(prototype, flags, id, super_class) {
-  var klass = define_class(id, super_class);
+function rb_bridge_class(prototype, flags, id, super_class) {
+  var klass = rb_define_class(id, super_class);
+
+  klass.$bridge_prototype = prototype;
+  rb_bridged_classes.push(prototype);
 
-  prototype.$klass = klass;
+  prototype.$k = klass;
   prototype.$m = klass.$m_tbl;
-  prototype.$flags = flags;
+  prototype.$f = flags;
   prototype.$r = true;
 
-  prototype.$hash = function() { return flags + '_' + this; };
+  prototype.$h = function() { return flags + '_' + this; };
 
   return klass;
 };
 
-Rt.native_prototype = function(cls, proto) {
-  proto.$klass = cls;
-  proto.$m = cls.$m_tbl;
-  proto.$flags = T_OBJECT;
-  proto.$r = true;
+// make native prototype from class
+function rb_native_prototype(cls, proto) {
+  var sup = cls.$s;
 
-  proto.$hash = function() {
-    return this.$id || (this.$id = yield_hash());
-  };
+  if (sup != rb_cObject) {
+    rb_raise(rb_eRuntimeError, "native_error must be used on subclass of Object only");
+  }
+
+  proto.$k = cls;
+  proto.$f = T_OBJECT;
+
+  proto.$h = function() { return this.$id || (this.$id = rb_yield_hash()); };
 
   return cls;
-};
+}
 
 /**
   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 rb_define_class(id, super_klass) {
+  return rb_define_class_under(rb_cObject, id, super_klass);
 };
 
-function define_class_under(base, id, super_klass) {
+function rb_define_class_under(base, id, super_klass) {
   var klass;
 
-  if (const_defined(base, id)) {
-    klass = const_get(base, id);
+  if (rb_const_defined(base, id)) {
+    klass = rb_const_get(base, id);
 
-    if (!(klass.$flags & T_CLASS)) {
-      throw new Error(id + " is not a class!");
+    if (!(klass.$f & T_CLASS)) {
+      rb_raise(rb_eException, id + " is not a class");
     }
 
-    if (klass.$super != super_klass && super_klass != cObject) {
-      throw new Error("Wrong superclass given for " + id);
+    if (klass.$s != super_klass && super_klass != rb_cObject) {
+      rb_raise(rb_eException, "Wrong superclass given for " + id);
     }
 
     return klass;
   }
 
-  klass = define_class_id(id, super_klass);
+  klass = rb_define_class_id(id, super_klass);
 
-  if (base == cObject) {
-    name_class(klass, id);
+  if (base == rb_cObject) {
+    rb_name_class(klass, id);
   } else {
-    name_class(klass, base.__classid__ + '::' + id);
+    rb_name_class(klass, base.__classid__ + '::' + id);
   }
 
-  const_set(base, id, klass);
+  rb_const_set(base, id, klass);
   klass.$parent = base;
 
   // Class#inherited hook - here is a good place to call. We check method
@@ -311,49 +341,46 @@ function define_class_under(base, id, super_klass) {
   return klass;
 };
 
-Rt.define_class_under = define_class_under;
-
 /**
   Actually create class
 */
-function define_class_id(id, super_klass) {
+function rb_define_class_id(id, super_klass) {
   var klass;
 
   if (!super_klass) {
-    super_klass = cObject;
+    super_klass = rb_cObject;
   }
-  klass = class_create(super_klass);
-  name_class(klass, id);
-  make_metaclass(klass, super_klass.$klass);
+  klass = rb_class_create(super_klass);
+  rb_name_class(klass, id);
+  rb_make_metaclass(klass, super_klass.$k);
 
   return klass;
 };
 
-function class_create(super_klass) {
-  return class_boot(super_klass);
+function rb_class_create(super_klass) {
+  return rb_class_boot(super_klass);
 };
 
 /**
   Get singleton class of obj
 */
-function singleton_class(obj) {
+function rb_singleton_class(obj) {
   var klass;
 
-  if (obj.$flags & T_OBJECT) {
-    if ((obj.$flags & T_NUMBER) || (obj.$flags & T_SYMBOL)) {
-      raise(eTypeError, "can't define singleton");
+  if (obj.$f & T_OBJECT) {
+    if ((obj.$f & T_NUMBER) || (obj.$f & T_SYMBOL)) {
+      rb_raise(rb_eTypeError, "can't define singleton");
     }
   }
 
-  if ((obj.$klass.$flags & FL_SINGLETON) && obj.$klass.__attached__ == obj) {
-    klass = obj.$klass;
+  if ((obj.$k.$f & FL_SINGLETON) && obj.$k.__attached__ == obj) {
+    klass = obj.$k;
   }
   else {
-    var class_id = obj.$klass.__classid__;
-    klass = make_metaclass(obj, obj.$klass);
+    var class_id = obj.$k.__classid__;
+    klass = rb_make_metaclass(obj, obj.$k);
   }
 
   return klass;
 };
 
-Rt.singleton_class = singleton_class;