opal 1.3.2 → 1.4.0.alpha1

data/opal/corelib/range.rb

@@ -1,15 +1,15 @@
 require 'corelib/enumerable'
 
-class Range
-  include Enumerable
+class ::Range
+  include ::Enumerable
 
   `self.$$prototype.$$is_range = true`
 
   attr_reader :begin, :end
 
   def initialize(first, last, exclude = false)
-    raise NameError, "'initialize' called twice" if @begin
-    raise ArgumentError, 'bad value for range' unless first <=> last || first.nil? || last.nil?
+    ::Kernel.raise ::NameError, "'initialize' called twice" if @begin
+    ::Kernel.raise ::ArgumentError, 'bad value for range' unless first <=> last || first.nil? || last.nil?
 
     @begin = first
     @end   = last
@@ -31,13 +31,13 @@ class Range
 
   def count(&block)
     if !block_given? && `is_infinite(self)`
-      return Float::INFINITY
+      return ::Float::INFINITY
     end
     super
   end
 
   def to_a
-    raise TypeError, 'cannot convert endless range to an array' if `is_infinite(self)`
+    ::Kernel.raise ::TypeError, 'cannot convert endless range to an array' if `is_infinite(self)`
     super
   end
 
@@ -59,7 +59,7 @@ class Range
 
       if (#{@begin}.$$is_number && #{@end}.$$is_number) {
         if (#{@begin} % 1 !== 0 || #{@end} % 1 !== 0) {
-          #{raise TypeError, "can't iterate from Float"}
+          #{::Kernel.raise ::TypeError, "can't iterate from Float"}
         }
 
         for (i = #{@begin}, limit = #{@end} + #{@excl ? 0 : 1}; i < limit; i++) {
@@ -79,7 +79,7 @@ class Range
     last    = @end
 
     unless current.respond_to?(:succ)
-      raise TypeError, "can't iterate from #{current.class}"
+      ::Kernel.raise ::TypeError, "can't iterate from #{current.class}"
     end
 
     while @end.nil? || (current <=> last) < 0
@@ -94,29 +94,25 @@ class Range
   end
 
   def eql?(other)
-    return false unless Range === other
+    return false unless ::Range === other
 
     @excl === other.exclude_end? &&
       @begin.eql?(other.begin) &&
       @end.eql?(other.end)
   end
 
-  alias == eql?
-
   def exclude_end?
     @excl
   end
 
   def first(n = undefined)
-    raise RangeError, 'cannot get the minimum of beginless range' if @begin.nil?
+    ::Kernel.raise ::RangeError, 'cannot get the minimum of beginless range' if @begin.nil?
     return @begin if `n == null`
     super
   end
 
-  alias include? cover?
-
   def last(n = undefined)
-    raise RangeError, 'cannot get the maximum of endless range' if @end.nil?
+    ::Kernel.raise ::RangeError, 'cannot get the maximum of endless range' if @end.nil?
     return @end if `n == null`
     to_a.last(n)
   end
@@ -124,7 +120,7 @@ class Range
   # FIXME: currently hardcoded to assume range holds numerics
   def max
     if @end.nil?
-      raise RangeError, 'cannot get the maximum of endless range'
+      ::Kernel.raise ::RangeError, 'cannot get the maximum of endless range'
     elsif block_given?
       super
     elsif !@begin.nil? && (@begin > @end ||
@@ -135,11 +131,9 @@ class Range
     end
   end
 
-  alias member? cover?
-
   def min
     if @begin.nil?
-      raise RangeError, 'cannot get the minimum of beginless range'
+      ::Kernel.raise ::RangeError, 'cannot get the minimum of beginless range'
     elsif block_given?
       super
     elsif !@end.nil? && (@begin > @end ||
@@ -151,11 +145,11 @@ class Range
   end
 
   def size
-    infinity = Float::INFINITY
+    infinity = ::Float::INFINITY
 
     return 0 if (@begin == infinity && !@end.nil?) || (@end == -infinity && !@begin.nil?)
     return infinity if `is_infinite(self)`
-    return nil unless Numeric === @begin && Numeric === @end
+    return nil unless ::Numeric === @begin && ::Numeric === @end
 
     range_begin = @begin
     range_end   = @end
@@ -166,17 +160,20 @@ class Range
     `Math.abs(range_end - range_begin) + 1`.to_i
   end
 
-  def step(n = 1)
+  def step(n = undefined)
     %x{
       function coerceStepSize() {
-        if (!n.$$is_number) {
-          n = #{Opal.coerce_to!(n, Integer, :to_int)}
+        if (n == null) {
+          n = 1;
+        }
+        else if (!n.$$is_number) {
+          n = #{::Opal.coerce_to!(n, ::Integer, :to_int)}
         }
 
         if (n < 0) {
-          #{raise ArgumentError, "step can't be negative"}
+          #{::Kernel.raise ::ArgumentError, "step can't be negative"}
         } else if (n === 0) {
-          #{raise ArgumentError, "step can't be 0"}
+          #{::Kernel.raise ::ArgumentError, "step can't be 0"}
         }
       }
 
@@ -195,7 +192,7 @@ class Range
           // 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},
+              err = (abs(begin) + abs(end) + abs(end - begin)) / abs(n) * #{::Float::EPSILON},
               size;
 
           if (err > 0.5) {
@@ -217,11 +214,18 @@ class Range
     }
 
     unless block_given?
-      return enum_for(:step, n) do
-        %x{
-          coerceStepSize();
-          return enumeratorSize();
-        }
+      if (@begin.is_a?(Numeric) || @begin.nil?) &&
+         (@end.is_a?(Numeric) || @end.nil?) &&
+         !(@begin.nil? && @end.nil?)
+
+        return ::Enumerator::ArithmeticSequence.new(self, n, :step)
+      else
+        return enum_for(:step, n) do
+          %x{
+            coerceStepSize();
+            return enumeratorSize();
+          }
+        end
       end
     end
 
@@ -242,7 +246,7 @@ class Range
     else
       %x{
         if (#{@begin}.$$is_string && #{@end}.$$is_string && n % 1 !== 0) {
-          #{raise TypeError, 'no implicit conversion to float from string'}
+          #{::Kernel.raise ::TypeError, 'no implicit conversion to float from string'}
         }
       }
       each_with_index do |value, idx|
@@ -252,15 +256,23 @@ class Range
     self
   end
 
+  def %(n)
+    if @begin.is_a?(Numeric) && @end.is_a?(Numeric)
+      ::Enumerator::ArithmeticSequence.new(self, n, :%)
+    else
+      step(n)
+    end
+  end
+
   def bsearch(&block)
     return enum_for(:bsearch) unless block_given?
 
     if `is_infinite(self) && (self.begin.$$is_number || self.end.$$is_number)`
-      raise NotImplementedError, "Can't #bsearch an infinite range"
+      ::Kernel.raise ::NotImplementedError, "Can't #bsearch an infinite range"
     end
 
     unless `self.begin.$$is_number && self.end.$$is_number`
-      raise TypeError, "can't do binary search for #{@begin.class}"
+      ::Kernel.raise ::TypeError, "can't do binary search for #{@begin.class}"
     end
 
     to_a.bsearch(&block)
@@ -283,4 +295,8 @@ class Range
   def hash
     [@begin, @end, @excl].hash
   end
+
+  alias == eql?
+  alias include? cover?
+  alias member? cover?
 end

data/opal/corelib/rational/base.rb

@@ -1,11 +1,11 @@
-module Kernel
+module ::Kernel
   def Rational(numerator, denominator = 1)
-    Rational.convert(numerator, denominator)
+    ::Rational.convert(numerator, denominator)
   end
 end
 
-class String
+class ::String
   def to_r
-    Rational.from_string(self)
+    ::Rational.from_string(self)
   end
 end

data/opal/corelib/rational.rb

@@ -1,13 +1,13 @@
 require 'corelib/numeric'
 require 'corelib/rational/base'
 
-class Rational < Numeric
+class ::Rational < ::Numeric
   def self.reduce(num, den)
     num = num.to_i
     den = den.to_i
 
     if den == 0
-      raise ZeroDivisionError, 'divided by 0'
+      ::Kernel.raise ::ZeroDivisionError, 'divided by 0'
     elsif den < 0
       num = -num
       den = -den
@@ -22,24 +22,24 @@ class Rational < Numeric
 
   def self.convert(num, den)
     if num.nil? || den.nil?
-      raise TypeError, 'cannot convert nil into Rational'
+      ::Kernel.raise ::TypeError, 'cannot convert nil into Rational'
     end
 
-    if Integer === num && Integer === den
+    if ::Integer === num && ::Integer === den
       return reduce(num, den)
     end
 
-    if Float === num || String === num || Complex === num
+    if ::Float === num || ::String === num || ::Complex === num
       num = num.to_r
     end
 
-    if Float === den || String === den || Complex === den
+    if ::Float === den || ::String === den || ::Complex === den
       den = den.to_r
     end
 
-    if den.equal?(1) && !(Integer === num)
-      Opal.coerce_to!(num, Rational, :to_r)
-    elsif Numeric === num && Numeric === den
+    if den.equal?(1) && !(::Integer === num)
+      ::Opal.coerce_to!(num, ::Rational, :to_r)
+    elsif ::Numeric === num && ::Numeric === den
       num / den
     else
       reduce(num, den)
@@ -61,26 +61,26 @@ class Rational < Numeric
 
   def coerce(other)
     case other
-    when Rational
+    when ::Rational
       [other, self]
 
-    when Integer
+    when ::Integer
       [other.to_r, self]
 
-    when Float
+    when ::Float
       [other, to_f]
     end
   end
 
   def ==(other)
     case other
-    when Rational
+    when ::Rational
       @num == other.numerator && @den == other.denominator
 
-    when Integer
+    when ::Integer
       @num == other && @den == 1
 
-    when Float
+    when ::Float
       to_f == other
 
     else
@@ -90,13 +90,13 @@ class Rational < Numeric
 
   def <=>(other)
     case other
-    when Rational
+    when ::Rational
       @num * other.denominator - @den * other.numerator <=> 0
 
-    when Integer
+    when ::Integer
       @num - @den * other <=> 0
 
-    when Float
+    when ::Float
       to_f <=> other
 
     else
@@ -106,16 +106,16 @@ class Rational < Numeric
 
   def +(other)
     case other
-    when Rational
+    when ::Rational
       num = @num * other.denominator + @den * other.numerator
       den = @den * other.denominator
 
-      Rational(num, den)
+      ::Kernel.Rational(num, den)
 
-    when Integer
-      Rational(@num + other * @den, @den)
+    when ::Integer
+      ::Kernel.Rational(@num + other * @den, @den)
 
-    when Float
+    when ::Float
       to_f + other
 
     else
@@ -125,16 +125,16 @@ class Rational < Numeric
 
   def -(other)
     case other
-    when Rational
+    when ::Rational
       num = @num * other.denominator - @den * other.numerator
       den = @den * other.denominator
 
-      Rational(num, den)
+      ::Kernel.Rational(num, den)
 
-    when Integer
-      Rational(@num - other * @den, @den)
+    when ::Integer
+      ::Kernel.Rational(@num - other * @den, @den)
 
-    when Float
+    when ::Float
       to_f - other
 
     else
@@ -144,16 +144,16 @@ class Rational < Numeric
 
   def *(other)
     case other
-    when Rational
+    when ::Rational
       num = @num * other.numerator
       den = @den * other.denominator
 
-      Rational(num, den)
+      ::Kernel.Rational(num, den)
 
-    when Integer
-      Rational(@num * other, @den)
+    when ::Integer
+      ::Kernel.Rational(@num * other, @den)
 
-    when Float
+    when ::Float
       to_f * other
 
     else
@@ -163,20 +163,20 @@ class Rational < Numeric
 
   def /(other)
     case other
-    when Rational
+    when ::Rational
       num = @num * other.denominator
       den = @den * other.numerator
 
-      Rational(num, den)
+      ::Kernel.Rational(num, den)
 
-    when Integer
+    when ::Integer
       if other == 0
         to_f / 0.0
       else
-        Rational(@num, @den * other)
+        ::Kernel.Rational(@num, @den * other)
       end
 
-    when Float
+    when ::Float
       to_f / other
 
     else
@@ -186,31 +186,31 @@ class Rational < Numeric
 
   def **(other)
     case other
-    when Integer
+    when ::Integer
       if self == 0 && other < 0
-        Float::INFINITY
+        ::Float::INFINITY
       elsif other > 0
-        Rational(@num**other, @den**other)
+        ::Kernel.Rational(@num**other, @den**other)
       elsif other < 0
-        Rational(@den**-other, @num**-other)
+        ::Kernel.Rational(@den**-other, @num**-other)
       else
-        Rational(1, 1)
+        ::Kernel.Rational(1, 1)
       end
 
-    when Float
+    when ::Float
       to_f**other
 
-    when Rational
+    when ::Rational
       if other == 0
-        Rational(1, 1)
+        ::Kernel.Rational(1, 1)
       elsif other.denominator == 1
         if other < 0
-          Rational(@den**other.numerator.abs, @num**other.numerator.abs)
+          ::Kernel.Rational(@den**other.numerator.abs, @num**other.numerator.abs)
         else
-          Rational(@num**other.numerator, @den**other.numerator)
+          ::Kernel.Rational(@num**other.numerator, @den**other.numerator)
         end
       elsif self == 0 && other < 0
-        raise ZeroDivisionError, 'divided by 0'
+        ::Kernel.raise ::ZeroDivisionError, 'divided by 0'
       else
         to_f**other
       end
@@ -221,7 +221,7 @@ class Rational < Numeric
   end
 
   def abs
-    Rational(@num.abs, @den.abs)
+    ::Kernel.Rational(@num.abs, @den.abs)
   end
 
   def ceil(precision = 0)
@@ -232,8 +232,6 @@ class Rational < Numeric
     end
   end
 
-  alias divide /
-
   def floor(precision = 0)
     if precision == 0
       (-(-@num / @den)).floor
@@ -250,12 +248,10 @@ class Rational < Numeric
     "(#{self})"
   end
 
-  alias quo /
-
   def rationalize(eps = undefined)
     %x{
       if (arguments.length > 1) {
-        #{raise ArgumentError, "wrong number of arguments (#{`arguments.length`} for 0..1)"};
+        #{::Kernel.raise ::ArgumentError, "wrong number of arguments (#{`arguments.length`} for 0..1)"};
       }
 
       if (eps == null) {
@@ -294,7 +290,7 @@ class Rational < Numeric
         q1 = q2;
       }
 
-      return #{Rational(`c * p1 + p0`, `c * q1 + q0`)};
+      return #{::Kernel.Rational(`c * p1 + p0`, `c * q1 + q0`)};
     }
   end
 
@@ -340,7 +336,7 @@ class Rational < Numeric
   end
 
   def with_precision(method, precision)
-    raise TypeError, 'not an Integer' unless Integer === precision
+    ::Kernel.raise ::TypeError, 'not an Integer' unless ::Integer === precision
 
     p = 10**precision
     s = self * p
@@ -348,7 +344,7 @@ class Rational < Numeric
     if precision < 1
       (s.send(method) / p).to_i
     else
-      Rational(s.send(method), p)
+      ::Kernel.Rational(s.send(method), p)
     end
   end
 
@@ -379,16 +375,19 @@ class Rational < Numeric
 
           if (isFloat()) {
             denominator = parseFloat(cutFloat());
-            return #{Rational(`numerator`, `denominator`)};
+            return #{::Kernel.Rational(`numerator`, `denominator`)};
           } else {
-            return #{Rational(`numerator`, 1)};
+            return #{::Kernel.Rational(`numerator`, 1)};
           }
         } else {
-          return #{Rational(`numerator`, 1)};
+          return #{::Kernel.Rational(`numerator`, 1)};
         }
       } else {
-        return #{Rational(0, 1)};
+        return #{::Kernel.Rational(0, 1)};
       }
     }
   end
+
+  alias divide /
+  alias quo /
 end