opal 0.10.0 → 0.11.0

data/opal/corelib/range.rb

@@ -8,11 +8,12 @@ class Range
   attr_reader :begin, :end
 
   def initialize(first, last, exclude = false)
-    raise ArgumentError unless first <=> last
+    raise NameError, "'initialize' called twice" if @begin
+    raise ArgumentError, "bad value for range" unless first <=> last
 
-    @begin   = first
-    @end     = last
-    @exclude = exclude
+    @begin = first
+    @end   = last
+    @excl  = exclude
   end
 
   def ==(other)
@@ -21,9 +22,9 @@ class Range
         return false;
       }
 
-      return self.exclude === other.exclude &&
-             self.begin   ==  other.begin &&
-             self.end     ==  other.end;
+      return self.excl  === other.excl &&
+             self.begin ==  other.begin &&
+             self.end   ==  other.end;
     }
   end
 
@@ -32,7 +33,14 @@ class Range
   end
 
   def cover?(value)
-    @begin <= value && (@exclude ? value < @end : value <= @end)
+    beg_cmp = (@begin <=> value)
+    return false unless beg_cmp && beg_cmp <= 0
+    end_cmp = (value <=> @end)
+    if @excl
+      end_cmp && end_cmp < 0
+    else
+      end_cmp && end_cmp <= 0
+    end
   end
 
   def each(&block)
@@ -46,7 +54,7 @@ class Range
           #{raise TypeError, "can't iterate from Float"}
         }
 
-        for (i = #@begin, limit = #@end + #{@exclude ? 0 : 1}; i < limit; i++) {
+        for (i = #@begin, limit = #@end + #{@excl ? 0 : 1}; i < limit; i++) {
           block(i);
         }
 
@@ -54,7 +62,7 @@ class Range
       }
 
       if (#@begin.$$is_string && #@end.$$is_string) {
-        #{@begin.upto(@end, @exclude, &block)}
+        #{@begin.upto(@end, @excl, &block)}
         return self;
       }
     }
@@ -62,13 +70,17 @@ class Range
     current = @begin
     last    = @end
 
-    while current < last
+    unless current.respond_to?(:succ)
+      raise TypeError, "can't iterate from #{current.class}"
+    end
+
+    while (current <=> last) < 0
       yield current
 
       current = current.succ
     end
 
-    yield current if !@exclude && current == last
+    yield current if !@excl && current == last
 
     self
   end
@@ -76,27 +88,37 @@ class Range
   def eql?(other)
     return false unless Range === other
 
-    @exclude === other.exclude_end? &&
+    @excl === other.exclude_end? &&
     @begin.eql?(other.begin) &&
     @end.eql?(other.end)
   end
 
   def exclude_end?
-    @exclude
+    @excl
   end
 
-  alias :first :begin
+  def first(n = undefined)
+    return @begin if `n == null`
+    super
+  end
 
   alias :include? :cover?
 
-  alias :last :end
+  def last(n = undefined)
+    return @end if `n == null`
+    to_a.last(n)
+  end
 
   # FIXME: currently hardcoded to assume range holds numerics
   def max
     if block_given?
       super
+    elsif @begin > @end
+      nil
+    elsif @excl && @begin == @end
+      nil
     else
-      `#@exclude ? #@end - 1 : #@end`
+      `#@excl ? #@end - 1 : #@end`
     end
   end
 
@@ -105,17 +127,19 @@ class Range
   def min
     if block_given?
       super
+    elsif @begin > @end
+      nil
+    elsif @excl && @begin == @end
+      nil
     else
       @begin
     end
   end
 
-  alias member? include?
-
   def size
     _begin = @begin
     _end   = @end
-    _end  -= 1 if @exclude
+    _end  -= 1 if @excl
 
     return nil unless Numeric === _begin && Numeric === _end
     return 0 if _end < _begin
@@ -126,18 +150,117 @@ class Range
   end
 
   def step(n = 1)
-    raise NotImplementedError
+    %x{
+      function coerceStepSize() {
+        if (!n.$$is_number) {
+          n = #{Opal.coerce_to!(n, Integer, :to_int)}
+        }
+
+        if (n < 0) {
+          #{raise ArgumentError, "step can't be negative"}
+        } else if (n === 0) {
+          #{raise ArgumentError, "step can't be 0"}
+        }
+      }
+
+      function enumeratorSize() {
+        if (!#{@begin.respond_to?(:succ)}) {
+          return nil;
+        }
+
+        if (#{@begin}.$$is_string && #{@end}.$$is_string) {
+          return nil;
+        }
+
+        if (n % 1 === 0) {
+          return #{(size / n).ceil};
+        } else {
+          // n is a float
+          var begin = self.begin, end = self.end,
+              abs = Math.abs, floor = Math.floor,
+              err = (abs(begin) + abs(end) + abs(end - begin)) / abs(n) * #{Float::EPSILON},
+              size;
+
+          if (err > 0.5) {
+            err = 0.5;
+          }
+
+          if (self.excl) {
+            size = floor((end - begin) / n - err);
+            if (size * n + begin < end) {
+              size++;
+            }
+          } else {
+            size = floor((end - begin) / n + err) + 1
+          }
+
+          return size;
+        }
+      }
+    }
+
+
+    unless block_given?
+      return enum_for(:step, n) {
+        %x{
+          coerceStepSize();
+          return enumeratorSize();
+        }
+      }
+    end
+
+    `coerceStepSize()`
+
+    if `self.begin.$$is_number && self.end.$$is_number`
+      i = 0
+      loop do
+        current = @begin + i * n
+        if @excl
+          break if current >= @end
+        else
+          break if current > @end
+        end
+        yield(current)
+        i += 1
+      end
+    else
+      %x{
+        if (#{@begin}.$$is_string && #{@end}.$$is_string && n % 1 !== 0) {
+          #{raise TypeError, "no implicit conversion to float from string"}
+        }
+      }
+      each_with_index do |value, idx|
+        yield(value) if idx % n == 0
+      end
+    end
+    self
+  end
+
+  def bsearch(&block)
+    return enum_for(:bsearch) unless block_given?
+
+    unless `self.begin.$$is_number && self.end.$$is_number`
+      raise TypeError, "can't do binary search for #{@begin.class}"
+    end
+
+    to_a.bsearch(&block)
   end
 
   def to_s
-    `#{@begin.inspect} + (#@exclude ? '...' : '..') + #{@end.inspect}`
+    "#{@begin}#{ @excl ? '...' : '..' }#{@end}"
   end
 
-  alias inspect to_s
+  def inspect
+    "#{@begin.inspect}#{ @excl ? '...' : '..' }#{@end.inspect}"
+  end
 
   def marshal_load(args)
     @begin = args[:begin]
     @end = args[:end]
-    @exclude = args[:excl]
+    @excl = args[:excl]
+  end
+
+  def hash
+    [@begin, @end, @excl].hash
   end
 end

data/opal/corelib/regexp.rb

@@ -14,13 +14,7 @@ class Regexp < `RegExp`
     end
 
     def escape(string)
-      %x{
-        return string.replace(/([-[\]\/{}()*+?.^$\\| ])/g, '\\$1')
-                     .replace(/[\n]/g, '\\n')
-                     .replace(/[\r]/g, '\\r')
-                     .replace(/[\f]/g, '\\f')
-                     .replace(/[\t]/g, '\\t');
-      }
+      `Opal.escape_regexp(string)`
     end
 
     def last_match(n=nil)
@@ -43,7 +37,7 @@ class Regexp < `RegExp`
         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'}
-        }        
+        }
         // deal with splat issues (related to https://github.com/opal/opal/issues/858)
         if (is_first_part_array) {
           parts = parts[0];
@@ -118,7 +112,41 @@ class Regexp < `RegExp`
   alias eql? ==
 
   def inspect
-    `self.toString()`
+    # 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.
+    %x{
+      var regexp_format = /^\/(.*)\/([^\/]*)$/;
+      var value = self.toString();
+      var matches = regexp_format.exec(value);
+      if (matches) {
+        var regexp_pattern = matches[1];
+        var regexp_flags = matches[2];
+        var chars = regexp_pattern.split('');
+        var chars_length = chars.length;
+        var char_escaped = false;
+        var regexp_pattern_escaped = '';
+        for (var i = 0; i < chars_length; i++) {
+          var current_char = chars[i];
+          if (!char_escaped && current_char == '/') {
+            regexp_pattern_escaped = regexp_pattern_escaped.concat('\\');
+          }
+          regexp_pattern_escaped = regexp_pattern_escaped.concat(current_char);
+          if (current_char == '\\') {
+            if (char_escaped) {
+              // does not over escape
+              char_escaped = false;
+            } else {
+              char_escaped = true;
+            }
+          } else {
+            char_escaped = false;
+          }
+        }
+        return '/' + regexp_pattern_escaped + '/' + regexp_flags;
+      } else {
+        return value;
+      }
+    }
   end
 
   def match(string, pos = undefined, &block)
@@ -171,6 +199,51 @@ class Regexp < `RegExp`
     }
   end
 
+  def match?(string, pos = undefined)
+    %x{
+      if (self.uninitialized) {
+        #{raise TypeError, 'uninitialized Regexp'}
+      }
+
+      if (pos === undefined) {
+        pos = 0;
+      } else {
+        pos = #{Opal.coerce_to(pos, Integer, :to_int)};
+      }
+
+      if (string === nil) {
+        return false;
+      }
+
+      string = #{Opal.coerce_to(string, String, :to_str)};
+
+      if (pos < 0) {
+        pos += string.length;
+        if (pos < 0) {
+          return false;
+        }
+      }
+
+      var source = self.source;
+      var flags = 'g';
+      // m flag + a . in Ruby will match white space, but in JS, it only matches beginning/ending of lines, so we get the equivalent here
+      if (self.multiline) {
+        source = source.replace('.', "[\\s\\S]");
+        flags += 'm';
+      }
+
+      // global RegExp maintains state, so not using self/this
+      var md, re = new RegExp(source, flags + (self.ignoreCase ? 'i' : ''));
+
+      md = re.exec(string);
+      if (md === null || md.index < pos) {
+        return false;
+      } else {
+        return true;
+      }
+    }
+  end
+
   def ~
     self =~ $_
   end
@@ -202,10 +275,6 @@ class Regexp < `RegExp`
   end
 
   alias to_s source
-
-  def self._load(args)
-    self.new(*args)
-  end
 end
 
 class MatchData