opal 1.0.5 → 1.1.0.rc1

data/opal/corelib/string.rb

@@ -1,3 +1,5 @@
+# helpers: coerce_to, respond_to
+
 require 'corelib/comparable'
 require 'corelib/regexp'
 
@@ -28,7 +30,7 @@ class String < `String`
   end
 
   def self.new(str = '')
-    str = Opal.coerce_to(str, String, :to_str)
+    str = `$coerce_to(str, #{String}, 'to_str')`
     `new self.$$constructor(str)`
   end
 
@@ -51,7 +53,7 @@ class String < `String`
 
   def *(count)
     %x{
-      count = #{Opal.coerce_to(`count`, Integer, :to_int)};
+      count = $coerce_to(count, #{Integer}, 'to_int');
 
       if (count < 0) {
         #{raise ArgumentError, 'negative argument'}
@@ -88,7 +90,7 @@ class String < `String`
   end
 
   def +(other)
-    other = Opal.coerce_to other, String, :to_str
+    other = `$coerce_to(#{other}, #{String}, 'to_str')`
 
     `self + #{other.to_s}`
   end
@@ -117,7 +119,7 @@ class String < `String`
       if (other.$$is_string) {
         return self.toString() === other.toString();
       }
-      if (#{Opal.respond_to? `other`, :to_str}) {
+      if ($respond_to(other, '$to_str')) {
         return #{other == self};
       }
       return false;
@@ -143,8 +145,8 @@ class String < `String`
 
       if (index.$$is_range) {
         exclude = index.excl;
-        length  = #{Opal.coerce_to(`index.end`, Integer, :to_int)};
-        index   = #{Opal.coerce_to(`index.begin`, Integer, :to_int)};
+        length  = $coerce_to(index.end, #{Integer}, 'to_int');
+        index   = $coerce_to(index.begin, #{Integer}, 'to_int');
 
         if (Math.abs(index) > size) {
           return nil;
@@ -194,7 +196,7 @@ class String < `String`
           return self.$$cast(match[0]);
         }
 
-        length = #{Opal.coerce_to(`length`, Integer, :to_int)};
+        length = $coerce_to(length, #{Integer}, 'to_int');
 
         if (length < 0 && -length < match.length) {
           return self.$$cast(match[length += match.length]);
@@ -208,7 +210,7 @@ class String < `String`
       }
 
 
-      index = #{Opal.coerce_to(`index`, Integer, :to_int)};
+      index = $coerce_to(index, #{Integer}, 'to_int');
 
       if (index < 0) {
         index += size;
@@ -221,7 +223,7 @@ class String < `String`
         return self.$$cast(self.substr(index, 1));
       }
 
-      length = #{Opal.coerce_to(`length`, Integer, :to_int)};
+      length = $coerce_to(length, #{Integer}, 'to_int');
 
       if (length < 0) {
         return nil;
@@ -247,7 +249,7 @@ class String < `String`
 
   def casecmp(other)
     return nil unless other.respond_to?(:to_str)
-    other = Opal.coerce_to(other, String, :to_str).to_s
+    other = `$coerce_to(other, #{String}, 'to_str')`.to_s
     %x{
       var ascii_only = /^[\x00-\x7F]*$/;
       if (ascii_only.test(self) && ascii_only.test(other)) {
@@ -270,8 +272,8 @@ class String < `String`
   end
 
   def center(width, padstr = ' ')
-    width  = Opal.coerce_to(width, Integer, :to_int)
-    padstr = Opal.coerce_to(padstr, String, :to_str).to_s
+    width  = `$coerce_to(#{width}, #{Integer}, 'to_int')`
+    padstr = `$coerce_to(#{padstr}, #{String}, 'to_str')`.to_s
 
     if padstr.empty?
       raise ArgumentError, 'zero width padding'
@@ -344,14 +346,14 @@ class String < `String`
   end
 
   def clone
-    copy = `self.slice()`
+    copy = `new String(self)`
     copy.copy_singleton_methods(self)
     copy.initialize_clone(self)
     copy
   end
 
   def dup
-    copy = `self.slice()`
+    copy = `new String(self)`
     copy.initialize_dup(self)
     copy
   end
@@ -385,7 +387,7 @@ class String < `String`
   def delete_prefix(prefix)
     %x{
       if (!prefix.$$is_string) {
-        #{prefix = Opal.coerce_to(prefix, String, :to_str)}
+        prefix = $coerce_to(prefix, #{String}, 'to_str');
       }
 
       if (self.slice(0, prefix.length) === prefix) {
@@ -399,7 +401,7 @@ class String < `String`
   def delete_suffix(suffix)
     %x{
       if (!suffix.$$is_string) {
-        #{suffix = Opal.coerce_to(suffix, String, :to_str)}
+        suffix = $coerce_to(suffix, #{String}, 'to_str');
       }
 
       if (self.slice(self.length - suffix.length) === suffix) {
@@ -436,7 +438,7 @@ class String < `String`
         return self;
       }
 
-      separator = #{Opal.coerce_to(`separator`, String, :to_str)}
+      separator = $coerce_to(separator, #{String}, 'to_str')
 
       var a, i, n, length, chomped, trailing, splitted;
 
@@ -475,7 +477,7 @@ class String < `String`
   def end_with?(*suffixes)
     %x{
       for (var i = 0, length = suffixes.length; i < length; i++) {
-        var suffix = #{Opal.coerce_to(`suffixes[i]`, String, :to_str).to_s};
+        var suffix = $coerce_to(suffixes[i], #{String}, 'to_str').$to_s();
 
         if (self.length >= suffix.length &&
             self.substr(self.length - suffix.length, suffix.length) == suffix) {
@@ -500,7 +502,7 @@ class String < `String`
       if (pattern.$$is_regexp) {
         pattern = Opal.global_multiline_regexp(pattern);
       } else {
-        pattern = #{Opal.coerce_to(`pattern`, String, :to_str)};
+        pattern = $coerce_to(pattern, #{String}, 'to_str');
         pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gm');
       }
 
@@ -526,7 +528,7 @@ class String < `String`
         }
         else {
           if (!replacement.$$is_string) {
-            replacement = #{Opal.coerce_to(`replacement`, String, :to_str)};
+            replacement = $coerce_to(replacement, #{String}, 'to_str');
           }
           _replacement = replacement.replace(/([\\]+)([0-9+&`'])/g, function (original, slashes, command) {
             if (slashes.length % 2 === 0) {
@@ -549,7 +551,7 @@ class String < `String`
         }
 
         if (pattern.lastIndex === match.index) {
-          result += (_replacement + self.slice(index, match.index + 1))
+          result += (self.slice(index, match.index) + _replacement + (self[match.index] || ""));
           pattern.lastIndex += 1;
         }
         else {
@@ -574,7 +576,7 @@ class String < `String`
   def include?(other)
     %x{
       if (!other.$$is_string) {
-        #{other = Opal.coerce_to(other, String, :to_str)}
+        other = $coerce_to(other, #{String}, 'to_str');
       }
       return self.indexOf(other) !== -1;
     }
@@ -589,7 +591,7 @@ class String < `String`
       if (offset === undefined) {
         offset = 0;
       } else {
-        offset = #{Opal.coerce_to(`offset`, Integer, :to_int)};
+        offset = $coerce_to(offset, #{Integer}, 'to_int');
         if (offset < 0) {
           offset += self.length;
           if (offset < 0) {
@@ -615,7 +617,7 @@ class String < `String`
           regex.lastIndex = match.index + 1;
         }
       } else {
-        search = #{Opal.coerce_to(`search`, String, :to_str)};
+        search = $coerce_to(search, #{String}, 'to_str');
         if (search.length === 0 && offset > self.length) {
           index = -1;
         } else {
@@ -663,8 +665,8 @@ class String < `String`
   end
 
   def ljust(width, padstr = ' ')
-    width  = Opal.coerce_to(width, Integer, :to_int)
-    padstr = Opal.coerce_to(padstr, String, :to_str).to_s
+    width  = `$coerce_to(#{width}, #{Integer}, 'to_int')`
+    padstr = `$coerce_to(#{padstr}, #{String}, 'to_str')`.to_s
 
     if padstr.empty?
       raise ArgumentError, 'zero width padding'
@@ -860,7 +862,7 @@ class String < `String`
           i = m.index;
         }
       } else {
-        sep = #{Opal.coerce_to(`sep`, String, :to_str)};
+        sep = $coerce_to(sep, #{String}, 'to_str');
         i = self.indexOf(sep);
       }
 
@@ -887,7 +889,7 @@ class String < `String`
       if (offset === undefined) {
         offset = self.length;
       } else {
-        offset = #{Opal.coerce_to(`offset`, Integer, :to_int)};
+        offset = $coerce_to(offset, #{Integer}, 'to_int');
         if (offset < 0) {
           offset += self.length;
           if (offset < 0) {
@@ -915,7 +917,7 @@ class String < `String`
           i = m.index;
         }
       } else {
-        search = #{Opal.coerce_to(`search`, String, :to_str)};
+        search = $coerce_to(search, #{String}, 'to_str');
         i = self.lastIndexOf(search, offset);
       }
 
@@ -924,8 +926,8 @@ class String < `String`
   end
 
   def rjust(width, padstr = ' ')
-    width  = Opal.coerce_to(width, Integer, :to_int)
-    padstr = Opal.coerce_to(padstr, String, :to_str).to_s
+    width  = `$coerce_to(#{width}, #{Integer}, 'to_int')`
+    padstr = `$coerce_to(#{padstr}, #{String}, 'to_str')`.to_s
 
     if padstr.empty?
       raise ArgumentError, 'zero width padding'
@@ -969,7 +971,7 @@ class String < `String`
         }
 
       } else {
-        sep = #{Opal.coerce_to(`sep`, String, :to_str)};
+        sep = $coerce_to(sep, #{String}, 'to_str');
         i = self.lastIndexOf(sep);
       }
 
@@ -998,7 +1000,7 @@ class String < `String`
       if (pattern.$$is_regexp) {
         pattern = Opal.global_multiline_regexp(pattern);
       } else {
-        pattern = #{Opal.coerce_to(`pattern`, String, :to_str)};
+        pattern = $coerce_to(pattern, #{String}, 'to_str');
         pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gm');
       }
 
@@ -1052,7 +1054,7 @@ class String < `String`
       if (pattern.$$is_regexp) {
         pattern = Opal.global_multiline_regexp(pattern);
       } else {
-        pattern = #{Opal.coerce_to(pattern, String, :to_str).to_s};
+        pattern = $coerce_to(pattern, #{String}, 'to_str').$to_s();
         if (pattern === ' ') {
           pattern = /\s+/gm;
           string = string.replace(/^\s+/, '');
@@ -1139,7 +1141,7 @@ class String < `String`
   def start_with?(*prefixes)
     %x{
       for (var i = 0, length = prefixes.length; i < length; i++) {
-        var prefix = #{Opal.coerce_to(`prefixes[i]`, String, :to_str).to_s};
+        var prefix = $coerce_to(prefixes[i], #{String}, 'to_str').$to_s();
 
         if (self.indexOf(prefix) === 0) {
           return true;
@@ -1157,7 +1159,7 @@ class String < `String`
   def sub(pattern, replacement = undefined, &block)
     %x{
       if (!pattern.$$is_regexp) {
-        pattern = #{Opal.coerce_to(`pattern`, String, :to_str)};
+        pattern = $coerce_to(pattern, #{String}, 'to_str');
         pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
       }
 
@@ -1182,7 +1184,7 @@ class String < `String`
 
         } else {
 
-          replacement = #{Opal.coerce_to(`replacement`, String, :to_str)};
+          replacement = $coerce_to(replacement, #{String}, 'to_str');
 
           replacement = replacement.replace(/([\\]+)([0-9+&`'])/g, function (original, slashes, command) {
             if (slashes.length % 2 === 0) {
@@ -1215,7 +1217,7 @@ class String < `String`
 
   def sum(n = 16)
     %x{
-      n = #{Opal.coerce_to(`n`, Integer, :to_int)};
+      n = $coerce_to(n, #{Integer}, 'to_int');
 
       var result = 0,
           length = self.length,
@@ -1268,7 +1270,7 @@ class String < `String`
     %x{
       var result,
           string = self.toLowerCase(),
-          radix = #{Opal.coerce_to(`base`, Integer, :to_int)};
+          radix = $coerce_to(base, #{Integer}, 'to_int');
 
       if (radix === 1 || radix < 0 || radix > 36) {
         #{raise ArgumentError, "invalid radix #{`radix`}"}
@@ -1364,9 +1366,10 @@ class String < `String`
   alias to_sym intern
 
   def tr(from, to)
-    from = Opal.coerce_to(from, String, :to_str).to_s
-    to = Opal.coerce_to(to, String, :to_str).to_s
     %x{
+      from = $coerce_to(from, #{String}, 'to_str').$to_s();
+      to = $coerce_to(to, #{String}, 'to_str').$to_s();
+
       if (from.length == 0 || from === to) {
         return self;
       }
@@ -1508,9 +1511,10 @@ class String < `String`
   end
 
   def tr_s(from, to)
-    from = Opal.coerce_to(from, String, :to_str).to_s
-    to = Opal.coerce_to(to, String, :to_str).to_s
     %x{
+      from = $coerce_to(from, #{String}, 'to_str').$to_s();
+      to = $coerce_to(to, #{String}, 'to_str').$to_s();
+
       if (from.length == 0) {
         return self;
       }
@@ -1675,10 +1679,11 @@ class String < `String`
 
   def upto(stop, excl = false, &block)
     return enum_for :upto, stop, excl unless block_given?
-    stop = Opal.coerce_to(stop, String, :to_str)
     %x{
       var a, b, s = self.toString();
 
+      stop = $coerce_to(stop, #{String}, 'to_str');
+
       if (s.length === 1 && stop.length === 1) {
 
         a = s.charCodeAt(0);
@@ -1778,7 +1783,7 @@ class String < `String`
           neg_intersection = '';
 
       for (i = 0, len = sets.length; i < len; i++) {
-        set = #{Opal.coerce_to(`sets[i]`, String, :to_str)};
+        set = $coerce_to(sets[i], #{String}, 'to_str');
         neg = (set.charAt(0) === '^' && set.length > 1);
         set = explode_sequences_in_character_set(neg ? set.slice(1) : set);
         if (neg) {
@@ -1820,12 +1825,13 @@ class String < `String`
     new(*args)
   end
 
-  def unicode_normalize(form = undefined)
-    `self.toString()`
+  def unicode_normalize(form = :nfc)
+    raise ArgumentError, "Invalid normalization form #{form}" unless %i[nfc nfd nfkc nfkd].include?(form)
+    `self.normalize(#{form.upcase})`
   end
 
-  def unicode_normalized?(form = undefined)
-    true
+  def unicode_normalized?(form = :nfc)
+    unicode_normalize(form) == self
   end
 
   def unpack(format)

data/opal/corelib/string/encoding.rb

@@ -1,31 +1,30 @@
 require 'corelib/string'
 
 class Encoding
-  `Opal.defineProperty(self, '$$register', {})`
-
   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 = [name] + (options[:aliases] || [])
+    ascii = options[:ascii] || false
+    dummy = options[:dummy] || false
+
+    encoding = new(name, names, ascii, dummy)
+    encoding.instance_eval(&block)
 
-    register = self.JS['$$register']
+    register = `Opal.encodings`
     names.each do |encoding_name|
       const_set encoding_name.sub('-', '_'), encoding
-      register.JS["$$#{encoding_name}"] = encoding
+      register.JS[encoding_name] = encoding
     end
   end
 
   def self.find(name)
     return default_external if name == :default_external
-    register = self.JS['$$register']
-    encoding = register.JS["$$#{name}"] || register.JS["$$#{name.upcase}"]
+    register = `Opal.encodings`
+    encoding = register.JS[name] || register.JS[name.upcase]
     raise ArgumentError, "unknown encoding name - #{name}" unless encoding
     encoding
   end
 
-  class << self
-    attr_accessor :default_external
-  end
+  singleton_class.attr_accessor :default_external
 
   attr_reader :name, :names
 
@@ -57,10 +56,6 @@ class Encoding
     raise NotImplementedError
   end
 
-  def getbyte(*)
-    raise NotImplementedError
-  end
-
   def bytesize(*)
     raise NotImplementedError
   end
@@ -72,19 +67,90 @@ 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);
+      // Taken from: https://github.com/feross/buffer/blob/f52dffd9df0445b93c0c9065c2f8f0f46b2c729a/index.js#L1954-L2032
+      var units = Infinity
+      var codePoint
+      var length = string.length
+      var leadSurrogate = null
+
+      for (var i = 0; i < length; ++i) {
+        codePoint = string.charCodeAt(i)
+
+        // is surrogate component
+        if (codePoint > 0xD7FF && codePoint < 0xE000) {
+          // last char was a lead
+          if (!leadSurrogate) {
+            // no lead yet
+            if (codePoint > 0xDBFF) {
+              // unexpected trail
+              if ((units -= 3) > -1) {
+                #{yield `0xEF`};
+                #{yield `0xBF`};
+                #{yield `0xBD`};
+              }
+              continue
+            } else if (i + 1 === length) {
+              // unpaired lead
+              if ((units -= 3) > -1) {
+                #{yield `0xEF`};
+                #{yield `0xBF`};
+                #{yield `0xBD`};
+              }
+              continue
+            }
+
+            // valid lead
+            leadSurrogate = codePoint
+
+            continue
+          }
 
-        if (code <= 0x7f) {
-          #{yield `code`};
-        }
-        else {
-          var encoded = encodeURIComponent(string.charAt(i)).substr(1).split('%');
+          // 2 leads in a row
+          if (codePoint < 0xDC00) {
+            if ((units -= 3) > -1) {
+              #{yield `0xEF`};
+              #{yield `0xBF`};
+              #{yield `0xBD`};
+            }
+            leadSurrogate = codePoint
+            continue
+          }
 
-          for (var j = 0, encoded_length = encoded.length; j < encoded_length; j++) {
-            #{yield `parseInt(encoded[j], 16)`};
+          // valid surrogate pair
+          codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+        } else if (leadSurrogate) {
+          // valid bmp char, but last char was a lead
+          if ((units -= 3) > -1) {
+            #{yield `0xEF`};
+            #{yield `0xBF`};
+            #{yield `0xBD`};
           }
         }
+
+        leadSurrogate = null
+
+        // encode utf8
+        if (codePoint < 0x80) {
+          if ((units -= 1) < 0) break
+          #{yield `codePoint`};
+        } else if (codePoint < 0x800) {
+          if ((units -= 2) < 0) break
+          #{yield `codePoint >> 0x6 | 0xC0`};
+          #{yield `codePoint & 0x3F | 0x80`};
+        } else if (codePoint < 0x10000) {
+          if ((units -= 3) < 0) break
+          #{yield `codePoint >> 0xC | 0xE0`};
+          #{yield `codePoint >> 0x6 & 0x3F | 0x80`};
+          #{yield `codePoint & 0x3F | 0x80`};
+        } else if (codePoint < 0x110000) {
+          if ((units -= 4) < 0) break
+          #{yield `codePoint >> 0x12 | 0xF0`};
+          #{yield `codePoint >> 0xC & 0x3F | 0x80`};
+          #{yield `codePoint >> 0x6 & 0x3F | 0x80`};
+          #{yield `codePoint & 0x3F | 0x80`};
+        } else {
+          // Invalid code point
+        }
       }
     }
   end
@@ -163,20 +229,24 @@ end
 
 class String
   attr_reader :encoding
-  `Opal.defineProperty(String.prototype, 'encoding', #{Encoding::UTF_16LE})`
+  attr_reader :internal_encoding
+  `Opal.defineProperty(String.prototype, 'bytes', nil)`
+  `Opal.defineProperty(String.prototype, 'encoding', #{Encoding::UTF_8})`
+  `Opal.defineProperty(String.prototype, 'internal_encoding', #{Encoding::UTF_8})`
 
   def bytes
-    each_byte.to_a
+    @bytes ||= each_byte.to_a
+    @bytes.dup
   end
 
   def bytesize
-    @encoding.bytesize(self)
+    @internal_encoding.bytesize(self)
   end
 
   def each_byte(&block)
     return enum_for :each_byte unless block_given?
 
-    @encoding.each_byte(self, &block)
+    @internal_encoding.each_byte(self, &block)
 
     self
   end
@@ -198,7 +268,7 @@ class String
   end
 
   def encode(encoding)
-    dup.force_encoding(encoding)
+    `Opal.enc(self, encoding)`
   end
 
   def force_encoding(encoding)
@@ -210,13 +280,18 @@ class String
 
       if (encoding === self.encoding) { return self; }
 
-      self.encoding = encoding;
+      Opal.set_encoding(self, encoding);
+
       return self;
     }
   end
 
   def getbyte(idx)
-    @encoding.getbyte(self, idx)
+    string_bytes = bytes
+    idx = Opal.coerce_to!(idx, Integer, :to_int)
+    return if string_bytes.length < idx
+
+    string_bytes[idx]
   end
 
   # stub
@@ -224,3 +299,5 @@ class String
     true
   end
 end
+
+Encoding.default_external = __ENCODING__