opal 0.7.2 → 0.8.0.beta1

data/opal/corelib/match_data.rb

@@ -6,8 +6,8 @@ class MatchData
     @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)`
+    @pre_match  = `match_groups.input.slice(0, match_groups.index)`
+    @post_match = `match_groups.input.slice(match_groups.index + match_groups[0].length)`
     @matches    = []
 
     %x{
@@ -28,22 +28,43 @@ class MatchData
     @matches[*args]
   end
 
+  def offset(n)
+    %x{
+      if (n !== 0) {
+        #{raise ArgumentError, 'MatchData#offset only supports 0th element'}
+      }
+      return [self.begin, self.begin + self.matches[n].length];
+    }
+  end
+
   def ==(other)
     return false unless MatchData === other
 
     `self.string == other.string` &&
-    `self.regexp == other.regexp` &&
+    `self.regexp.toString() == other.regexp.toString()` &&
     `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
+  alias eql? ==
 
-    @begin
+  def begin(n)
+    %x{
+      if (n !== 0) {
+        #{raise ArgumentError, 'MatchData#begin only supports 0th element'}
+      }
+      return self.begin;
+    }
+  end
+
+  def end(n)
+    %x{
+      if (n !== 0) {
+        #{raise ArgumentError, 'MatchData#end only supports 0th element'}
+      }
+      return self.begin + self.matches[n].length;
+    }
   end
 
   def captures
@@ -76,27 +97,29 @@ class MatchData
     `#@matches[0]`
   end
 
-  def values_at(*indexes)
+  def values_at(*args)
     %x{
-      var values       = [],
-          match_length = #@matches.length;
+      var i, a, index, values = [];
 
-      for (var i = 0, length = indexes.length; i < length; i++) {
-        var pos = indexes[i];
+      for (i = 0; i < args.length; i++) {
 
-        if (pos >= 0) {
-          values.push(#@matches[pos]);
+        if (args[i].$$is_range) {
+          a = #{`args[i]`.to_a};
+          a.unshift(i, 1);
+          Array.prototype.splice.apply(args, a);
         }
-        else {
-          pos += match_length;
 
-          if (pos > 0) {
-            values.push(#@matches[pos]);
-          }
-          else {
+        index = #{Opal.coerce_to!(`args[i]`, Integer, :to_int)};
+
+        if (index < 0) {
+          index += #@matches.length;
+          if (index < 0) {
             values.push(nil);
+            continue;
           }
         }
+
+        values.push(#@matches[index]);
       }
 
       return values;

data/opal/corelib/module.rb

@@ -92,20 +92,33 @@ class Module
     attr_writer(*names)
   end
 
+  alias attr attr_accessor
+
   def attr_reader(*names)
     %x{
-      for (var i = 0, length = names.length; i < length; i++) {
-        (function(name) {
-          self.$$proto[name] = nil;
-          var func = function() { return this[name] };
+      var proto = self.$$proto;
 
-          if (self.$$is_singleton) {
-            self.$$proto.constructor.prototype['$' + name] = func;
-          }
-          else {
-            Opal.defn(self, '$' + name, func);
-          }
-        })(names[i]);
+      for (var i = names.length - 1; i >= 0; i--) {
+        var name = names[i],
+            id   = '$' + name;
+
+        // the closure here is needed because name will change at the next
+        // cycle, I wish we could use let.
+        var body = (function(name) {
+          return function() {
+            return this[name];
+          };
+        })(name);
+
+        // initialize the instance variable as nil
+        proto[name] = nil;
+
+        if (self.$$is_singleton) {
+          proto.constructor.prototype[id] = body;
+        }
+        else {
+          Opal.defn(self, id, body);
+        }
       }
     }
 
@@ -114,25 +127,35 @@ class Module
 
   def attr_writer(*names)
     %x{
-      for (var i = 0, length = names.length; i < length; i++) {
-        (function(name) {
-          self.$$proto[name] = nil;
-          var func = function(value) { return this[name] = value; };
+      var proto = self.$$proto;
 
-          if (self.$$is_singleton) {
-            self.$$proto.constructor.prototype['$' + name + '='] = func;
-          }
-          else {
-            Opal.defn(self, '$' + name + '=', func);
+      for (var i = names.length - 1; i >= 0; i--) {
+        var name = names[i],
+            id   = '$' + name + '=';
+
+        // the closure here is needed because name will change at the next
+        // cycle, I wish we could use let.
+        var body = (function(name){
+          return function(value) {
+            return this[name] = value;
           }
-        })(names[i]);
+        })(name);
+
+        // initialize the instance variable as nil
+        proto[name] = nil;
+
+        if (self.$$is_singleton) {
+          proto.constructor.prototype[id] = body;
+        }
+        else {
+          Opal.defn(self, id, body);
+        }
       }
     }
+
     nil
   end
 
-  alias attr attr_accessor
-
   def autoload(const, path)
     %x{
       var autoloaders;
@@ -176,15 +199,18 @@ class Module
 
     %x{
       scopes = [self.$$scope];
+
       if (inherit || self === Opal.Object) {
         var parent = self.$$super;
+
         while (parent !== Opal.BasicObject) {
           scopes.push(parent.$$scope);
+
           parent = parent.$$super;
         }
       }
 
-      for (var i = 0, len = scopes.length; i < len; i++) {
+      for (var i = 0, length = scopes.length; i < length; i++) {
         if (scopes[i].hasOwnProperty(name)) {
           return true;
         }
@@ -195,19 +221,24 @@ class Module
   end
 
   def const_get(name, inherit = true)
+    if name['::'] && name != '::'
+      return name.split('::').inject(self){|o, c| o.const_get(c)}
+    end
     raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]\w*$/
-
     %x{
       var scopes = [self.$$scope];
+
       if (inherit || self == Opal.Object) {
         var parent = self.$$super;
+
         while (parent !== Opal.BasicObject) {
           scopes.push(parent.$$scope);
+
           parent = parent.$$super;
         }
       }
 
-      for (var i = 0, len = scopes.length; i < len; i++) {
+      for (var i = 0, length = scopes.length; i < length; i++) {
         if (scopes[i].hasOwnProperty(name)) {
           return scopes[i][name];
         }
@@ -217,20 +248,20 @@ class Module
     }
   end
 
-  def const_missing(const)
+  def const_missing(name)
     %x{
       if (self.$$autoload) {
-        var file = self.$$autoload[#{const}];
+        var file = self.$$autoload[name];
 
         if (file) {
           self.$require(file);
 
-          return #{const_get const};
+          return #{const_get name};
         }
       }
     }
 
-    raise NameError, "uninitialized constant #{self}::#{const}"
+    raise NameError, "uninitialized constant #{self}::#{name}"
   end
 
   def const_set(name, value)
@@ -247,26 +278,31 @@ class Module
     value
   end
 
-  def define_method(name, method = undefined, &block)
-    %x{
-      if (method) {
-        block = #{method.to_proc};
-      }
+  def define_method(name, method = nil, &block)
+    unless method || block
+      raise ArgumentError, 'tried to create Proc object without a block'
+    end
 
-      if (block === nil) {
-        throw new Error("no block given");
-      }
+    if method
+      if Proc === method
+        block = method
+      else
+        raise TypeError, "wrong argument type #{method.class} (expected Proc/Method)"
+      end
+    end
+
+    %x{
+      var id = '$' + name;
 
-      var jsid    = '$' + name;
       block.$$jsid = name;
       block.$$s    = null;
       block.$$def  = block;
 
       if (self.$$is_singleton) {
-        self.$$proto[jsid] = block;
+        self.$$proto[id] = block;
       }
       else {
-        Opal.defn(self, jsid, block);
+        Opal.defn(self, id, block);
       }
 
       return name;
@@ -274,15 +310,9 @@ class Module
   end
 
   def remove_method(name)
-    %x{
-      var jsid    = '$' + name;
-      var current = self.$$proto[jsid];
-      delete self.$$proto[jsid];
+    `Opal.undef(self, '$' + name)`
 
-      // Check if we need to reverse Opal.donate
-      // Opal.retire(self, [jsid]);
-      return self;
-    }
+    self
   end
 
   def include(*mods)
@@ -304,7 +334,7 @@ class Module
 
   def include?(mod)
     %x{
-      for (var cls = self; cls; cls = cls.parent) {
+      for (var cls = self; cls; cls = cls.$$super) {
         for (var i = 0; i != cls.$$inc.length; i++) {
           var mod2 = cls.$$inc[i];
           if (mod === mod2) {
@@ -328,17 +358,17 @@ class Module
     }
   end
 
-  def instance_methods(include_super = false)
+  def instance_methods(include_super = true)
     %x{
       var methods = [],
           proto   = self.$$proto;
 
       for (var prop in proto) {
-        if (!prop.charAt(0) === '$') {
+        if (!(prop.charAt(0) === '$')) {
           continue;
         }
 
-        if (typeof(proto[prop]) !== "function") {
+        if (!(typeof(proto[prop]) === "function")) {
           continue;
         }
 

data/opal/corelib/numeric.rb

@@ -5,6 +5,11 @@ class Numeric
 
   `def.$$is_number = true`
 
+  def __id__
+    `(self * 2) + 1`
+  end
+  alias object_id __id__
+
   def coerce(other, type = :operation)
     %x{
       if (other.$$is_number) {
@@ -266,6 +271,9 @@ class Numeric
     return enum_for :downto, finish unless block
 
     %x{
+      if (!finish.$$is_number) {
+        #{raise ArgumentError, "comparison of #{self.class} with #{finish.class} failed"}
+      }
       for (var i = self; i >= finish; i--) {
         if (block(i) === $breaker) {
           return $breaker.$v;
@@ -277,7 +285,10 @@ class Numeric
   end
 
   alias eql? ==
-  alias equal? ==
+
+  def equal?(other)
+    self == other || `isNaN(self) && isNaN(other)`
+  end
 
   def even?
     `self % 2 === 0`
@@ -455,6 +466,9 @@ class Numeric
     return enum_for :upto, finish unless block
 
     %x{
+      if (!finish.$$is_number) {
+        #{raise ArgumentError, "comparison of #{self.class} with #{finish.class} failed"}
+      }
       for (var i = self; i <= finish; i++) {
         if (block(i) === $breaker) {
           return $breaker.$v;

data/opal/corelib/regexp.rb

@@ -35,53 +35,12 @@ class Regexp
     `other.constructor == RegExp && self.toString() === other.toString()`
   end
 
-  def ===(str)
-    %x{
-      if (!str.$$is_string && #{str.respond_to?(:to_str)}) {
-        #{str = str.to_str};
-      }
-
-      if (!str.$$is_string) {
-        return false;
-      }
-
-      return self.test(str);
-    }
+  def ===(string)
+    `#{match(string)} !== nil`
   end
 
   def =~(string)
-    if `string === nil`
-      $~ = nil
-
-      return
-    end
-
-    string = Opal.coerce_to(string, String, :to_str).to_s
-
-    %x{
-      var re = self;
-
-      if (re.global) {
-        // should we clear it afterwards too?
-        re.lastIndex = 0;
-      }
-      else {
-        // rewrite regular expression to add the global flag to capture pre/post match
-        re = new RegExp(re.source, 'g' + (re.multiline ? 'm' : '') + (re.ignoreCase ? 'i' : ''));
-      }
-
-      var result = re.exec(string);
-
-      if (result) {
-        #{$~ = MatchData.new(`re`, `result`)};
-
-        return result.index;
-      }
-      else {
-        #{$~ = nil};
-        return nil;
-      }
-    }
+    match(string) && $~.begin(0)
   end
 
   alias eql? ==
@@ -91,49 +50,46 @@ class Regexp
   end
 
   def match(string, pos = undefined, &block)
-    if `string === nil`
-      $~ = nil
-
-      return
-    end
-
-    if `string.$$is_string == null`
-      unless string.respond_to? :to_str
-        raise TypeError, "no implicit conversion of #{string.class} into String"
-      end
-
-      string = string.to_str
-    end
-
     %x{
-      var re = self;
-
-      if (re.global) {
-        // should we clear it afterwards too?
-        re.lastIndex = 0;
+      if (pos === undefined) {
+        pos = 0;
+      } else {
+        pos = #{Opal.coerce_to(pos, Integer, :to_int)};
       }
-      else {
-        re = new RegExp(re.source, 'g' + (re.multiline ? 'm' : '') + (re.ignoreCase ? 'i' : ''));
+
+      if (string === nil) {
+        return #{$~ = nil};
       }
 
-      var result = re.exec(string);
+      string = #{Opal.coerce_to(string, String, :to_str)};
+
+      if (pos < 0) {
+        pos += string.length;
+        if (pos < 0) {
+          return #{$~ = nil};
+        }
+      }
 
-      if (result) {
-        result = #{$~ = MatchData.new(`re`, `result`)};
+      var md, re = new RegExp(self.source, 'gm' + (self.ignoreCase ? 'i' : ''));
 
-        if (block === nil) {
-          return result;
+      while (true) {
+        md = re.exec(string);
+        if (md === null) {
+          return #{$~ = nil};
         }
-        else {
-          return #{block.call(`result`)};
+        if (md.index >= pos) {
+          #{$~ = MatchData.new(`re`, `md`)}
+          return block === nil ? #{$~} : #{block.call($~)};
         }
-      }
-      else {
-        return #{$~ = nil};
+        re.lastIndex = md.index + 1;
       }
     }
   end
 
+  def ~
+    self =~ $_
+  end
+
   def source
     `self.source`
   end