opal 0.8.1 → 0.9.0.beta1

data/opal/corelib/string/encoding.rb

@@ -0,0 +1,177 @@
+require 'corelib/string'
+
+class Encoding
+  def self.register(name, options = {}, &block)
+    names    = [name] + (options[:aliases] || [])
+    encoding = Class.new(self, &block).
+      new(name, names, options[:ascii] || false, options[:dummy] || false)
+
+    names.each {|name|
+      const_set name.sub('-', '_'), encoding
+    }
+  end
+
+  def self.find(name)
+    upcase = name.upcase
+
+    constants.each {|const|
+      encoding = const_get(const)
+
+      next unless Encoding === encoding
+
+      if encoding.name == upcase || encoding.names.include?(upcase)
+        return encoding
+      end
+    }
+
+    raise ArgumentError, "unknown encoding name - #{name}"
+  end
+
+  class << self
+    attr_accessor :default_external
+  end
+
+  attr_reader :name, :names
+
+  def initialize(name, names, ascii, dummy)
+    @name  = name
+    @names = names
+    @ascii = ascii
+    @dummy = dummy
+  end
+
+  def ascii_compatible?
+    @ascii
+  end
+
+  def dummy?
+    @dummy
+  end
+
+  def to_s
+    @name
+  end
+
+  def inspect
+    "#<Encoding:#{@name}#{" (dummy)" if @dummy}>"
+  end
+
+  # methods to implement per encoding
+  def each_byte(*)
+    raise NotImplementedError
+  end
+
+  def getbyte(*)
+    raise NotImplementedError
+  end
+
+  def bytesize(*)
+    raise NotImplementedError
+  end
+
+  class EncodingError < StandardError; end
+  class CompatibilityError < EncodingError; end
+end
+
+Encoding.register "UTF-8", aliases: ["CP65001"], ascii: true do
+  def each_byte(string, &block)
+    %x{
+      for (var i = 0, length = string.length; i < length; i++) {
+        var code = string.charCodeAt(i);
+
+        if (code <= 0x7f) {
+          #{yield `code`};
+        }
+        else {
+          var encoded = encodeURIComponent(string.charAt(i)).substr(1).split('%');
+
+          for (var j = 0, encoded_length = encoded.length; j < encoded_length; j++) {
+            #{yield `parseInt(encoded[j], 16)`};
+          }
+        }
+      }
+    }
+  end
+
+  def bytesize
+    bytes.length
+  end
+end
+
+Encoding.register "UTF-16LE" do
+  def each_byte(string, &block)
+    %x{
+      for (var i = 0, length = string.length; i < length; i++) {
+        var code = string.charCodeAt(i);
+
+        #{yield `code & 0xff`};
+        #{yield `code >> 8`};
+      }
+    }
+  end
+
+  def bytesize
+    bytes.length
+  end
+end
+
+Encoding.register "ASCII-8BIT", aliases: ["BINARY"], ascii: true do
+  def each_byte(string, &block)
+    %x{
+      for (var i = 0, length = string.length; i < length; i++) {
+        #{yield `string.charCodeAt(i) & 0xff`};
+      }
+    }
+  end
+
+  def bytesize
+    bytes.length
+  end
+end
+
+class String
+  `String.prototype.encoding = #{Encoding::UTF_16LE}`
+
+  def bytes
+    each_byte.to_a
+  end
+
+  def bytesize
+    @encoding.bytesize(self)
+  end
+
+  def each_byte(&block)
+    return enum_for :each_byte unless block_given?
+
+    @encoding.each_byte(self, &block)
+
+    self
+  end
+
+  def encode(encoding)
+    dup.force_encoding(encoding)
+  end
+
+  def encoding
+    @encoding
+  end
+
+  def force_encoding(encoding)
+    encoding = Opal.coerce_to!(encoding, String, :to_str)
+    encoding = Encoding.find(encoding)
+
+    return self if encoding == @encoding
+    raise ArgumentError, "unknown encoding name - #{encoding}" if encoding.nil?
+
+    %x{
+      var result = new String(self);
+      result.encoding = encoding;
+
+      return result;
+    }
+  end
+
+  def getbyte(idx)
+    @encoding.getbyte(self, idx)
+  end
+end

data/opal/corelib/string/inheritance.rb

@@ -1,3 +1,5 @@
+require 'corelib/string'
+
 class String
   def self.inherited(klass)
     replace = Class.new(String::Wrapper)

data/opal/corelib/struct.rb

@@ -14,7 +14,18 @@ class Struct
       Class.new(self) {
         args.each { |arg| define_struct_attribute arg }
 
-        instance_eval(&block) if block
+        class_eval(&block) if block
+
+        class << self
+          def new(*args)
+            instance = allocate
+            `#{instance}.$$data = {};`
+            instance.initialize(*args)
+            instance
+          end
+
+          alias [] new
+        end
       }
     end
   end
@@ -26,7 +37,15 @@ class Struct
 
     members << name
 
-    attr_accessor name
+    if Opal.valid_method_name?(name)
+      define_method name do
+        self[name]
+      end
+
+      define_method "#{name}=" do |value|
+        self[name] = value
+      end
+    end
   end
 
   def self.members
@@ -45,19 +64,19 @@ class Struct
     }
   end
 
-  class << self
-    alias [] new
-  end
-
   def initialize(*args)
     members.each_with_index {|name, index|
-      instance_variable_set "@#{name}", args[index]
+      self[name] = args[index]
     }
   end
 
   def members
     self.class.members
   end
+  
+  def hash
+    Hash.new(`self.$$data`).hash
+  end
 
   def [](name)
     if Integer === name
@@ -71,7 +90,8 @@ class Struct
       raise TypeError, "no implicit conversion of #{name.class} into Integer"
     end
 
-    instance_variable_get "@#{name}"
+    name = Opal.coerce_to!(name, String, :to_str)
+    `self.$$data[name]`
   end
 
   def []=(name, value)
@@ -86,29 +106,96 @@ class Struct
       raise TypeError, "no implicit conversion of #{name.class} into Integer"
     end
 
-    instance_variable_set "@#{name}", value
+    name = Opal.coerce_to!(name, String, :to_str)
+    `self.$$data[name] = value`
+  end
+
+  def ==(other)
+    return false unless other.instance_of?(self.class)
+
+    %x{
+      var recursed1 = {}, recursed2 = {};
+
+      function _eqeq(struct, other) {
+        var key, a, b;
+
+        recursed1[#{`struct`.__id__}] = true;
+        recursed2[#{`other`.__id__}] = true;
+
+        for (key in struct.$$data) {
+          a = struct.$$data[key];
+          b = other.$$data[key];
+
+          if (#{Struct === `a`}) {
+            if (!recursed1.hasOwnProperty(#{`a`.__id__}) || !recursed2.hasOwnProperty(#{`b`.__id__})) {
+              if (!_eqeq(a, b)) {
+                return false;
+              }
+            }
+          } else {
+            if (!#{`a` == `b`}) {
+              return false;
+            }
+          }
+        }
+
+        return true;
+      }
+
+      return _eqeq(self, other);
+    }
+  end
+
+  def eql?(other)
+    return false unless other.instance_of?(self.class)
+
+    %x{
+      var recursed1 = {}, recursed2 = {};
+
+      function _eqeq(struct, other) {
+        var key, a, b;
+
+        recursed1[#{`struct`.__id__}] = true;
+        recursed2[#{`other`.__id__}] = true;
+
+        for (key in struct.$$data) {
+          a = struct.$$data[key];
+          b = other.$$data[key];
+
+          if (#{Struct === `a`}) {
+            if (!recursed1.hasOwnProperty(#{`a`.__id__}) || !recursed2.hasOwnProperty(#{`b`.__id__})) {
+              if (!_eqeq(a, b)) {
+                return false;
+              }
+            }
+          } else {
+            if (!#{`a`.eql?(`b`)}) {
+              return false;
+            }
+          }
+        }
+
+        return true;
+      }
+
+      return _eqeq(self, other);
+    }
   end
 
   def each
-    return enum_for :each unless block_given?
+    return enum_for(:each){self.size} unless block_given?
 
     members.each { |name| yield self[name] }
     self
   end
 
   def each_pair
-    return enum_for :each_pair unless block_given?
+    return enum_for(:each_pair){self.size} unless block_given?
 
-    members.each { |name| yield name, self[name] }
+    members.each { |name| yield [name, self[name]] }
     self
   end
 
-  def eql?(other)
-    hash == other.hash || other.each_with_index.all? {|object, index|
-      self[members[index]] == object
-    }
-  end
-
   def length
     members.length
   end

data/opal/corelib/time.rb

@@ -1,6 +1,6 @@
 require 'corelib/comparable'
 
-class Time
+class Time < `Date`
   include Comparable
 
   %x{
@@ -10,100 +10,213 @@ class Time
         long_months  = #{%w[January February March April May June July August September October November December]};
   }
 
-  def self.at(seconds, frac = 0)
-    `new Date(seconds * 1000 + frac)`
-  end
-
-  def self.new(year = undefined, month = undefined, day = undefined, hour = undefined, minute = undefined, second = undefined, utc_offset = undefined)
+  def self.at(seconds, frac = undefined)
     %x{
-      switch (arguments.length) {
-        case 1:
-          return new Date(year, 0);
-
-        case 2:
-          return new Date(year, month - 1);
-
-        case 3:
-          return new Date(year, month - 1, day);
+      var result;
 
-        case 4:
-          return new Date(year, month - 1, day, hour);
-
-        case 5:
-          return new Date(year, month - 1, day, hour, minute);
+      if (#{Time === seconds}) {
+        if (frac !== undefined) {
+          #{raise TypeError, "can't convert Time into an exact number"}
+        }
+        result = new Date(seconds.getTime());
+        result.is_utc = seconds.is_utc;
+        return result;
+      }
 
-        case 6:
-          return new Date(year, month - 1, day, hour, minute, second);
+      if (!seconds.$$is_number) {
+        seconds = #{Opal.coerce_to!(seconds, Integer, :to_int)};
+      }
 
-        case 7:
-          return new Date(year, month - 1, day, hour, minute, second);
+      if (frac === undefined) {
+        return new Date(seconds * 1000);
+      }
 
-        default:
-          return new Date();
+      if (!frac.$$is_number) {
+        frac = #{Opal.coerce_to!(frac, Integer, :to_int)};
       }
+
+      return new Date(seconds * 1000 + (frac / 1000));
     }
   end
 
-  def self.local(year, month = nil, day = nil, hour = nil, minute = nil, second = nil, millisecond = nil)
-    if `arguments.length === 10`
-      %x{
-        var args = $slice.call(arguments).reverse();
+  %x{
+    function time_params(year, month, day, hour, min, sec) {
+      if (year.$$is_string) {
+        year = parseInt(year, 10);
+      } else {
+        year = #{Opal.coerce_to!(`year`, Integer, :to_int)};
+      }
 
-        second = args[9];
-        minute = args[8];
-        hour   = args[7];
-        day    = args[6];
-        month  = args[5];
-        year   = args[4];
+      if (month === nil) {
+        month = 1;
+      } else if (!month.$$is_number) {
+        if (#{`month`.respond_to?(:to_str)}) {
+          month = #{`month`.to_str};
+          switch (month.toLowerCase()) {
+          case 'jan': month =  1; break;
+          case 'feb': month =  2; break;
+          case 'mar': month =  3; break;
+          case 'apr': month =  4; break;
+          case 'may': month =  5; break;
+          case 'jun': month =  6; break;
+          case 'jul': month =  7; break;
+          case 'aug': month =  8; break;
+          case 'sep': month =  9; break;
+          case 'oct': month = 10; break;
+          case 'nov': month = 11; break;
+          case 'dec': month = 12; break;
+          default: month = #{`month`.to_i};
+          }
+        } else {
+          month = #{Opal.coerce_to!(`month`, Integer, :to_int)};
+        }
       }
-    end
 
-    year = year.kind_of?(String) ? year.to_i : Opal.coerce_to(year, Integer, :to_int)
+      if (month < 1 || month > 12) {
+        #{raise ArgumentError, "month out of range: #{`month`}"}
+      }
+      month = month - 1;
+
+      if (day === nil) {
+        day = 1;
+      } else if (day.$$is_string) {
+        day = parseInt(day, 10);
+      } else {
+        day = #{Opal.coerce_to!(`day`, Integer, :to_int)};
+      }
 
-    month = month.kind_of?(String) ? month.to_i : Opal.coerce_to(month || 1, Integer, :to_int)
+      if (day < 1 || day > 31) {
+        #{raise ArgumentError, "day out of range: #{`day`}"}
+      }
 
-    unless month.between?(1, 12)
-      raise ArgumentError, "month out of range: #{month}"
-    end
+      if (hour === nil) {
+        hour = 0;
+      } else if (hour.$$is_string) {
+        hour = parseInt(hour, 10);
+      } else {
+        hour = #{Opal.coerce_to!(`hour`, Integer, :to_int)};
+      }
+
+      if (hour < 0 || hour > 24) {
+        #{raise ArgumentError, "hour out of range: #{`hour`}"}
+      }
 
-    day = day.kind_of?(String) ? day.to_i : Opal.coerce_to(day || 1, Integer, :to_int)
+      if (min === nil) {
+        min = 0;
+      } else if (min.$$is_string) {
+        min = parseInt(min, 10);
+      } else {
+        min = #{Opal.coerce_to!(`min`, Integer, :to_int)};
+      }
 
-    unless day.between?(1, 31)
-      raise ArgumentError, "day out of range: #{day}"
-    end
+      if (min < 0 || min > 59) {
+        #{raise ArgumentError, "min out of range: #{`min`}"}
+      }
 
-    hour = hour.kind_of?(String) ? hour.to_i : Opal.coerce_to(hour || 0, Integer, :to_int)
+      if (sec === nil) {
+        sec = 0;
+      } else if (!sec.$$is_number) {
+        if (sec.$$is_string) {
+          sec = parseInt(sec, 10);
+        } else {
+          sec = #{Opal.coerce_to!(`sec`, Integer, :to_int)};
+        }
+      }
 
-    unless hour.between?(0, 24)
-      raise ArgumentError, "hour out of range: #{hour}"
-    end
+      if (sec < 0 || sec > 60) {
+        #{raise ArgumentError, "sec out of range: #{`sec`}"}
+      }
 
-    minute = minute.kind_of?(String) ? minute.to_i : Opal.coerce_to(minute || 0, Integer, :to_int)
+      return [year, month, day, hour, min, sec];
+    }
+  }
 
-    unless minute.between?(0, 59)
-      raise ArgumentError, "minute out of range: #{minute}"
-    end
+  def self.new(year = undefined, month = nil, day = nil, hour = nil, min = nil, sec = nil, utc_offset = nil)
+    %x{
+      var args, result;
 
-    second = second.kind_of?(String)  ? second.to_i : Opal.coerce_to(second || 0, Integer, :to_int)
+      if (year === undefined) {
+        return new Date();
+      }
 
-    unless second.between?(0, 59)
-      raise ArgumentError, "second out of range: #{second}"
-    end
+      if (utc_offset !== nil) {
+        #{raise ArgumentError, 'Opal does not support explicitly specifying UTC offset for Time'}
+      }
 
-    new(*[year, month, day, hour, minute, second].compact)
+      args  = time_params(year, month, day, hour, min, sec);
+      year  = args[0];
+      month = args[1];
+      day   = args[2];
+      hour  = args[3];
+      min   = args[4];
+      sec   = args[5];
+
+      result = new Date(year, month, day, hour, min, 0, sec * 1000);
+      if (year < 100) {
+        result.setFullYear(year);
+      }
+      return result;
+    }
   end
 
-  def self.gm(year, month = undefined, day = undefined, hour = undefined, minute = undefined, second = undefined, utc_offset = undefined)
-    raise TypeError, 'missing year (got nil)' if year.nil?
+  def self.local(year, month = nil, day = nil, hour = nil, min = nil, sec = nil, millisecond = nil)
+    %x{
+      var args, result;
+
+      if (arguments.length === 10) {
+        args  = $slice.call(arguments);
+        year  = args[5];
+        month = args[4];
+        day   = args[3];
+        hour  = args[2];
+        min   = args[1];
+        sec   = args[0];
+      }
 
+      args  = time_params(year, month, day, hour, min, sec);
+      year  = args[0];
+      month = args[1];
+      day   = args[2];
+      hour  = args[3];
+      min   = args[4];
+      sec   = args[5];
+
+      result = new Date(year, month, day, hour, min, 0, sec * 1000);
+      if (year < 100) {
+        result.setFullYear(year);
+      }
+      return result;
+    }
+  end
+
+  def self.gm(year, month = nil, day = nil, hour = nil, min = nil, sec = nil, millisecond = nil)
     %x{
-      if (month > 12 || day > 31 || hour > 24 || minute > 59 || second > 59) {
-        #{raise ArgumentError};
+      var args, result;
+
+      if (arguments.length === 10) {
+        args  = $slice.call(arguments);
+        year  = args[5];
+        month = args[4];
+        day   = args[3];
+        hour  = args[2];
+        min   = args[1];
+        sec   = args[0];
       }
 
-      var date = new Date(Date.UTC(year, (month || 1) - 1, (day || 1), (hour || 0), (minute || 0), (second || 0)));
-      date.tz_offset = 0
-      return date;
+      args  = time_params(year, month, day, hour, min, sec);
+      year  = args[0];
+      month = args[1];
+      day   = args[2];
+      hour  = args[3];
+      min   = args[4];
+      sec   = args[5];
+
+      result = new Date(Date.UTC(year, month, day, hour, min, 0, sec * 1000));
+      if (year < 100) {
+        result.setUTCFullYear(year);
+      }
+      result.is_utc = true;
+      return result;
     }
   end
 
@@ -113,7 +226,7 @@ class Time
   end
 
   def self.now
-    `new Date()`
+    new
   end
 
   def +(other)
@@ -121,12 +234,12 @@ class Time
       raise TypeError, "time + time?"
     end
 
-    other = Opal.coerce_to other, Integer, :to_int
-
     %x{
-      var result           = new Date(self.getTime() + (other * 1000));
-          result.tz_offset = #@tz_offset;
-
+      if (!other.$$is_number) {
+        other = #{Opal.coerce_to!(other, Integer, :to_int)};
+      }
+      var result = new Date(self.getTime() + (other * 1000));
+      result.is_utc = self.is_utc;
       return result;
     }
   end
@@ -136,18 +249,31 @@ class Time
       return `(self.getTime() - other.getTime()) / 1000`
     end
 
-    other = Opal.coerce_to other, Integer, :to_int
-
     %x{
-      var result           = new Date(self.getTime() - (other * 1000));
-          result.tz_offset = #@tz_offset;
-
+      if (!other.$$is_number) {
+        other = #{Opal.coerce_to!(other, Integer, :to_int)};
+      }
+      var result = new Date(self.getTime() - (other * 1000));
+      result.is_utc = self.is_utc;
       return result;
     }
   end
 
   def <=>(other)
-    to_f <=> other.to_f
+    if Time === other
+      to_f <=> other.to_f
+    else
+      r = other <=> self
+      if r.nil?
+        nil
+      elsif r > 0
+        -1
+      elsif r < 0
+        1
+      else
+        0
+      end
+    end
   end
 
   def ==(other)
@@ -161,26 +287,37 @@ class Time
   alias ctime asctime
 
   def day
-    %x{
-      if (#@tz_offset === 0) {
-        return self.getUTCDate();
-      }
-      else {
-        return self.getDate();
-      }
-    }
+    `self.is_utc ? self.getUTCDate() : self.getDate()`
   end
 
   def yday
+    # http://javascript.about.com/library/bldayyear.htm
+    # also see moment.js implementation: http://git.io/vCKNE
+
+    start_of_year = Time.new(year).to_i
+    start_of_day  = Time.new(year, month, day).to_i
+    one_day       = 86400
+
+    ((start_of_day - start_of_year) / one_day).round + 1
+  end
+
+  def isdst
     %x{
-      // http://javascript.about.com/library/bldayyear.htm
-      var onejan = new Date(self.getFullYear(), 0, 1);
-      return Math.ceil((self - onejan) / 86400000);
+      var jan = new Date(self.getFullYear(), 0, 1),
+          jul = new Date(self.getFullYear(), 6, 1);
+      return self.getTimezoneOffset() < Math.max(jan.getTimezoneOffset(), jul.getTimezoneOffset());
     }
   end
 
-  def isdst
-    raise NotImplementedError
+  alias dst? isdst
+
+  def dup
+    copy = `new Date(self.getTime())`
+
+    copy.copy_instance_variables(self)
+    copy.initialize_dup(self)
+
+    copy
   end
 
   def eql?(other)
@@ -191,15 +328,12 @@ class Time
     `#{wday} == 5`
   end
 
+  def hash
+    `'Time:' + self.getTime()`
+  end
+
   def hour
-    %x{
-      if (#@tz_offset === 0) {
-        return self.getUTCHours();
-      }
-      else {
-        return self.getHours();
-      }
-    }
+    `self.is_utc ? self.getUTCHours() : self.getHours()`
   end
 
   def inspect
@@ -213,25 +347,11 @@ class Time
   alias mday day
 
   def min
-    %x{
-      if (#@tz_offset === 0) {
-        return self.getUTCMinutes();
-      }
-      else {
-        return self.getMinutes();
-      }
-    }
+    `self.is_utc ? self.getUTCMinutes() : self.getMinutes()`
   end
 
   def mon
-    %x{
-      if (#@tz_offset === 0) {
-        return self.getUTCMonth() + 1;
-      }
-      else {
-        return self.getMonth() + 1;
-      }
-    }
+    `(self.is_utc ? self.getUTCMonth() : self.getMonth()) + 1`
   end
 
   def monday?
@@ -245,19 +365,19 @@ class Time
   end
 
   def sec
+    `self.is_utc ? self.getUTCSeconds() : self.getSeconds()`
+  end
+
+  def succ
     %x{
-      if (#@tz_offset === 0) {
-        return self.getUTCSeconds();
-      }
-      else {
-        return self.getSeconds();
-      }
+      var result = new Date(self.getTime() + 1000);
+      result.is_utc = self.is_utc;
+      return result;
     }
   end
 
   def usec
-    warn 'Microseconds are not supported'
-    0
+    `self.getMilliseconds() * 1000`
   end
 
   def zone
@@ -283,15 +403,25 @@ class Time
 
   def getgm
     %x{
-      var result           = new Date(self.getTime());
-          result.tz_offset = 0;
-
+      var result = new Date(self.getTime());
+      result.is_utc = true;
       return result;
     }
   end
 
+  alias getutc getgm
+
+  def gmtime
+    %x{
+      self.is_utc = true;
+      return self;
+    }
+  end
+
+  alias utc gmtime
+
   def gmt?
-    `#@tz_offset === 0`
+    `self.is_utc === true`
   end
 
   def gmt_offset
@@ -302,7 +432,6 @@ class Time
     %x{
       return format.replace(/%([\-_#^0]*:{0,2})(\d+)?([EO]*)(.)/g, function(full, flags, width, _, conv) {
         var result = "",
-            width  = parseInt(width),
             zero   = flags.indexOf('0') !== -1,
             pad    = flags.indexOf('-') === -1,
             blank  = flags.indexOf('_') !== -1,
@@ -310,6 +439,8 @@ class Time
             invert = flags.indexOf('#') !== -1,
             colons = (flags.match(':') || []).length;
 
+        width = parseInt(width, 10);
+
         if (zero && blank) {
           if (flags.indexOf('0') < flags.indexOf('_')) {
             zero = false;
@@ -552,7 +683,7 @@ class Time
   end
 
   def to_i
-    `parseInt(self.getTime() / 1000)`
+    `parseInt(self.getTime() / 1000, 10)`
   end
 
   alias to_s inspect
@@ -561,19 +692,17 @@ class Time
     `#{wday} == 2`
   end
 
+  alias tv_sec sec
+
+  alias tv_usec usec
+
   alias utc? gmt?
 
+  alias gmtoff gmt_offset
   alias utc_offset gmt_offset
 
   def wday
-    %x{
-      if (#@tz_offset === 0) {
-        return self.getUTCDay();
-      }
-      else {
-        return self.getDay();
-      }
-    }
+    `self.is_utc ? self.getUTCDay() : self.getDay()`
   end
 
   def wednesday?
@@ -581,17 +710,9 @@ class Time
   end
 
   def year
-    %x{
-      if (#@tz_offset === 0) {
-        return self.getUTCFullYear();
-      }
-      else {
-        return self.getFullYear();
-      }
-    }
+    `self.is_utc ? self.getUTCFullYear() : self.getFullYear()`
   end
 
-  private :cweek_cyear
   def cweek_cyear
     jan01 = Time.new(self.year, 1, 1)
     jan01_wday = jan01.wday