opal 0.4.4 → 0.5.0

data/corelib/main.rb

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

data/corelib/match_data.rb

@@ -0,0 +1,118 @@
+class MatchData
+  attr_reader :post_match, :pre_match, :regexp, :string
+
+  def self.new(regexp, match_groups)
+    data = super(regexp, match_groups)
+
+    $` = data.pre_match
+    $' = data.post_match
+    $~ = data
+
+    data
+  end
+
+  def initialize(regexp, match_groups)
+    @regexp     = regexp
+    @begin      = `match_groups.index`
+    @string     = `match_groups.input`
+    @pre_match  = `#@string.substr(0, regexp.lastIndex - match_groups[0].length)`
+    @post_match = `#@string.substr(regexp.lastIndex)`
+    @matches    = []
+
+    %x{
+      for (var i = 0, length = match_groups.length; i < length; i++) {
+        var group = match_groups[i];
+
+        if (group == null) {
+          #@matches.push(nil);
+        }
+        else {
+          #@matches.push(group);
+        }
+      }
+    }
+  end
+
+  def [](*args)
+    @matches[*args]
+  end
+
+  def ==(other)
+    return false unless MatchData === other
+
+    `self.string == other.string` &&
+    `self.regexp == other.regexp` &&
+    `self.pre_match == other.pre_match` &&
+    `self.post_match == other.post_match` &&
+    `self.begin == other.begin`
+  end
+
+  def begin(pos)
+    if pos != 0 && pos != 1
+      raise ArgumentError, 'MatchData#begin only supports 0th element'
+    end
+
+    @begin
+  end
+
+  def captures
+    `#@matches.slice(1)`
+  end
+
+  def inspect
+    %x{
+      var str = "#<MatchData " + #{`#@matches[0]`.inspect};
+
+      for (var i = 1, length = #@matches.length; i < length; i++) {
+        str += " " + i + ":" + #{`#@matches[i]`.inspect};
+      }
+
+      return str + ">";
+    }
+  end
+
+  def length
+    `#@matches.length`
+  end
+
+  alias size length
+
+  def to_a
+    @matches
+  end
+
+  def to_s
+    `#@matches[0]`
+  end
+
+  def to_n
+    @matches
+  end
+
+  def values_at(*indexes)
+    %x{
+      var values       = [],
+          match_length = #@matches.length;
+
+      for (var i = 0, length = indexes.length; i < length; i++) {
+        var pos = indexes[i];
+
+        if (pos >= 0) {
+          values.push(#@matches[pos]);
+        }
+        else {
+          pos += match_length;
+
+          if (pos > 0) {
+            values.push(#@matches[pos]);
+          }
+          else {
+            values.push(nil);
+          }
+        }
+      }
+
+      return values;
+    }
+  end
+end

data/corelib/method.rb

@@ -0,0 +1,58 @@
+class Method
+  attr_reader :owner, :receiver, :name
+
+  def initialize(receiver, method, name)
+    @receiver = receiver
+    @owner    = receiver.class
+    @name     = name
+    @method   = method
+  end
+
+  def arity
+    @method.arity
+  end
+
+  def call(*args, &block)
+    %x{
+      #@method._p = block;
+
+      return #@method.apply(#@object, args);
+    }
+  end
+
+  alias [] call
+
+  def unbind
+    UnboundMethod.new(@owner, @method, @name)
+  end
+
+  def to_proc
+    @method
+  end
+
+  def inspect
+    "#<Method: #{@obj.class.name}##@name}>"
+  end
+end
+
+class UnboundMethod
+  attr_reader :owner, :name
+
+  def initialize(owner, method, name)
+    @owner  = owner
+    @method = method
+    @name   = name
+  end
+
+  def arity
+    @method.arity
+  end
+
+  def bind(object)
+    Method.new(object, @method, @name)
+  end
+
+  def inspect
+    "#<UnboundMethod: #{@owner.name}##@name>"
+  end
+end

data/corelib/module.rb

@@ -2,10 +2,15 @@ class Module
   def self.new(&block)
     %x{
       function AnonModule(){}
-      var klass = Opal.boot(Module, AnonModule);
-      klass._name = nil;
-      klass._scope = Module._scope;
-      klass._klass = Module;
+      var klass     = Opal.boot(Module, AnonModule);
+      klass._name   = nil;
+      klass._klass  = Module;
+      klass.__dep__ = []
+      klass.__mod__ = true;
+      klass._proto  = {};
+
+      // inherit scope from parent
+      $opal.create_scope(Module._scope, klass);
 
       if (block !== nil) {
         var block_self = block._s;
@@ -19,19 +24,21 @@ class Module
   end
 
   def ===(object)
-    %x{
-      if (object == null) {
-        return false;
-      }
+    return false if `object == null`
 
-      var search = object._klass;
+    `$opal.is_a(object, self)`
+  end
+
+  def <(other)
+    %x{
+      var working = self;
 
-      while (search) {
-        if (search === #{self}) {
+      while (working) {
+        if (working === other) {
           return true;
         }
 
-        search = search._super;
+        working = working.__parent;
       }
 
       return false;
@@ -39,21 +46,29 @@ class Module
   end
 
   def alias_method(newname, oldname)
-    `#{self}._proto['$' + newname] = #{self}._proto['$' + oldname]`
+    %x{
+      self._proto['$' + newname] = self._proto['$' + oldname];
+
+      if (self._methods) {
+        $opal.donate(self, ['$' + newname ])
+      }
+    }
     self
   end
 
-  def alias_native(mid, jsid)
-    `#{self}._proto['$' + mid] = #{self}._proto[jsid]`
+  def alias_native(mid, jsid = mid)
+    `self._proto['$' + mid] = self._proto[jsid]`
   end
 
   def ancestors
     %x{
-      var parent = #{self},
+      var parent = self,
           result = [];
 
       while (parent) {
         result.push(parent);
+        result = result.concat(parent.__inc__);
+
         parent = parent._super;
       }
 
@@ -63,25 +78,29 @@ class Module
 
   def append_features(klass)
     %x{
-      var module = #{self};
+      var module   = self,
+          included = klass.__inc__;
 
-      if (!klass.$included_modules) {
-        klass.$included_modules = [];
-      }
-
-      for (var idx = 0, length = klass.$included_modules.length; idx < length; idx++) {
-        if (klass.$included_modules[idx] === module) {
+      // check if this module is already included in the klass
+      for (var i = 0, length = included.length; i < length; i++) {
+        if (included[i] === module) {
           return;
         }
       }
 
-      klass.$included_modules.push(module);
+      included.push(module);
+      module.__dep__.push(klass);
 
-      if (!module._included_in) {
-        module._included_in = [];
-      }
+      // iclass
+      var iclass = {
+        name: module._name,
 
-      module._included_in.push(klass);
+        _proto:   module._proto,
+        __parent: klass.__parent,
+        __iclass: true
+      };
+
+      klass.__parent = iclass;
 
       var donator   = module._proto,
           prototype = klass._proto,
@@ -89,24 +108,31 @@ class Module
 
       for (var i = 0, length = methods.length; i < length; i++) {
         var method = methods[i];
-        prototype[method] = donator[method];
-      }
 
-      // if (prototype._smethods) {
-      //  prototype._smethods.push.apply(prototype._smethods, methods);
-      //}
+        if (prototype.hasOwnProperty(method) && !prototype[method]._donated) {
+          // if the target class already has a method of the same name defined
+          // and that method was NOT donated, then it must be a method defined
+          // by the class so we do not want to override it
+        }
+        else {
+          prototype[method] = donator[method];
+          prototype[method]._donated = true;
+        }
+      }
 
-      if (klass._included_in) {
+      if (klass.__dep__) {
         $opal.donate(klass, methods.slice(), true);
       }
+
+      $opal.donate_constants(module, klass);
     }
 
     self
   end
 
   def attr_accessor(*names)
-    attr_reader *names
-    attr_writer *names
+    attr_reader(*names)
+    attr_writer(*names)
   end
 
   def attr_reader(*names)
@@ -122,6 +148,7 @@ class Module
           }
           else {
             proto['$' + name] = func;
+            $opal.donate(self, ['$' + name ]);
           }
         })(names[i]);
       }
@@ -143,6 +170,7 @@ class Module
           }
           else {
             proto['$' + name + '='] = func;
+            $opal.donate(self, ['$' + name + '=']);
           }
         })(names[i]);
       }
@@ -157,39 +185,14 @@ class Module
   # when self is not Module (or Class), implement 2nd form:
   # - constants, classes and modules scoped to instance
   def constants
-    %x{
-      var result = [];
-      var name_re = /^[A-Z][A-Za-z0-9_]+$/;
-      var scopes = [#{self}._scope];
-      var own_only;
-      if (#{self} === Opal.Class || #{self} === Opal.Module) {
-        own_only = false;
-      }
-      else {
-        own_only = true;
-        var parent = #{self}._super;
-        while (parent && (parent !== Opal.Object)) {
-          scopes.push(parent._scope);
-          parent = parent._super;
-        }
-      }
-      for (var i = 0, len = scopes.length; i < len; i++) {
-        var scope = scopes[i]; 
-        for (name in scope) {
-          if ((!own_only || scope.hasOwnProperty(name)) && name_re.test(name)) {
-            result.push(name);
-          }
-        }
-      }
-
-      return result;
-    }
+    `#{self}._scope.constants`
   end
 
   # check for constant within current scope
   # if inherit is true or self is Object, will also check ancestors
   def const_defined?(name, inherit = true)
-    raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]\w+$/
+    raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]\w*$/
+
     %x{
       scopes = [#{self}._scope];
       if (inherit || #{self} === Opal.Object) {
@@ -213,7 +216,8 @@ class Module
   # check for constant within current scope
   # if inherit is true or self is Object, will also check ancestors
   def const_get(name, inherit = true)
-    raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]\w+$/
+    raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]\w*$/
+
     %x{
       var scopes = [#{self}._scope];
       if (inherit || #{self} == Opal.Object) {
@@ -228,7 +232,7 @@ class Module
         if (scopes[i].hasOwnProperty(name)) {
           return scopes[i][name];
         }
-       }
+      }
 
       return #{const_missing name};
     }
@@ -236,23 +240,21 @@ class Module
 
   def const_missing(const)
     name = `#{self}._name`
+
     raise NameError, "uninitialized constant #{name}::#{const}"
   end
 
   def const_set(name, value)
-    raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]\w+$/
+    raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]\w*$/
+
     begin
       name = name.to_str
     rescue
       raise TypeError, 'conversion with #to_str failed'
     end
-    %x{
-      #{self}._scope[name] = #{value};
-
-      if (value._isClass && value._name === nil) {
-        value._name = #{self.name} + '::' + name;
-      }
 
+    %x{
+      $opal.casgn(self, name, value);
       return #{value}
     }
   end
@@ -268,9 +270,9 @@ class Module
       }
 
       var jsid    = '$' + name;
-      block._jsid = jsid;
-      block._sup  = #{self}._proto[jsid];
+      block._jsid = name;
       block._s    = null;
+      block._def  = block;
 
       #{self}._proto[jsid] = block;
       $opal.donate(#{self}, [jsid]);
@@ -279,6 +281,18 @@ class Module
     }
   end
 
+  def remove_method(name)
+    %x{
+      var jsid    = '$' + name;
+      var current = #{self}._proto[jsid];
+      delete #{self}._proto[jsid];
+
+      // Check if we need to reverse $opal.donate
+      // $opal.retire(#{self}, [jsid]);
+      return #{self};
+    }
+  end
+
   def include(*mods)
     %x{
       var i = mods.length - 1, mod;
@@ -298,6 +312,18 @@ class Module
     }
   end
 
+  def instance_method(name)
+    %x{
+      var meth = self._proto['$' + name];
+
+      if (!meth || meth.rb_stub) {
+        #{raise NameError, "undefined method `#{name}' for class `#{self.name}'"};
+      }
+
+      return #{UnboundMethod.new(self, `meth`, name)};
+    }
+  end
+
   def instance_methods(include_super = false)
     %x{
       var methods = [], proto = #{self}._proto;
@@ -307,6 +333,10 @@ class Module
           continue;
         }
 
+        if (!include_super && proto[prop]._donated) {
+          continue;
+        }
+
         if (prop.charAt(0) === '$') {
           methods.push(prop.substr(1));
         }
@@ -336,6 +366,8 @@ class Module
   end
 
   alias class_eval module_eval
+  alias class_exec module_eval
+  alias module_exec module_eval
 
   def method_defined?(method)
     %x{
@@ -357,17 +389,53 @@ class Module
   end
 
   def name
-    `#{self}._name`
+    %x{
+      if (self._full_name) {
+        return self._full_name;
+      }
+
+      var result = [], base = self;
+
+      while (base) {
+        if (base._name === nil) {
+          return result.length === 0 ? nil : result.join('::');
+        }
+
+        result.unshift(base._name);
+
+        base = base._base_module;
+
+        if (base === $opal.Object) {
+          break;
+        }
+      }
+
+      if (result.length === 0) {
+        return nil;
+      }
+
+      return self._full_name = result.join('::');
+    }
   end
 
   def public(*)
   end
 
+  def private_class_method(name)
+    `self['$' + name] || nil`
+  end
+
   alias private public
   alias protected public
 
+  alias public_instance_methods instance_methods
+
   alias public_method_defined? method_defined?
 
+  def remove_class_variable(*)
+
+  end
+
   def remove_const(name)
     %x{
       var old = #{self}._scope[name];
@@ -377,7 +445,7 @@ class Module
   end
 
   def to_s
-    `#{self}._name`
+    name.to_s
   end
 
   def undef_method(symbol)