opal 0.11.0.rc1 → 0.11.0

data/opal/corelib/marshal/write_buffer.rb

@@ -16,8 +16,13 @@ end
 
 class Fixnum
   def __marshal__(buffer)
-    buffer.append('i')
-    buffer.write_fixnum(self)
+    if self >= -0x40000000 && self < 0x40000000
+      buffer.append('i')
+      buffer.write_fixnum(self)
+    else
+      buffer.append('l')
+      buffer.write_bignum(self)
+    end
   end
 end
 
@@ -244,6 +249,26 @@ module Marshal
       }
     end
 
+    def write_bignum(n)
+      sign = n > 0 ? '+' : '-'
+      append(sign)
+
+      num = n > 0 ? n : -n
+
+      arr = []
+      while num > 0
+        arr << (num & 0xffff)
+        num = (num / 0x10000).floor
+      end
+
+      write_fixnum(arr.size)
+
+      arr.each do |x|
+        append(`String.fromCharCode(x & 0xff)`)
+        append(`String.fromCharCode(#{(x/0x100).floor})`)
+      end
+    end
+
     def write_string(s)
       write_fixnum(s.length)
       append(s)

data/opal/corelib/nil.rb

@@ -1,6 +1,14 @@
 class NilClass
   `def.$$meta = #{self}`
 
+  class << self
+    def allocate
+      raise TypeError, "allocator undefined for #{self.name}"
+    end
+
+    undef :new
+  end
+
   def !
     true
   end
@@ -22,11 +30,11 @@ class NilClass
   end
 
   def dup
-    raise TypeError, "can't dup #{self.class}"
+    nil
   end
 
-  def clone
-    raise TypeError, "can't clone #{self.class}"
+  def clone(freeze: true)
+    nil
   end
 
   def inspect

data/opal/corelib/number.rb

@@ -5,6 +5,14 @@ class Number < Numeric
   `Number.prototype.$$is_number = true`
   `self.$$is_number_class = true`
 
+  class << self
+    def allocate
+      raise TypeError, "allocator undefined for #{self.name}"
+    end
+
+    undef :new
+  end
+
   def coerce(other)
     %x{
       if (other === nil) {
@@ -581,31 +589,52 @@ class Number < Numeric
     end
   end
 
-  def step(limit = nil, step = nil, to: nil, by: nil, &block)
+  def step(limit = undefined, step = undefined, to: undefined, by: undefined, &block)
     %x{
-      if (limit !== nil && to !== nil) {
+      if (limit !== undefined && to !== undefined) {
         #{raise ArgumentError, "to is given twice"}
       }
 
-      if (step !== nil && by !== nil) {
+      if (step !== undefined && by !== undefined) {
         #{raise ArgumentError, "step is given twice"}
       }
 
       function validateParameters() {
+        if (to !== undefined) {
+          limit = to;
+        }
+
+        if (limit === undefined) {
+          limit = nil;
+        }
+
+        if (step === nil) {
+          #{raise TypeError, "step must be numeric"}
+        }
+
         if (step === 0) {
-          #{raise ArgumentError, "step cannot be 0"}
+          #{raise ArgumentError, "step can't be 0"}
+        }
+
+        if (by !== undefined) {
+          step = by;
+        }
+
+        if (step === nil || step == null) {
+          step = 1;
         }
 
-        #{limit ||= to};
-        #{step ||= by || 1};
+        var sign = #{step <=> 0};
 
-        if (!limit.$$is_number) {
-          #{raise ArgumentError, "limit must be a number"}
+        if (sign === nil) {
+          #{raise TypeError, "0 can't be coerced into #{step.class}"}
         }
 
-        if (!step.$$is_number) {
-          #{raise ArgumentError, "step must be a number"}
+        if (limit === nil || limit == null) {
+          limit = sign > 0 ? #{Float::INFINITY} : #{-Float::INFINITY};
         }
+
+        #{Opal.compare(self, limit)}
       }
 
       function stepFloatSize() {
@@ -651,7 +680,32 @@ class Number < Numeric
     }
 
     unless block_given?
-      return enum_for(:step, limit, step, to: to, by: by) { `stepSize()` }
+      positional_args = []
+      keyword_args = {}
+
+      %x{
+        if (limit !== undefined) {
+          positional_args.push(limit);
+        }
+
+        if (step !== undefined) {
+          positional_args.push(step);
+        }
+
+        if (to !== undefined) {
+          Opal.hash_put(keyword_args, "to", to);
+        }
+
+        if (by !== undefined) {
+          Opal.hash_put(keyword_args, "by", by);
+        }
+
+        if (!#{keyword_args.empty?}) {
+          positional_args.push(keyword_args);
+        }
+      }
+
+      return enum_for(:step, *positional_args) { `stepSize()` }
     end
 
     %x{
@@ -834,14 +888,22 @@ Fixnum = Number
 class Integer < Numeric
   `self.$$is_number_class = true`
 
-  def self.===(other)
-    %x{
-      if (!other.$$is_number) {
-        return false;
-      }
+  class << self
+    def allocate
+      raise TypeError, "allocator undefined for #{self.name}"
+    end
 
-      return (other % 1) === 0;
-    }
+    undef :new
+
+    def ===(other)
+      %x{
+        if (!other.$$is_number) {
+          return false;
+        }
+
+        return (other % 1) === 0;
+      }
+    end
   end
 
   MAX = `Math.pow(2, 30) - 1`
@@ -851,8 +913,16 @@ end
 class Float < Numeric
   `self.$$is_number_class = true`
 
-  def self.===(other)
-    `!!other.$$is_number`
+  class << self
+    def allocate
+      raise TypeError, "allocator undefined for #{self.name}"
+    end
+
+    undef :new
+
+    def ===(other)
+      `!!other.$$is_number`
+    end
   end
 
   INFINITY = `Infinity`

data/opal/corelib/numeric.rb

@@ -172,10 +172,10 @@ class Numeric
   end
 
   def dup
-    raise TypeError, "can't dup #{self.class}"
+    self
   end
 
-  def clone
-    raise TypeError, "can't clone #{self.class}"
+  def clone(freeze: true)
+    self
   end
 end

data/opal/corelib/random.rb

@@ -81,7 +81,7 @@ class Random
           return min;
         }
 
-        if (max % 1 === 0 && min % 1 === 0 && !limit.exclude) {
+        if (max % 1 === 0 && min % 1 === 0 && !limit.excl) {
           length++;
         }
 

data/opal/corelib/range.rb

@@ -11,9 +11,9 @@ class Range
     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)
@@ -22,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
 
@@ -36,7 +36,7 @@ class Range
     beg_cmp = (@begin <=> value)
     return false unless beg_cmp && beg_cmp <= 0
     end_cmp = (value <=> @end)
-    if @exclude
+    if @excl
       end_cmp && end_cmp < 0
     else
       end_cmp && end_cmp <= 0
@@ -54,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);
         }
 
@@ -62,7 +62,7 @@ class Range
       }
 
       if (#@begin.$$is_string && #@end.$$is_string) {
-        #{@begin.upto(@end, @exclude, &block)}
+        #{@begin.upto(@end, @excl, &block)}
         return self;
       }
     }
@@ -80,7 +80,7 @@ class Range
       current = current.succ
     end
 
-    yield current if !@exclude && current == last
+    yield current if !@excl && current == last
 
     self
   end
@@ -88,13 +88,13 @@ 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
 
   def first(n = undefined)
@@ -115,10 +115,10 @@ class Range
       super
     elsif @begin > @end
       nil
-    elsif @exclude && @begin == @end
+    elsif @excl && @begin == @end
       nil
     else
-      `#@exclude ? #@end - 1 : #@end`
+      `#@excl ? #@end - 1 : #@end`
     end
   end
 
@@ -129,7 +129,7 @@ class Range
       super
     elsif @begin > @end
       nil
-    elsif @exclude && @begin == @end
+    elsif @excl && @begin == @end
       nil
     else
       @begin
@@ -139,7 +139,7 @@ class Range
   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
@@ -185,7 +185,7 @@ class Range
             err = 0.5;
           }
 
-          if (self.exclude) {
+          if (self.excl) {
             size = floor((end - begin) / n - err);
             if (size * n + begin < end) {
               size++;
@@ -215,7 +215,7 @@ class Range
       i = 0
       loop do
         current = @begin + i * n
-        if @exclude
+        if @excl
           break if current >= @end
         else
           break if current > @end
@@ -247,20 +247,20 @@ class Range
   end
 
   def to_s
-    "#{@begin}#{ @exclude ? '...' : '..' }#{@end}"
+    "#{@begin}#{ @excl ? '...' : '..' }#{@end}"
   end
 
   def inspect
-    "#{@begin.inspect}#{ @exclude ? '...' : '..' }#{@end.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, @exclude].hash
+    [@begin, @end, @excl].hash
   end
 end

data/opal/corelib/regexp.rb

@@ -199,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
@@ -230,10 +275,6 @@ class Regexp < `RegExp`
   end
 
   alias to_s source
-
-  def self._load(args)
-    self.new(*args)
-  end
 end
 
 class MatchData