opal 1.3.2 → 1.4.0.alpha1

data/opal/corelib/struct.rb

@@ -1,19 +1,19 @@
 require 'corelib/enumerable'
 
-class Struct
-  include Enumerable
+class ::Struct
+  include ::Enumerable
 
   def self.new(const_name, *args, keyword_init: false, &block)
     if const_name
-      if const_name.class == String && const_name[0].upcase != const_name[0]
+      if const_name.class == ::String && const_name[0].upcase != const_name[0]
         # Fast track so that we skip needlessly going thru exceptions
         # in most cases.
         args.unshift(const_name)
         const_name = nil
       else
         begin
-          const_name = Opal.const_name!(const_name)
-        rescue TypeError, NameError
+          const_name = ::Opal.const_name!(const_name)
+        rescue ::TypeError, ::NameError
           args.unshift(const_name)
           const_name = nil
         end
@@ -21,10 +21,10 @@ class Struct
     end
 
     args.map do |arg|
-      Opal.coerce_to!(arg, String, :to_str)
+      ::Opal.coerce_to!(arg, ::String, :to_str)
     end
 
-    klass = Class.new(self) do
+    klass = ::Class.new(self) do
       args.each { |arg| define_struct_attribute(arg) }
 
       class << self
@@ -43,15 +43,15 @@ class Struct
     `klass.$$keyword_init = keyword_init`
 
     if const_name
-      Struct.const_set(const_name, klass)
+      ::Struct.const_set(const_name, klass)
     end
 
     klass
   end
 
   def self.define_struct_attribute(name)
-    if self == Struct
-      raise ArgumentError, 'you cannot define attributes to the Struct class'
+    if self == ::Struct
+      ::Kernel.raise ::ArgumentError, 'you cannot define attributes to the Struct class'
     end
 
     members << name
@@ -66,8 +66,8 @@ class Struct
   end
 
   def self.members
-    if self == Struct
-      raise ArgumentError, 'the Struct class has no members'
+    if self == ::Struct
+      ::Kernel.raise ::ArgumentError, 'the Struct class has no members'
     end
 
     @members ||= []
@@ -86,12 +86,12 @@ class Struct
       kwargs = args.last || {}
 
       if args.length > 1 || `(args.length === 1 && !kwargs.$$is_hash)`
-        raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 0)"
+        ::Kernel.raise ::ArgumentError, "wrong number of arguments (given #{args.length}, expected 0)"
       end
 
       extra = kwargs.keys - self.class.members
       if extra.any?
-        raise ArgumentError, "unknown keywords: #{extra.join(', ')}"
+        ::Kernel.raise ::ArgumentError, "unknown keywords: #{extra.join(', ')}"
       end
 
       self.class.members.each do |name|
@@ -99,7 +99,7 @@ class Struct
       end
     else
       if args.length > self.class.members.length
-        raise ArgumentError, 'struct size differs'
+        ::Kernel.raise ::ArgumentError, 'struct size differs'
       end
 
       self.class.members.each_with_index do |name, index|
@@ -119,6 +119,10 @@ class Struct
     }
   end
 
+  def self.keyword_init?
+    `self.$$keyword_init`
+  end
+
   def members
     self.class.members
   end
@@ -128,38 +132,38 @@ class Struct
   end
 
   def [](name)
-    if Integer === name
-      raise IndexError, "offset #{name} too small for struct(size:#{self.class.members.size})" if name < -self.class.members.size
-      raise IndexError, "offset #{name} too large for struct(size:#{self.class.members.size})" if name >= self.class.members.size
+    if ::Integer === name
+      ::Kernel.raise ::IndexError, "offset #{name} too small for struct(size:#{self.class.members.size})" if name < -self.class.members.size
+      ::Kernel.raise ::IndexError, "offset #{name} too large for struct(size:#{self.class.members.size})" if name >= self.class.members.size
 
       name = self.class.members[name]
-    elsif String === name
+    elsif ::String === name
       %x{
         if(!self.$$data.hasOwnProperty(name)) {
-          #{raise NameError.new("no member '#{name}' in struct", name)}
+          #{::Kernel.raise ::NameError.new("no member '#{name}' in struct", name)}
         }
       }
     else
-      raise TypeError, "no implicit conversion of #{name.class} into Integer"
+      ::Kernel.raise ::TypeError, "no implicit conversion of #{name.class} into Integer"
     end
 
-    name = Opal.coerce_to!(name, String, :to_str)
+    name = ::Opal.coerce_to!(name, ::String, :to_str)
     `self.$$data[name]`
   end
 
   def []=(name, value)
-    if Integer === name
-      raise IndexError, "offset #{name} too small for struct(size:#{self.class.members.size})" if name < -self.class.members.size
-      raise IndexError, "offset #{name} too large for struct(size:#{self.class.members.size})" if name >= self.class.members.size
+    if ::Integer === name
+      ::Kernel.raise ::IndexError, "offset #{name} too small for struct(size:#{self.class.members.size})" if name < -self.class.members.size
+      ::Kernel.raise ::IndexError, "offset #{name} too large for struct(size:#{self.class.members.size})" if name >= self.class.members.size
 
       name = self.class.members[name]
-    elsif String === name
-      raise NameError.new("no member '#{name}' in struct", name) unless self.class.members.include?(name.to_sym)
+    elsif ::String === name
+      ::Kernel.raise ::NameError.new("no member '#{name}' in struct", name) unless self.class.members.include?(name.to_sym)
     else
-      raise TypeError, "no implicit conversion of #{name.class} into Integer"
+      ::Kernel.raise ::TypeError, "no implicit conversion of #{name.class} into Integer"
     end
 
-    name = Opal.coerce_to!(name, String, :to_str)
+    name = ::Opal.coerce_to!(name, ::String, :to_str)
     `self.$$data[name] = value`
   end
 
@@ -179,7 +183,7 @@ class Struct
           a = struct.$$data[key];
           b = other.$$data[key];
 
-          if (#{Struct === `a`}) {
+          if (#{::Struct === `a`}) {
             if (!recursed1.hasOwnProperty(#{`a`.__id__}) || !recursed2.hasOwnProperty(#{`b`.__id__})) {
               if (!_eqeq(a, b)) {
                 return false;
@@ -215,7 +219,7 @@ class Struct
           a = struct.$$data[key];
           b = other.$$data[key];
 
-          if (#{Struct === `a`}) {
+          if (#{::Struct === `a`}) {
             if (!recursed1.hasOwnProperty(#{`a`.__id__}) || !recursed2.hasOwnProperty(#{`b`.__id__})) {
               if (!_eqeq(a, b)) {
                 return false;
@@ -253,32 +257,37 @@ class Struct
     self.class.members.length
   end
 
-  alias size length
-
   def to_a
     self.class.members.map { |name| self[name] }
   end
 
-  alias values to_a
+  `var inspect_stack = []`
 
   def inspect
     result = '#<struct '
 
-    if Struct === self && self.class.name
-      result += "#{self.class} "
-    end
+    if `inspect_stack`.include? __id__
+      result + ':...>'
+    else
+      `inspect_stack` << __id__
+      pushed = true
+
+      if ::Struct === self && self.class.name
+        result += "#{self.class} "
+      end
 
-    result += each_pair.map do |name, value|
-      "#{name}=#{value.inspect}"
-    end.join ', '
+      result += each_pair.map do |name, value|
+        "#{name}=#{Opal.inspect(value)}"
+      end.join ', '
 
-    result += '>'
+      result += '>'
 
-    result
+      result
+    end
+  ensure
+    `inspect_stack.pop()` if pushed
   end
 
-  alias to_s inspect
-
   def to_h(&block)
     return map(&block).to_h(*args) if block_given?
 
@@ -291,7 +300,7 @@ class Struct
       var result = [];
       for (var i = 0, len = args.length; i < len; i++) {
         if (!args[i].$$is_number) {
-          #{raise TypeError, "no implicit conversion of #{`args[i]`.class} into Integer"}
+          #{::Kernel.raise ::TypeError, "no implicit conversion of #{`args[i]`.class} into Integer"}
         }
         result.push(#{self[`args[i]`]});
       }
@@ -311,9 +320,13 @@ class Struct
     }
 
     unless item.respond_to?(:dig)
-      raise TypeError, "#{item.class} does not have #dig method"
+      ::Kernel.raise ::TypeError, "#{item.class} does not have #dig method"
     end
 
     item.dig(*keys)
   end
+
+  alias size length
+  alias to_s inspect
+  alias values to_a
 end

data/opal/corelib/time.rb

@@ -2,8 +2,8 @@
 
 require 'corelib/comparable'
 
-class Time < `Date`
-  include Comparable
+class ::Time < `Date`
+  include ::Comparable
 
   %x{
     var days_of_week = #{%w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday Sunday]},
@@ -16,9 +16,9 @@ class Time < `Date`
     %x{
       var result;
 
-      if (#{Time === seconds}) {
+      if (#{::Time === seconds}) {
         if (frac !== undefined) {
-          #{raise TypeError, "can't convert Time into an exact number"}
+          #{::Kernel.raise ::TypeError, "can't convert Time into an exact number"}
         }
         result = new Date(seconds.getTime());
         result.is_utc = seconds.is_utc;
@@ -26,7 +26,7 @@ class Time < `Date`
       }
 
       if (!seconds.$$is_number) {
-        seconds = #{Opal.coerce_to!(seconds, Integer, :to_int)};
+        seconds = #{::Opal.coerce_to!(seconds, ::Integer, :to_int)};
       }
 
       if (frac === undefined) {
@@ -34,7 +34,7 @@ class Time < `Date`
       }
 
       if (!frac.$$is_number) {
-        frac = #{Opal.coerce_to!(frac, Integer, :to_int)};
+        frac = #{::Opal.coerce_to!(frac, ::Integer, :to_int)};
       }
 
       return new Date(seconds * 1000 + (frac / 1000));
@@ -46,7 +46,7 @@ class Time < `Date`
       if (year.$$is_string) {
         year = parseInt(year, 10);
       } else {
-        year = #{Opal.coerce_to!(`year`, Integer, :to_int)};
+        year = #{::Opal.coerce_to!(`year`, ::Integer, :to_int)};
       }
 
       if (month === nil) {
@@ -70,12 +70,12 @@ class Time < `Date`
           default: month = #{`month`.to_i};
           }
         } else {
-          month = #{Opal.coerce_to!(`month`, Integer, :to_int)};
+          month = #{::Opal.coerce_to!(`month`, ::Integer, :to_int)};
         }
       }
 
       if (month < 1 || month > 12) {
-        #{raise ArgumentError, "month out of range: #{`month`}"}
+        #{::Kernel.raise ::ArgumentError, "month out of range: #{`month`}"}
       }
       month = month - 1;
 
@@ -84,11 +84,11 @@ class Time < `Date`
       } else if (day.$$is_string) {
         day = parseInt(day, 10);
       } else {
-        day = #{Opal.coerce_to!(`day`, Integer, :to_int)};
+        day = #{::Opal.coerce_to!(`day`, ::Integer, :to_int)};
       }
 
       if (day < 1 || day > 31) {
-        #{raise ArgumentError, "day out of range: #{`day`}"}
+        #{::Kernel.raise ::ArgumentError, "day out of range: #{`day`}"}
       }
 
       if (hour === nil) {
@@ -96,11 +96,11 @@ class Time < `Date`
       } else if (hour.$$is_string) {
         hour = parseInt(hour, 10);
       } else {
-        hour = #{Opal.coerce_to!(`hour`, Integer, :to_int)};
+        hour = #{::Opal.coerce_to!(`hour`, ::Integer, :to_int)};
       }
 
       if (hour < 0 || hour > 24) {
-        #{raise ArgumentError, "hour out of range: #{`hour`}"}
+        #{::Kernel.raise ::ArgumentError, "hour out of range: #{`hour`}"}
       }
 
       if (min === nil) {
@@ -108,11 +108,11 @@ class Time < `Date`
       } else if (min.$$is_string) {
         min = parseInt(min, 10);
       } else {
-        min = #{Opal.coerce_to!(`min`, Integer, :to_int)};
+        min = #{::Opal.coerce_to!(`min`, ::Integer, :to_int)};
       }
 
       if (min < 0 || min > 59) {
-        #{raise ArgumentError, "min out of range: #{`min`}"}
+        #{::Kernel.raise ::ArgumentError, "min out of range: #{`min`}"}
       }
 
       if (sec === nil) {
@@ -121,12 +121,12 @@ class Time < `Date`
         if (sec.$$is_string) {
           sec = parseInt(sec, 10);
         } else {
-          sec = #{Opal.coerce_to!(`sec`, Integer, :to_int)};
+          sec = #{::Opal.coerce_to!(`sec`, ::Integer, :to_int)};
         }
       }
 
       if (sec < 0 || sec > 60) {
-        #{raise ArgumentError, "sec out of range: #{`sec`}"}
+        #{::Kernel.raise ::ArgumentError, "sec out of range: #{`sec`}"}
       }
 
       return [year, month, day, hour, min, sec];
@@ -142,7 +142,7 @@ class Time < `Date`
       }
 
       if (utc_offset !== nil) {
-        #{raise ArgumentError, 'Opal does not support explicitly specifying UTC offset for Time'}
+        #{::Kernel.raise ::ArgumentError, 'Opal does not support explicitly specifying UTC offset for Time'}
       }
 
       args  = time_params(year, month, day, hour, min, sec);
@@ -224,23 +224,18 @@ class Time < `Date`
     }
   end
 
-  class << self
-    alias mktime local
-    alias utc gm
-  end
-
   def self.now
     new
   end
 
   def +(other)
-    if Time === other
-      raise TypeError, 'time + time?'
+    if ::Time === other
+      ::Kernel.raise ::TypeError, 'time + time?'
     end
 
     %x{
       if (!other.$$is_number) {
-        other = #{Opal.coerce_to!(other, Integer, :to_int)};
+        other = #{::Opal.coerce_to!(other, ::Integer, :to_int)};
       }
       var result = new Date(self.getTime() + (other * 1000));
       result.is_utc = self.is_utc;
@@ -249,13 +244,13 @@ class Time < `Date`
   end
 
   def -(other)
-    if Time === other
+    if ::Time === other
       return `(self.getTime() - other.getTime()) / 1000`
     end
 
     %x{
       if (!other.$$is_number) {
-        other = #{Opal.coerce_to!(other, Integer, :to_int)};
+        other = #{::Opal.coerce_to!(other, ::Integer, :to_int)};
       }
       var result = new Date(self.getTime() - (other * 1000));
       result.is_utc = self.is_utc;
@@ -264,7 +259,7 @@ class Time < `Date`
   end
 
   def <=>(other)
-    if Time === other
+    if ::Time === other
       to_f <=> other.to_f
     else
       r = other <=> self
@@ -281,15 +276,13 @@ class Time < `Date`
   end
 
   def ==(other)
-    Time === other && `#{to_f} === #{other.to_f}`
+    ::Time === other && `#{to_f} === #{other.to_f}`
   end
 
   def asctime
     strftime '%a %b %e %H:%M:%S %Y'
   end
 
-  alias ctime asctime
-
   def day
     `self.is_utc ? self.getUTCDate() : self.getDate()`
   end
@@ -313,8 +306,6 @@ class Time < `Date`
     }
   end
 
-  alias dst? isdst
-
   def dup
     copy = `new Date(self.getTime())`
 
@@ -325,7 +316,7 @@ class Time < `Date`
   end
 
   def eql?(other)
-    other.is_a?(Time) && (self <=> other).zero?
+    other.is_a?(::Time) && (self <=> other).zero?
   end
 
   def friday?
@@ -348,8 +339,6 @@ class Time < `Date`
     end
   end
 
-  alias mday day
-
   def min
     `self.is_utc ? self.getUTCMinutes() : self.getMinutes()`
   end
@@ -362,8 +351,6 @@ class Time < `Date`
     `#{wday} == 1`
   end
 
-  alias month mon
-
   def saturday?
     `#{wday} == 6`
   end
@@ -413,8 +400,6 @@ class Time < `Date`
     }
   end
 
-  alias getutc getgm
-
   def gmtime
     %x{
       self.is_utc = true;
@@ -422,8 +407,6 @@ class Time < `Date`
     }
   end
 
-  alias utc gmtime
-
   def gmt?
     `self.is_utc === true`
   end
@@ -692,21 +675,10 @@ class Time < `Date`
     `parseInt(self.getTime() / 1000, 10)`
   end
 
-  alias to_s inspect
-
   def tuesday?
     `#{wday} == 2`
   end
 
-  alias tv_sec to_i
-
-  alias tv_usec usec
-
-  alias utc? gmt?
-
-  alias gmtoff gmt_offset
-  alias utc_offset gmt_offset
-
   def wday
     `self.is_utc ? self.getUTCDay() : self.getDay()`
   end
@@ -720,7 +692,7 @@ class Time < `Date`
   end
 
   def cweek_cyear
-    jan01 = Time.new(year, 1, 1)
+    jan01 = ::Time.new(year, 1, 1)
     jan01_wday = jan01.wday
     first_monday = 0
     year = self.year
@@ -737,10 +709,10 @@ class Time < `Date`
 
     if week <= 0
       # Get the last week of the previous year
-      return Time.new(self.year - 1, 12, 31).cweek_cyear
+      return ::Time.new(self.year - 1, 12, 31).cweek_cyear
     elsif week == 53
       # Find out whether this is actually week 53 or already week 01 of the following year
-      dec31 = Time.new(self.year, 12, 31)
+      dec31 = ::Time.new(self.year, 12, 31)
       dec31_wday = dec31.wday
       if dec31_wday <= 3 && dec31_wday != 0
         week = 1
@@ -750,4 +722,22 @@ class Time < `Date`
 
     [week, year]
   end
+
+  class << self
+    alias mktime local
+    alias utc gm
+  end
+
+  alias ctime asctime
+  alias dst? isdst
+  alias getutc getgm
+  alias gmtoff gmt_offset
+  alias mday day
+  alias month mon
+  alias to_s inspect
+  alias tv_sec to_i
+  alias tv_usec usec
+  alias utc gmtime
+  alias utc? gmt?
+  alias utc_offset gmt_offset
 end

data/opal/corelib/trace_point.rb

@@ -1,4 +1,4 @@
-class TracePoint
+class ::TracePoint
   # partial implementation of TracePoint
   # for the moment only supports the :class event
   def self.trace(event, &block)
@@ -8,7 +8,7 @@ class TracePoint
   attr_reader :event
 
   def initialize(event, &block)
-    raise 'Only the :class event is supported' unless event == :class
+    ::Kernel.raise 'Only the :class event is supported' unless event == :class
     @event = event
     @block = block
     @trace_object = nil