opal 1.1.0.rc1 → 1.2.0.beta1

data/opal/corelib/string/encoding.rb

@@ -6,22 +6,24 @@ class Encoding
     ascii = options[:ascii] || false
     dummy = options[:dummy] || false
 
-    encoding = new(name, names, ascii, dummy)
-    encoding.instance_eval(&block)
+    if options[:inherits]
+      encoding = options[:inherits].clone
+      encoding.initialize(name, names, ascii, dummy)
+    else
+      encoding = new(name, names, ascii, dummy)
+    end
+    encoding.instance_eval(&block) if block_given?
 
     register = `Opal.encodings`
     names.each do |encoding_name|
-      const_set encoding_name.sub('-', '_'), encoding
+      const_set encoding_name.tr('-', '_'), encoding
       register.JS[encoding_name] = encoding
     end
   end
 
   def self.find(name)
     return default_external if name == :default_external
-    register = `Opal.encodings`
-    encoding = register.JS[name] || register.JS[name.upcase]
-    raise ArgumentError, "unknown encoding name - #{name}" unless encoding
-    encoding
+    `return Opal.find_encoding(name)`
   end
 
   singleton_class.attr_accessor :default_external
@@ -43,6 +45,10 @@ class Encoding
     @dummy
   end
 
+  def binary?
+    false
+  end
+
   def to_s
     @name
   end
@@ -52,6 +58,41 @@ class Encoding
   end
 
   # methods to implement per encoding
+  def charsize(string)
+    %x{
+      var len = 0;
+      for (var i = 0, length = string.length; i < length; i++) {
+        var charcode = string.charCodeAt(i);
+        if (!(charcode >= 0xD800 && charcode <= 0xDBFF)) {
+          len++;
+        }
+      }
+      return len;
+    }
+  end
+
+  def each_char(string, &block)
+    %x{
+      var low_surrogate = "";
+      for (var i = 0, length = string.length; i < length; i++) {
+        var charcode = string.charCodeAt(i);
+        var chr = string.charAt(i);
+        if (charcode >= 0xDC00 && charcode <= 0xDFFF) {
+          low_surrogate = chr;
+          continue;
+        }
+        else if (charcode >= 0xD800 && charcode <= 0xDBFF) {
+          chr = low_surrogate + chr;
+        }
+        if (string.encoding.name != "UTF-8") {
+          chr = new String(chr);
+          chr.encoding = string.encoding;
+        }
+        Opal.yield1(block, chr);
+      }
+    }
+  end
+
   def each_byte(*)
     raise NotImplementedError
   end
@@ -173,11 +214,11 @@ Encoding.register 'UTF-16LE' do
   end
 
   def bytesize(string)
-    string.bytes.length
+    `string.length * 2`
   end
 end
 
-Encoding.register 'UTF-16BE' do
+Encoding.register 'UTF-16BE', inherits: Encoding::UTF_16LE do
   def each_byte(string, &block)
     %x{
       for (var i = 0, length = string.length; i < length; i++) {
@@ -188,10 +229,6 @@ Encoding.register 'UTF-16BE' do
       }
     }
   end
-
-  def bytesize(string)
-    string.bytes.length
-  end
 end
 
 Encoding.register 'UTF-32LE' do
@@ -202,31 +239,68 @@ Encoding.register 'UTF-32LE' do
 
         #{yield `code & 0xff`};
         #{yield `code >> 8`};
+        #{yield 0};
+        #{yield 0};
       }
     }
   end
 
   def bytesize(string)
-    string.bytes.length
+    `string.length * 4`
   end
 end
 
-Encoding.register 'ASCII-8BIT', aliases: ['BINARY', 'US-ASCII', 'ASCII'], ascii: true, dummy: true do
+Encoding.register 'UTF-32BE', inherits: Encoding::UTF_32LE 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 0};
+        #{yield 0};
         #{yield `code >> 8`};
+        #{yield `code & 0xff`};
+      }
+    }
+  end
+end
+
+Encoding.register 'ASCII-8BIT', aliases: ['BINARY'], ascii: true do
+  def each_char(string, &block)
+    %x{
+      for (var i = 0, length = string.length; i < length; i++) {
+        var chr = new String(string.charAt(i));
+        chr.encoding = string.encoding;
+        #{yield `chr`};
+      }
+    }
+  end
+
+  def charsize(string)
+    `string.length`
+  end
+
+  def each_byte(string, &block)
+    %x{
+      for (var i = 0, length = string.length; i < length; i++) {
+        var code = string.charCodeAt(i);
+        #{yield `code & 0xff`};
       }
     }
   end
 
   def bytesize(string)
-    string.bytes.length
+    `string.length`
+  end
+
+  def binary?
+    true
   end
 end
 
+Encoding.register 'ISO-8859-1', aliases: ['ISO8859-1'], ascii: true, inherits: Encoding::ASCII_8BIT
+Encoding.register 'US-ASCII', aliases: ['ASCII'], ascii: true, inherits: Encoding::ASCII_8BIT
+
 class String
   attr_reader :encoding
   attr_reader :internal_encoding
@@ -234,9 +308,8 @@ class String
   `Opal.defineProperty(String.prototype, 'encoding', #{Encoding::UTF_8})`
   `Opal.defineProperty(String.prototype, 'internal_encoding', #{Encoding::UTF_8})`
 
-  def bytes
-    @bytes ||= each_byte.to_a
-    @bytes.dup
+  def b
+    dup.force_encoding('binary')
   end
 
   def bytesize
@@ -244,13 +317,40 @@ class String
   end
 
   def each_byte(&block)
-    return enum_for :each_byte unless block_given?
+    return enum_for(:each_byte) { bytesize } unless block_given?
 
     @internal_encoding.each_byte(self, &block)
 
     self
   end
 
+  def bytes
+    # REMIND: required when running in strict mode, otherwise the following error will be thrown:
+    # Cannot create property 'bytes' on string 'abc'
+    %x{
+      if (typeof self === 'string') {
+        return #{`new String(self)`.each_byte.to_a};
+      }
+    }
+
+    @bytes ||= each_byte.to_a
+    @bytes.dup
+  end
+
+  def each_char(&block)
+    return enum_for(:each_char) { length } unless block_given?
+
+    @encoding.each_char(self, &block)
+
+    self
+  end
+
+  def chars(&block)
+    return each_char.to_a unless block
+
+    each_char(&block)
+  end
+
   def each_codepoint(&block)
     return enum_for :each_codepoint unless block_given?
     %x{
@@ -273,16 +373,18 @@ class String
 
   def force_encoding(encoding)
     %x{
-      if (encoding === self.encoding) { return self; }
+      var str = self;
+
+      if (encoding === str.encoding) { return str; }
 
       encoding = #{Opal.coerce_to!(encoding, String, :to_s)};
       encoding = #{Encoding.find(encoding)};
 
-      if (encoding === self.encoding) { return self; }
+      if (encoding === str.encoding) { return str; }
 
-      Opal.set_encoding(self, encoding);
+      str = Opal.set_encoding(str, encoding);
 
-      return self;
+      return str;
     }
   end
 
@@ -294,6 +396,19 @@ class String
     string_bytes[idx]
   end
 
+  def initialize_copy(other)
+    %{
+      self.encoding = other.encoding;
+      self.internal_encoding = other.internal_encoding;
+    }
+  end
+
+  def length
+    `self.length`
+  end
+
+  alias size length
+
   # stub
   def valid_encoding?
     true

data/opal/corelib/string/unpack.rb

@@ -42,38 +42,6 @@ class String
       }
     }
 
-    function utf16LEToBytes(string) {
-      var utf8 = [];
-      for (var i=0; i < string.length; i++) {
-        var charcode = string.charCodeAt(i);
-        if (charcode < 0x100) utf8.push(charcode);
-        else if (charcode < 0x800) {
-          utf8.push(0xc0 | (charcode >> 6),
-                    0x80 | (charcode & 0x3f));
-        }
-        else if (charcode < 0xd800 || charcode >= 0xe000) {
-          utf8.push(0xe0 | (charcode >> 12),
-                    0x80 | ((charcode>>6) & 0x3f),
-                    0x80 | (charcode & 0x3f));
-        }
-        // surrogate pair
-        else {
-          i++;
-          // UTF-16 encodes 0x10000-0x10FFFF by
-          // subtracting 0x10000 and splitting the
-          // 20 bits of 0x0-0xFFFFF into two halves
-          charcode = 0x10000 + (((charcode & 0x3ff)<<10)
-                    | (string.charCodeAt(i) & 0x3ff))
-          utf8.push(0xf0 | (charcode >>18),
-                    0x80 | ((charcode>>12) & 0x3f),
-                    0x80 | ((charcode>>6) & 0x3f),
-                    0x80 | (charcode & 0x3f));
-        }
-      }
-
-      return utf8;
-    }
-
     function toNByteSigned(bytesCount, callback) {
       return function(data) {
         var unsignedBits = callback(data),
@@ -321,9 +289,11 @@ class String
     }
 
     function readUnicodeCharChunk(bytes) {
+      var currentByteIndex = 0;
+      var bytesLength = bytes.length;
       function readByte() {
-        var result = bytes[0];
-        bytes = bytes.slice(1, bytes.length);
+        var result = bytes[currentByteIndex++];
+        bytesLength = bytes.length - currentByteIndex;
         return result;
       }
 
@@ -331,7 +301,7 @@ class String
 
       if (c >> 7 == 0) {
         // 0xxx xxxx
-        return { chunk: [c], rest: bytes };
+        return { chunk: [c], rest: bytes.slice(currentByteIndex) };
       }
 
       if (c >> 6 == 0x02) {
@@ -357,10 +327,10 @@ class String
         #{raise 'malformed UTF-8 character'}
       }
 
-      if (extraLength > bytes.length) {
+      if (extraLength > bytesLength) {
         #{
           expected = `extraLength + 1`
-          given = `bytes.length + 1`
+          given = `bytesLength + 1`
           raise ArgumentError, "malformed UTF-8 character (expected #{expected} bytes, given #{given} bytes)"
         }
       }
@@ -380,12 +350,12 @@ class String
       }
 
       if (result <= 0xffff) {
-        return { chunk: [result], rest: bytes };
+        return { chunk: [result], rest: bytes.slice(currentByteIndex) };
       } else {
         result -= 0x10000;
         var high = ((result >> 10) & 0x3ff) + 0xd800,
             low = (result & 0x3ff) + 0xdc00;
-        return { chunk: [high, low], rest: bytes };
+        return { chunk: [high, low], rest: bytes.slice(currentByteIndex) };
       }
     }
 
@@ -711,7 +681,23 @@ class String
     %x{
       var output = [];
 
-      var buffer = utf16LEToBytes(self);
+      // A very optimized handler for U*.
+      if (format == "U*" &&
+          self.internal_encoding.name === "UTF-8" &&
+          typeof self.codePointAt === "function") {
+
+        var cp, j = 0;
+
+        output = new Array(self.length);
+        for (var i = 0; i < self.length; i++) {
+          cp = output[j++] = self.codePointAt(i);
+          if (cp > 0xffff) i++;
+        }
+        return output.slice(0, j);
+      }
+
+      var buffer = self.$bytes();
+
 
       // optimization
       var optimizedHandler = optimized[format];

data/opal/opal.rb

@@ -13,6 +13,7 @@ require 'corelib/main'
 require 'corelib/dir'
 require 'corelib/file'
 require 'corelib/process'
+require 'corelib/random/formatter'
 require 'corelib/random'
 require 'corelib/random/mersenne_twister'
 

data/opal/opal/full.rb

@@ -1,3 +1,4 @@
 require 'corelib/marshal'
 require 'corelib/string/unpack'
 require 'corelib/array/pack'
+require 'corelib/object_space'

data/package.json

@@ -5,7 +5,7 @@
     "benchmark": "^2.1.4",
     "browserify": "^17.0.0",
     "jshint": "^2.11.0-rc1",
-    "source-map-support": "^0.5.16",
+    "source-map-support": "0.5.19",
     "uglify-js": "^3.7.2"
   },
   "devDependencies": {},

data/spec/filters/bugs/array.rb

@@ -1,6 +1,5 @@
 # NOTE: run bin/format-filters after changing this file
 opal_filter "Array" do
-  fails "Array#* with an integer with a subclass of Array returns an Array instance" # Expected [] (ArraySpecs::MyArray) to be an instance of Array
   fails "Array#== compares with an equivalent Array-like object using #to_ary" # Expected false to be true
   fails "Array#== returns true for [NaN] == [NaN] because Array#== first checks with #equal? and NaN.equal?(NaN) is true" # Expected [NaN] to equal [NaN]
   fails "Array#[] can accept beginless ranges" # Opal::SyntaxError: undefined method `type' for nil
@@ -9,12 +8,6 @@ opal_filter "Array" do
   fails "Array#[] raises TypeError if to_int returns non-integer" # Expected TypeError but no exception was raised ([1, 2, 3, 4] was returned)
   fails "Array#[] raises a RangeError if passed a range with a bound that is too large" # Expected RangeError but no exception was raised (nil was returned)
   fails "Array#[] raises a type error if a range is passed with a length" # Expected TypeError but no exception was raised ([2, 3] was returned)
-  fails "Array#[] with a subclass of Array returns a Array instance with [-n, m]" # Expected [3, 4] (ArraySpecs::MyArray) to be an instance of Array
-  fails "Array#[] with a subclass of Array returns a Array instance with [-n..-m]" # Expected [3, 4, 5] (ArraySpecs::MyArray) to be an instance of Array
-  fails "Array#[] with a subclass of Array returns a Array instance with [-n...-m]" # Expected [3, 4] (ArraySpecs::MyArray) to be an instance of Array
-  fails "Array#[] with a subclass of Array returns a Array instance with [n, m]" # Expected [1, 2] (ArraySpecs::MyArray) to be an instance of Array
-  fails "Array#[] with a subclass of Array returns a Array instance with [n...m]" # Expected [2, 3] (ArraySpecs::MyArray) to be an instance of Array
-  fails "Array#[] with a subclass of Array returns a Array instance with [n..m]" # Expected [2, 3, 4] (ArraySpecs::MyArray) to be an instance of Array
   fails "Array#[]= with [..n] and [...n] inserts at the beginning if n < negative the array size" # Opal::SyntaxError: undefined method `type' for nil
   fails "Array#[]= with [..n] and [...n] just sets the section defined by range to nil even if the rhs is nil" # Opal::SyntaxError: undefined method `type' for nil
   fails "Array#[]= with [..n] and [...n] just sets the section defined by range to nil if n < 0 and the rhs is nil" # Opal::SyntaxError: undefined method `type' for nil
@@ -27,9 +20,6 @@ opal_filter "Array" do
   fails "Array#[]= with [m..] replaces the section defined by range" # Opal::SyntaxError: undefined method `type' for nil
   fails "Array#[]= with [m..] replaces the section if m and n < 0" # Opal::SyntaxError: undefined method `type' for nil
   fails "Array#deconstruct returns self" # NoMethodError: undefined method `deconstruct' for [1]
-  fails "Array#difference accepts multiple arguments" # NoMethodError: undefined method `difference' for [1, 2, 3, 1]
-  fails "Array#difference does not return subclass instances for Array subclasses" # NoMethodError: undefined method `difference' for [1, 2, 3]
-  fails "Array#difference returns a copy when called without any parameter" # NoMethodError: undefined method `difference' for [1, 2, 3, 2]
   fails "Array#drop raises a TypeError when the passed argument can't be coerced to Integer" # Expected TypeError but no exception was raised ([1, 2] was returned)
   fails "Array#drop raises a TypeError when the passed argument isn't an integer and #to_int returns non-Integer" # Expected TypeError but no exception was raised ([1, 2] was returned)
   fails "Array#drop tries to convert the passed argument to an Integer using #to_int" # Expected [1, 2, 3] == [3] to be truthy but was false
@@ -40,10 +30,8 @@ opal_filter "Array" do
   fails "Array#filter returns a new array of elements for which block is true" # NoMethodError: undefined method `filter' for [1, 3, 4, 5, 6, 9]
   fails "Array#flatten does not call #to_ary on elements beyond the given level"
   fails "Array#flatten performs respond_to? and method_missing-aware checks when coercing elements to array"
-  fails "Array#flatten returns Array instance for Array subclasses" # Expected [] (ArraySpecs::MyArray) to be an instance of Array
   fails "Array#flatten with a non-Array object in the Array calls #method_missing if defined"
   fails "Array#inspect does not call #to_str on the object returned from #to_s when it is not a String" # Exception: Cannot convert object to primitive value
-  fails "Array#intersection accepts multiple arguments" # NoMethodError: undefined method `intersection' for [1, 2, 3, 4]
   fails "Array#join raises a NoMethodError if an element does not respond to #to_str, #to_ary, or #to_s"
   fails "Array#partition returns in the left array values for which the block evaluates to true"
   fails "Array#rassoc calls elem == obj on the second element of each contained array"
@@ -55,21 +43,11 @@ opal_filter "Array" do
   fails "Array#slice raises TypeError if to_int returns non-integer" # Expected TypeError but no exception was raised ([1, 2, 3, 4] was returned)
   fails "Array#slice raises a RangeError if passed a range with a bound that is too large" # Expected RangeError but no exception was raised (nil was returned)
   fails "Array#slice raises a type error if a range is passed with a length" # Expected TypeError but no exception was raised ([2, 3] was returned)
-  fails "Array#slice with a subclass of Array returns a Array instance with [-n, m]" # Expected [3, 4] (ArraySpecs::MyArray) to be an instance of Array
-  fails "Array#slice with a subclass of Array returns a Array instance with [-n..-m]" # Expected [3, 4, 5] (ArraySpecs::MyArray) to be an instance of Array
-  fails "Array#slice with a subclass of Array returns a Array instance with [-n...-m]" # Expected [3, 4] (ArraySpecs::MyArray) to be an instance of Array
-  fails "Array#slice with a subclass of Array returns a Array instance with [n, m]" # Expected [1, 2] (ArraySpecs::MyArray) to be an instance of Array
-  fails "Array#slice with a subclass of Array returns a Array instance with [n...m]" # Expected [2, 3] (ArraySpecs::MyArray) to be an instance of Array
-  fails "Array#slice with a subclass of Array returns a Array instance with [n..m]" # Expected [2, 3, 4] (ArraySpecs::MyArray) to be an instance of Array
   fails "Array#slice! works with beginless ranges" # Opal::SyntaxError: undefined method `type' for nil
   fails "Array#slice! works with endless ranges" # Opal::SyntaxError: undefined method `type' for nil
   fails "Array#to_h with block does not coerce returned pair to Array with #to_a" # Expected TypeError (/wrong element type MockObject at 0/) but got: TypeError (wrong element type NilClass at 0 (expected array))
   fails "Array#to_h with block raises TypeError if block returns something other than Array" # Expected TypeError (/wrong element type String at 0/) but got: TypeError (wrong element type NilClass at 0 (expected array))
   fails "Array#to_s does not call #to_str on the object returned from #to_s when it is not a String" # Exception: Cannot convert object to primitive value
-  fails "Array#union accepts multiple arguments" # NoMethodError: undefined method `union' for [1, 2, 3]
-  fails "Array#union does not return subclass instances for Array subclasses"
-  fails "Array#union returns unique elements when given no argument" # NoMethodError: undefined method `union' for [1, 2, 3, 2]
-  fails "Array#uniq returns Array instance on Array subclasses" # Expected [1, 2, 3] (ArraySpecs::MyArray) to be an instance of Array
   fails "Array#uniq! properly handles recursive arrays"
   fails "Array#values_at works when given beginless ranges" # Opal::SyntaxError: undefined method `type' for nil
   fails "Array#values_at works when given endless ranges" # Opal::SyntaxError: undefined method `type' for nil