opal 1.3.1 → 1.4.1

data/opal/corelib/numeric.rb

@@ -1,14 +1,14 @@
 require 'corelib/comparable'
 
-class Numeric
-  include Comparable
+class ::Numeric
+  include ::Comparable
 
   def coerce(other)
     if other.instance_of? self.class
       return [other, self]
     end
 
-    [Float(other), Float(self)]
+    [::Kernel.Float(other), ::Kernel.Float(self)]
   end
 
   def __coerced__(method, other)
@@ -18,9 +18,9 @@ class Numeric
     else
       case method
       when :+, :-, :*, :/, :%, :&, :|, :^, :**
-        raise TypeError, "#{other.class} can't be coerced into Numeric"
+        ::Kernel.raise ::TypeError, "#{other.class} can't be coerced into Numeric"
       when :>, :>=, :<, :<=, :<=>
-        raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+        ::Kernel.raise ::ArgumentError, "comparison of #{self.class} with #{other.class} failed"
       end
     end
   end
@@ -54,11 +54,9 @@ class Numeric
   end
 
   def angle
-    self < 0 ? Math::PI : 0
+    self < 0 ? ::Math::PI : 0
   end
 
-  alias arg angle
-
   def ceil(ndigits = 0)
     to_f.ceil(ndigits)
   end
@@ -67,14 +65,12 @@ class Numeric
     self
   end
 
-  alias conjugate conj
-
   def denominator
     to_r.denominator
   end
 
   def div(other)
-    raise ZeroDivisionError, 'divided by o' if other == 0
+    ::Kernel.raise ::ZeroDivisionError, 'divided by o' if other == 0
 
     (self / other).floor
   end
@@ -92,23 +88,17 @@ class Numeric
   end
 
   def i
-    Complex(0, self)
+    ::Kernel.Complex(0, self)
   end
 
   def imag
     0
   end
 
-  alias imaginary imag
-
   def integer?
     false
   end
 
-  alias magnitude abs
-
-  alias modulo %
-
   def nonzero?
     zero? ? nil : self
   end
@@ -117,14 +107,12 @@ class Numeric
     to_r.numerator
   end
 
-  alias phase arg
-
   def polar
     [abs, arg]
   end
 
   def quo(other)
-    Opal.coerce_to!(self, Rational, :to_r) / other
+    ::Opal.coerce_to!(self, ::Rational, :to_r) / other
   end
 
   def real
@@ -139,8 +127,6 @@ class Numeric
     [self, 0]
   end
 
-  alias rectangular rect
-
   def round(digits = undefined)
     to_f.round(digits)
   end
@@ -148,11 +134,11 @@ class Numeric
   def step(limit = undefined, step = undefined, to: undefined, by: undefined, &block)
     %x{
       if (limit !== undefined && to !== undefined) {
-        #{raise ArgumentError, 'to is given twice'}
+        #{::Kernel.raise ::ArgumentError, 'to is given twice'}
       }
 
       if (step !== undefined && by !== undefined) {
-        #{raise ArgumentError, 'step is given twice'}
+        #{::Kernel.raise ::ArgumentError, 'step is given twice'}
       }
 
       if (to !== undefined) {
@@ -169,11 +155,11 @@ class Numeric
 
       function validateParameters() {
         if (step === nil) {
-          #{raise TypeError, 'step must be numeric'}
+          #{::Kernel.raise ::TypeError, 'step must be numeric'}
         }
 
         if (step != null && #{step == 0}) {
-          #{raise ArgumentError, "step can't be 0"}
+          #{::Kernel.raise ::ArgumentError, "step can't be 0"}
         }
 
         if (step === nil || step == null) {
@@ -183,14 +169,14 @@ class Numeric
         var sign = #{step <=> 0};
 
         if (sign === nil) {
-          #{raise ArgumentError, "0 can't be coerced into #{step.class}"}
+          #{::Kernel.raise ::ArgumentError, "0 can't be coerced into #{step.class}"}
         }
 
         if (limit === nil || limit == null) {
-          limit = sign > 0 ? #{Float::INFINITY} : #{-Float::INFINITY};
+          limit = sign > 0 ? #{::Float::INFINITY} : #{-::Float::INFINITY};
         }
 
-        #{Opal.compare(self, limit)}
+        #{::Opal.compare(self, limit)}
       }
 
       function stepFloatSize() {
@@ -200,7 +186,7 @@ class Numeric
           return 1;
         } else {
           var abs = Math.abs, floor = Math.floor,
-              err = (abs(self) + abs(limit) + abs(limit - self)) / abs(step) * #{Float::EPSILON};
+              err = (abs(self) + abs(limit) + abs(limit - self)) / abs(step) * #{::Float::EPSILON};
 
           if (err === Infinity || err === -Infinity) {
             return 0;
@@ -236,7 +222,17 @@ class Numeric
 
     }
 
-    return enum_for(:step, limit, step, &`stepSize`) unless block_given?
+    unless block_given?
+      if (!limit || limit.is_a?(::Numeric)) &&
+         (!step || step.is_a?(::Numeric))
+
+        return ::Enumerator::ArithmeticSequence.new(
+          [limit, step, ('to: ' if to), ('by: ' if by)], self
+        )
+      else
+        return enum_for(:step, limit, step, &`stepSize`)
+      end
+    end
 
     %x{
       validateParameters();
@@ -302,7 +298,7 @@ class Numeric
   end
 
   def to_c
-    Complex(self, 0)
+    ::Kernel.Complex(self, 0)
   end
 
   def to_int
@@ -340,4 +336,12 @@ class Numeric
   def infinite?
     nil
   end
+
+  alias arg angle
+  alias conjugate conj
+  alias imaginary imag
+  alias magnitude abs
+  alias modulo %
+  alias phase arg
+  alias rectangular rect
 end

data/opal/corelib/object_space.rb

@@ -1,6 +1,6 @@
-# helpers: respond_to, falsy, truthy
+# helpers: respond_to, truthy
 
-module ObjectSpace
+module ::ObjectSpace
   module_function
 
   %x{
@@ -36,9 +36,9 @@ module ObjectSpace
   def define_finalizer(obj, aproc = undefined, &block)
     %x{
       if ($truthy(block)) aproc = block;
-      if ($falsy(aproc)) aproc = #{proc};
+      if (!$truthy(aproc)) aproc = #{::Kernel.proc};
       if (!$respond_to(aproc, '$call')) {
-        #{raise ArgumentError, "Wrong type argument #{aproc.class} (should be callable)"};
+        #{::Kernel.raise ::ArgumentError, "Wrong type argument #{aproc.class} (should be callable)"};
       }
       var id = #{obj.__id__};
       add_caller(id, aproc);
@@ -47,7 +47,7 @@ module ObjectSpace
       }
       catch (e) {
         delete_callers(id);
-        #{raise ArgumentError, "cannot define finalizer for #{obj.class}"};
+        #{::Kernel.raise ::ArgumentError, "cannot define finalizer for #{obj.class}"};
       }
       return [0, aproc];
     }
@@ -62,8 +62,8 @@ module ObjectSpace
     }
   end
 
-  class WeakMap
-    include Enumerable
+  class self::WeakMap
+    include ::Enumerable
 
     def initialize
       @weak_map = `new WeakMap()`
@@ -90,13 +90,14 @@ module ObjectSpace
         return #{@weak_map}.has(p1);
       }
     end
-    alias member? include?
-    alias key? include?
 
     %i[each each_key each_value each_pair keys values size length].each do |i|
       define_method i do |*|
-        raise NotImplementedError, "##{i} can't be implemented on top of JS interfaces"
+        ::Kernel.raise ::NotImplementedError, "##{i} can't be implemented on top of JS interfaces"
       end
     end
+
+    alias member? include?
+    alias key? include?
   end
 end

data/opal/corelib/pack_unpack/format_string_parser.rb

@@ -1,4 +1,4 @@
-module PackUnpack
+module ::PackUnpack
   %x{
     var directives = [
       // Integer
@@ -84,11 +84,11 @@ module PackUnpack
         var directiveSupportsModifiers = /[sSiIlLqQjJ]/.test(currentDirective);
 
         if (!directiveSupportsModifiers && currentModifiers.length > 0) {
-          #{raise ArgumentError, "'#{`currentModifiers[0]`}' allowed only after types sSiIlLqQjJ"}
+          #{::Kernel.raise ::ArgumentError, "'#{`currentModifiers[0]`}' allowed only after types sSiIlLqQjJ"}
         }
 
         if (currentModifiers.indexOf('<') !== -1 && currentModifiers.indexOf('>') !== -1) {
-          #{raise RangeError, "Can't use both '<' and '>'"}
+          #{::Kernel.raise ::RangeError, "Can't use both '<' and '>'"}
         }
 
         if (!countSpecified) {

data/opal/corelib/pattern_matching/base.rb

@@ -1,28 +1,28 @@
-class Array
+class ::Array
   def deconstruct
     self
   end
 end
 
-class Hash
+class ::Hash
   def deconstruct_keys(_)
     self
   end
 end
 
-class Struct
+class ::Struct
   alias deconstruct to_a
   # This function is specified in a very weird way...
   def deconstruct_keys(keys)
     return to_h if keys.nil?
-    raise TypeError, 'expected Array or nil' unless Array === keys
+    ::Kernel.raise ::TypeError, 'expected Array or nil' unless ::Array === keys
     return {} if keys.length > values.length
     out = {}
     keys.each do |key|
       should_break = case key
-                     when Integer
+                     when ::Integer
                        values.length < key
-                     when Symbol # Or String? Doesn't matter, we're in Opal.
+                     when ::Symbol # Or String? Doesn't matter, we're in Opal.
                        !members.include?(key)
                      end
       break if should_break
@@ -32,4 +32,4 @@ class Struct
   end
 end
 
-class NoMatchingPatternError < StandardError; end
+class ::NoMatchingPatternError < ::StandardError; end

data/opal/corelib/pattern_matching.rb

@@ -2,7 +2,7 @@ require 'corelib/pattern_matching/base'
 
 # A "userland" implementation of pattern matching for Opal
 
-class PatternMatching
+class ::PatternMatching
   def self.call(from, pattern)
     pm = new(from, pattern)
     pm.match || (return nil)

data/opal/corelib/proc.rb

@@ -1,12 +1,12 @@
 # helpers: slice
 
-class Proc < `Function`
-  `Opal.defineProperty(self.$$prototype, '$$is_proc', true)`
-  `Opal.defineProperty(self.$$prototype, '$$is_lambda', false)`
+class ::Proc < `Function`
+  `Opal.prop(self.$$prototype, '$$is_proc', true)`
+  `Opal.prop(self.$$prototype, '$$is_lambda', false)`
 
   def self.new(&block)
     unless block
-      raise ArgumentError, 'tried to create a Proc object without a block'
+      ::Kernel.raise ::ArgumentError, 'tried to create a Proc object without a block'
     end
 
     block
@@ -50,19 +50,15 @@ class Proc < `Function`
     }
   end
 
-  alias [] call
-  alias === call
-  alias yield call
-
   def >>(other)
-    proc do |*args, &block|
+    ::Kernel.proc do |*args, &block|
       out = call(*args, &block)
       other.call(out)
     end
   end
 
   def <<(other)
-    proc do |*args, &block|
+    ::Kernel.proc do |*args, &block|
       out = other.call(*args, &block)
       call(out)
     end
@@ -94,10 +90,10 @@ class Proc < `Function`
   end
 
   def binding
-    `if (self.$$is_curried) { #{raise ArgumentError, "Can't create Binding"} }`
+    `if (self.$$is_curried) { #{::Kernel.raise ::ArgumentError, "Can't create Binding"} }`
 
-    if defined? Binding
-      Binding.new(nil, [], `self.$$s`, source_location)
+    if defined? ::Binding
+      ::Binding.new(nil, [], `self.$$s`, source_location)
     end
   end
 
@@ -136,9 +132,9 @@ class Proc < `Function`
         arity = self.length;
       }
       else {
-        arity = #{Opal.coerce_to!(arity, Integer, :to_int)};
+        arity = #{::Opal.coerce_to!(arity, ::Integer, :to_int)};
         if (self.$$is_lambda && arity !== self.length) {
-          #{raise ArgumentError, "wrong number of arguments (#{`arity`} for #{`self.length`})"}
+          #{::Kernel.raise ::ArgumentError, "wrong number of arguments (#{`arity`} for #{`self.length`})"}
         }
       }
 
@@ -148,7 +144,7 @@ class Proc < `Function`
             result;
 
         if (length > arity && self.$$is_lambda && !self.$$is_curried) {
-          #{raise ArgumentError, "wrong number of arguments (#{`length`} for #{`arity`})"}
+          #{::Kernel.raise ::ArgumentError, "wrong number of arguments (#{`length`} for #{`arity`})"}
         }
 
         if (length >= arity) {
@@ -188,5 +184,8 @@ class Proc < `Function`
     }
   end
 
+  alias === call
   alias clone dup
+  alias yield call
+  alias [] call
 end

data/opal/corelib/process/base.rb

@@ -1,9 +1,9 @@
-class Signal
+class ::Signal
   def self.trap(*)
   end
 end
 
-class GC
+class ::GC
   def self.start
   end
 end

data/opal/corelib/process/status.rb

@@ -0,0 +1,21 @@
+module ::Process
+  class Status
+    def initialize(status, pid)
+      @status, @pid = status, pid
+    end
+
+    def exitstatus
+      @status
+    end
+
+    attr_reader :pid
+
+    def success?
+      @status == 0
+    end
+
+    def inspect
+      "#<Process::Status: pid #{@pid} exit #{@status}>"
+    end
+  end
+end

data/opal/corelib/process.rb

@@ -1,4 +1,4 @@
-module Process
+module ::Process
   @__clocks__ = []
   def self.__register_clock__(name, func)
     const_set name, @__clocks__.size
@@ -34,12 +34,12 @@ module Process
   end
 
   def self.times
-    t = Time.now.to_f
-    Benchmark::Tms.new(t, t, t, t, t)
+    t = ::Time.now.to_f
+    ::Benchmark::Tms.new(t, t, t, t, t)
   end
 
   def self.clock_gettime(clock_id, unit = :float_second)
-    (clock = @__clocks__[clock_id]) || raise(Errno::EINVAL, "clock_gettime(#{clock_id}) #{@__clocks__[clock_id]}")
+    (clock = @__clocks__[clock_id]) || ::Kernel.raise(::Errno::EINVAL, "clock_gettime(#{clock_id}) #{@__clocks__[clock_id]}")
     %x{
       var ms = clock();
       switch (unit) {
@@ -50,7 +50,7 @@ module Process
         case 'millisecond':       return ((ms / 1)       | 0); // number of milliseconds as an integer
         case 'microsecond':       return ((ms * 1000)    | 0); // number of microseconds as an integer
         case 'nanosecond':        return ((ms * 1000000) | 0); // number of nanoseconds as an integer
-        default: #{raise ArgumentError, "unexpected unit: #{unit}"}
+        default: #{::Kernel.raise ::ArgumentError, "unexpected unit: #{unit}"}
       }
     }
   end

data/opal/corelib/random/formatter.rb

@@ -1,7 +1,7 @@
-class Random
-  module Formatter
+class ::Random
+  module self::Formatter
     def hex(count = nil)
-      count = Random._verify_count(count)
+      count = ::Random._verify_count(count)
       %x{
         var bytes = #{bytes(count)};
         var out = "";
@@ -17,11 +17,11 @@ class Random
     end
 
     def base64(count = nil)
-      Base64.strict_encode64(random_bytes(count)).encode('US-ASCII')
+      ::Base64.strict_encode64(random_bytes(count)).encode('US-ASCII')
     end
 
     def urlsafe_base64(count = nil, padding = false)
-      Base64.urlsafe_encode64(random_bytes(count), padding).encode('US-ASCII')
+      ::Base64.urlsafe_encode64(random_bytes(count), padding).encode('US-ASCII')
     end
 
     def uuid
@@ -87,7 +87,7 @@ class Random
           return randomRange();
         } else if (limit.$$is_number) {
           if (limit <= 0) {
-            #{raise ArgumentError, "invalid argument - #{limit}"}
+            #{::Kernel.raise ::ArgumentError, "invalid argument - #{limit}"}
           }
 
           if (limit % 1 === 0) {
@@ -97,10 +97,10 @@ class Random
             return randomFloat() * limit;
           }
         } else {
-          limit = #{Opal.coerce_to!(limit, Integer, :to_int)};
+          limit = #{::Opal.coerce_to!(limit, ::Integer, :to_int)};
 
           if (limit <= 0) {
-            #{raise ArgumentError, "invalid argument - #{limit}"}
+            #{::Kernel.raise ::ArgumentError, "invalid argument - #{limit}"}
           }
 
           return randomInt(limit);
@@ -111,12 +111,12 @@ class Random
     def alphanumeric(count = nil)
       count = Random._verify_count(count)
       map = ['0'..'9', 'a'..'z', 'A'..'Z'].map(&:to_a).flatten
-      Array.new(count) do |i|
+      ::Array.new(count) do |i|
         map[random_number(map.length)]
       end.join
     end
   end
 
-  include Random::Formatter
-  extend Random::Formatter
+  include ::Random::Formatter
+  extend ::Random::Formatter
 end

data/opal/corelib/random/math_random.js.rb

@@ -1,4 +1,4 @@
-class Random
+class ::Random
   MATH_RANDOM_GENERATOR = `{
     new_seed: function() { return 0; },
     reseed: function(seed) { return {}; },

data/opal/corelib/random/mersenne_twister.rb

@@ -134,14 +134,14 @@ mersenne_twister = %x{(function() {
   return { genrand_real: genrand_real, init: init };
 })()}
 
-class Random
+class ::Random
   `var MAX_INT = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1`
 
-  MERSENNE_TWISTER_GENERATOR = `{
+  self::MERSENNE_TWISTER_GENERATOR = `{
     new_seed: function() { return Math.round(Math.random() * MAX_INT); },
     reseed: function(seed) { return mersenne_twister.init(seed); },
     rand: function(mt) { return mersenne_twister.genrand_real(mt); }
   }`
 
-  self.generator = MERSENNE_TWISTER_GENERATOR
+  self.generator = self::MERSENNE_TWISTER_GENERATOR
 end

data/opal/corelib/random/seedrandom.js.rb

@@ -1,4 +1,4 @@
-class Random
+class ::Random
   %x{
     var module = { exports: {} };
 
@@ -17,11 +17,11 @@ class Random
     var $seed_generator = new Math.seedrandom('opal', { entropy: true })
   }
 
-  SEEDRANDOM_GENERATOR = `{
+  self::SEEDRANDOM_GENERATOR = `{
     new_seed: function() { return Math.abs($seed_generator.int32()); },
     reseed: function(seed) { return new seedrandom(seed); },
     rand: function($rng) { return $rng.quick(); }
   }`
 
-  self.generator = SEEDRANDOM_GENERATOR
+  self.generator = self::SEEDRANDOM_GENERATOR
 end

data/opal/corelib/random.rb

@@ -1,22 +1,22 @@
-# helpers: falsy
+# helpers: truthy
 
 require 'corelib/random/formatter'
 
-class Random
+class ::Random
   attr_reader :seed, :state
 
   def self._verify_count(count)
     %x{
-      if ($falsy(count)) count = 16;
+      if (!$truthy(count)) count = 16;
       if (typeof count !== "number") count = #{`count`.to_int};
-      if (count < 0) #{raise ArgumentError, 'negative string size (or size too big)'};
+      if (count < 0) #{::Kernel.raise ::ArgumentError, 'negative string size (or size too big)'};
       count = Math.floor(count);
       return count;
     }
   end
 
-  def initialize(seed = Random.new_seed)
-    seed = Opal.coerce_to!(seed, Integer, :to_int)
+  def initialize(seed = ::Random.new_seed)
+    seed = ::Opal.coerce_to!(seed, ::Integer, :to_int)
     @state = seed
     reseed(seed)
   end
@@ -31,14 +31,14 @@ class Random
   end
 
   def self.rand(limit = undefined)
-    DEFAULT.rand(limit)
+    self::DEFAULT.rand(limit)
   end
 
-  def self.srand(n = Random.new_seed)
-    n = Opal.coerce_to!(n, Integer, :to_int)
+  def self.srand(n = ::Random.new_seed)
+    n = ::Opal.coerce_to!(n, ::Integer, :to_int)
 
-    previous_seed = DEFAULT.seed
-    DEFAULT.reseed(n)
+    previous_seed = self::DEFAULT.seed
+    self::DEFAULT.reseed(n)
     previous_seed
   end
 
@@ -47,19 +47,19 @@ class Random
   end
 
   def ==(other)
-    return false unless Random === other
+    return false unless ::Random === other
 
     seed == other.seed && state == other.state
   end
 
   def bytes(length)
-    length = Random._verify_count(length)
+    length = ::Random._verify_count(length)
 
-    Array.new(length) { rand(255).chr }.join.encode('ASCII-8BIT')
+    ::Array.new(length) { rand(255).chr }.join.encode('ASCII-8BIT')
   end
 
   def self.bytes(length)
-    DEFAULT.bytes(length)
+    self::DEFAULT.bytes(length)
   end
 
   def rand(limit = undefined)
@@ -77,14 +77,14 @@ class Random
   end
 
   def self.random_float
-    DEFAULT.random_float
+    self::DEFAULT.random_float
   end
 
   def self.generator=(generator)
     `Opal.$$rand = #{generator}`
 
     if const_defined? :DEFAULT
-      DEFAULT.reseed
+      self::DEFAULT.reseed
     else
       const_set :DEFAULT, new(new_seed)
     end