opal 1.3.2 → 1.4.0.alpha1

data/opal/corelib/regexp.rb

@@ -1,13 +1,13 @@
 # helpers: coerce_to
 
-class RegexpError < StandardError; end
+class ::RegexpError < ::StandardError; end
 
-class Regexp < `RegExp`
-  IGNORECASE = 1
-  EXTENDED = 2
-  MULTILINE = 4
+class ::Regexp < `RegExp`
+  self::IGNORECASE = 1
+  self::EXTENDED = 2
+  self::MULTILINE = 4
 
-  `Opal.defineProperty(self.$$prototype, '$$is_regexp', true)`
+  `Opal.prop(self.$$prototype, '$$is_regexp', true)`
 
   class << self
     def allocate
@@ -28,8 +28,6 @@ class Regexp < `RegExp`
       end
     end
 
-    alias quote escape
-
     def union(*parts)
       %x{
         var is_first_part_array, quoted_validated, part, options, each_part_options;
@@ -43,7 +41,7 @@ class Regexp < `RegExp`
         // cover the 2 arrays passed as arguments case
         is_first_part_array = parts[0].$$is_array;
         if (parts.length > 1 && is_first_part_array) {
-          #{raise TypeError, 'no implicit conversion of Array into String'}
+          #{::Kernel.raise ::TypeError, 'no implicit conversion of Array into String'}
         }
         // deal with splat issues (related to https://github.com/opal/opal/issues/858)
         if (is_first_part_array) {
@@ -59,7 +57,7 @@ class Regexp < `RegExp`
           else if (part.$$is_regexp) {
             each_part_options = #{`part`.options};
             if (options != undefined && options != each_part_options) {
-              #{raise TypeError, 'All expressions must use the same options'}
+              #{::Kernel.raise ::TypeError, 'All expressions must use the same options'}
             }
             options = each_part_options;
             quoted_validated.push('('+part.source+')');
@@ -79,10 +77,10 @@ class Regexp < `RegExp`
           return new RegExp(regexp);
         }
 
-        regexp = #{Opal.coerce_to!(regexp, String, :to_str)};
+        regexp = #{::Opal.coerce_to!(regexp, ::String, :to_str)};
 
         if (regexp.charAt(regexp.length - 1) === '\\' && regexp.charAt(regexp.length - 2) !== '\\') {
-          #{raise RegexpError, "too short escape sequence: /#{regexp}/"}
+          #{::Kernel.raise ::RegexpError, "too short escape sequence: /#{regexp}/"}
         }
 
         if (options === undefined || #{!options}) {
@@ -104,6 +102,7 @@ class Regexp < `RegExp`
     end
 
     alias compile new
+    alias quote escape
   end
 
   def ==(other)
@@ -111,15 +110,13 @@ class Regexp < `RegExp`
   end
 
   def ===(string)
-    `#{match(Opal.coerce_to?(string, String, :to_str))} !== nil`
+    `#{match(::Opal.coerce_to?(string, ::String, :to_str))} !== nil`
   end
 
   def =~(string)
     match(string) && $~.begin(0)
   end
 
-  alias eql? ==
-
   def inspect
     # Use a regexp to extract the regular expression and the optional mode modifiers from the string.
     # In the regular expression, escape any front slash (not already escaped) with a backslash.
@@ -161,27 +158,27 @@ class Regexp < `RegExp`
   def match(string, pos = undefined, &block)
     %x{
       if (self.uninitialized) {
-        #{raise TypeError, 'uninitialized Regexp'}
+        #{::Kernel.raise ::TypeError, 'uninitialized Regexp'}
       }
 
       if (pos === undefined) {
         if (string === nil) return #{$~ = nil};
-        var m = self.exec($coerce_to(string, #{String}, 'to_str'));
+        var m = self.exec($coerce_to(string, #{::String}, 'to_str'));
         if (m) {
-          #{$~ = MatchData.new(`self`, `m`)};
+          #{$~ = ::MatchData.new(`self`, `m`)};
           return block === nil ? #{$~} : #{yield $~};
         } else {
           return #{$~ = nil};
         }
       }
 
-      pos = $coerce_to(pos, #{Integer}, 'to_int');
+      pos = $coerce_to(pos, #{::Integer}, 'to_int');
 
       if (string === nil) {
         return #{$~ = nil};
       }
 
-      string = $coerce_to(string, #{String}, 'to_str');
+      string = $coerce_to(string, #{::String}, 'to_str');
 
       if (pos < 0) {
         pos += string.length;
@@ -199,7 +196,7 @@ class Regexp < `RegExp`
           return #{$~ = nil};
         }
         if (md.index >= pos) {
-          #{$~ = MatchData.new(`re`, `md`)};
+          #{$~ = ::MatchData.new(`re`, `md`)};
           return block === nil ? #{$~} : #{yield $~};
         }
         re.lastIndex = md.index + 1;
@@ -210,20 +207,20 @@ class Regexp < `RegExp`
   def match?(string, pos = undefined)
     %x{
       if (self.uninitialized) {
-        #{raise TypeError, 'uninitialized Regexp'}
+        #{::Kernel.raise ::TypeError, 'uninitialized Regexp'}
       }
 
       if (pos === undefined) {
-        return string === nil ? false : self.test($coerce_to(string, #{String}, 'to_str'));
+        return string === nil ? false : self.test($coerce_to(string, #{::String}, 'to_str'));
       }
 
-      pos = $coerce_to(pos, #{Integer}, 'to_int');
+      pos = $coerce_to(pos, #{::Integer}, 'to_int');
 
       if (string === nil) {
         return false;
       }
 
-      string = $coerce_to(string, #{String}, 'to_str');
+      string = $coerce_to(string, #{::String}, 'to_str');
 
       if (pos < 0) {
         pos += string.length;
@@ -270,7 +267,7 @@ class Regexp < `RegExp`
     # Flags would be nice to use with this, but still experimental - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/flags
     %x{
       if (self.uninitialized) {
-        #{raise TypeError, 'uninitialized Regexp'}
+        #{::Kernel.raise ::TypeError, 'uninitialized Regexp'}
       }
       var result = 0;
       // should be supported in IE6 according to https://msdn.microsoft.com/en-us/library/7f5z26w4(v=vs.94).aspx
@@ -288,14 +285,15 @@ class Regexp < `RegExp`
     `self.ignoreCase`
   end
 
+  alias eql? ==
   alias to_s source
 end
 
 class MatchData
   attr_reader :post_match, :pre_match, :regexp, :string
 
-  def initialize(regexp, match_groups)
-    $~          = self
+  def initialize(regexp, match_groups, no_matchdata: false)
+    $~          = self unless no_matchdata
     @regexp     = regexp
     @begin      = `match_groups.index`
     @string     = `match_groups.input`
@@ -317,11 +315,23 @@ class MatchData
     }
   end
 
+  def match(idx)
+    if (match = self[idx])
+      match
+    elsif idx.is_a?(Integer) && idx >= length
+      ::Kernel.raise ::IndexError, "index #{idx} out of matches"
+    end
+  end
+
+  def match_length(idx)
+    match(idx)&.length
+  end
+
   def [](*args)
     %x{
       if (args[0].$$is_string) {
         if (#{!regexp.names.include?(args[0])}) {
-          #{raise IndexError, "undefined group name reference: #{args[0]}"}
+          #{::Kernel.raise ::IndexError, "undefined group name reference: #{args[0]}"}
         }
         return #{named_captures[args[0]]}
       }
@@ -334,14 +344,14 @@ class MatchData
   def offset(n)
     %x{
       if (n !== 0) {
-        #{raise ArgumentError, 'MatchData#offset only supports 0th element'}
+        #{::Kernel.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
+    return false unless ::MatchData === other
 
     `self.string == other.string` &&
       `self.regexp.toString() == other.regexp.toString()` &&
@@ -350,12 +360,10 @@ class MatchData
       `self.begin == other.begin`
   end
 
-  alias eql? ==
-
   def begin(n)
     %x{
       if (n !== 0) {
-        #{raise ArgumentError, 'MatchData#begin only supports 0th element'}
+        #{::Kernel.raise ::ArgumentError, 'MatchData#begin only supports 0th element'}
       }
       return self.begin;
     }
@@ -364,7 +372,7 @@ class MatchData
   def end(n)
     %x{
       if (n !== 0) {
-        #{raise ArgumentError, 'MatchData#end only supports 0th element'}
+        #{::Kernel.raise ::ArgumentError, 'MatchData#end only supports 0th element'}
       }
       return self.begin + self.matches[n].length;
     }
@@ -410,8 +418,6 @@ class MatchData
     `#{@matches}.length`
   end
 
-  alias size length
-
   def to_a
     @matches
   end
@@ -432,7 +438,7 @@ class MatchData
           Array.prototype.splice.apply(args, a);
         }
 
-        index = #{Opal.coerce_to!(`args[i]`, Integer, :to_int)};
+        index = #{::Opal.coerce_to!(`args[i]`, ::Integer, :to_int)};
 
         if (index < 0) {
           index += #{@matches}.length;
@@ -448,4 +454,7 @@ class MatchData
       return values;
     }
   end
+
+  alias eql? ==
+  alias size length
 end