opal 0.7.2 → 0.8.0.beta1

data/opal/corelib/runtime.js

@@ -29,12 +29,17 @@
   var $hasOwn = Opal.hasOwnProperty;
   var $slice  = Opal.slice = Array.prototype.slice;
 
-  // Generates unique id for every ruby object
-  var unique_id = 0;
+  // Nil object id is always 4
+  var nil_id = 4;
+
+  // Generates even sequential numbers greater than 4
+  // (nil_id) to serve as unique ids for ruby objects
+  var unique_id = nil_id;
 
   // Return next unique id
   Opal.uid = function() {
-    return unique_id++;
+    unique_id += 2;
+    return unique_id;
   };
 
   // Table holds all class variables
@@ -238,7 +243,7 @@
   function setup_module_or_class_object(module, constructor, superklass, prototype) {
     // @property $$id Each class is assigned a unique `id` that helps
     //                comparation and implementation of `#object_id`
-    module.$$id = unique_id++;
+    module.$$id = Opal.uid();
 
     // @property $$proto This is the prototype on which methods will be defined
     module.$$proto = prototype;
@@ -1134,6 +1139,13 @@
     }
   }
 
+  /*
+   * Called to remove a method.
+   */
+  Opal.undef = function(obj, jsid) {
+    delete obj.$$proto[jsid];
+  };
+
   Opal.hash = function() {
     if (arguments.length == 1 && arguments[0].$$class == Opal.Hash) {
       return arguments[0];
@@ -1182,7 +1194,7 @@
         obj = arguments[0];
         for (key in obj) {
           khash = key.$hash();
-          map[khash] = obj[khash];
+          smap[khash] = obj[khash];
           keys.push(key);
         }
       }
@@ -1248,8 +1260,8 @@
   // Require system
   // --------------
   (function(Opal) {
-    var loaded_features = ['corelib/runtime.js'],
-        require_table   = {'corelib/runtime.js': true},
+    var loaded_features = ['corelib/runtime'],
+        require_table   = {'corelib/runtime': true},
         modules         = {};
 
     var current_dir  = '.';
@@ -1272,6 +1284,7 @@
         path = current_dir.replace(/\/*$/, '/') + path;
       }
 
+      path = path.replace(/\.(rb|opal|js)$/, '');
       parts = path.split(SEPARATOR);
 
       for (var i = 0, ii = parts.length; i < ii; i++) {
@@ -1408,7 +1421,6 @@
   Opal.top = new ObjectClass.$$alloc();
 
   // Nil
-  var nil_id = Opal.uid(); // nil id is traditionally 4
   Opal.klass(ObjectClass, ObjectClass, 'NilClass', NilClass);
   var nil = Opal.nil = new NilClass();
   nil.$$id = nil_id;

data/opal/corelib/string.rb

@@ -5,16 +5,29 @@ class String
 
   `def.$$is_string = true`
 
+  def __id__
+    `self.toString()`
+  end
+  alias object_id __id__
+
   def self.try_convert(what)
-    what.to_str
-  rescue
-    nil
+    Opal.coerce_to?(what, String, :to_str)
   end
 
   def self.new(str = '')
+    str = Opal.coerce_to(str, String, :to_str)
     `new String(str)`
   end
 
+  def initialize(str = undefined)
+    %x{
+      if (str === undefined) {
+        return self;
+      }
+    }
+    raise NotImplementedError, 'Mutable strings are not supported in Opal.'
+  end
+
   def %(data)
     if Array === data
       format(self, *data)
@@ -25,20 +38,36 @@ class String
 
   def *(count)
     %x{
-      if (count < 1) {
+      count = #{Opal.coerce_to(`count`, Integer, :to_int)};
+
+      if (count < 0) {
+        #{raise ArgumentError, 'negative argument'}
+      }
+
+      if (count === 0) {
         return '';
       }
 
-      var result  = '',
-          pattern = self;
+      var result = '',
+          string = self.toString();
 
-      while (count > 0) {
-        if (count & 1) {
-          result += pattern;
-        }
+      // All credit for the bit-twiddling magic code below goes to Mozilla
+      // polyfill implementation of String.prototype.repeat() posted here:
+      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat
 
-        count >>= 1;
-        pattern += pattern;
+      if (string.length * count >= 1 << 28) {
+        #{raise RangeError, 'multiply count must not overflow maximum string size'}
+      }
+
+      for (;;) {
+        if ((count & 1) === 1) {
+          result += string;
+        }
+        count >>>= 1;
+        if (count === 0) {
+          break;
+        }
+        string += string;
       }
 
       return result;
@@ -75,9 +104,15 @@ class String
   end
 
   def ==(other)
-    return false unless String === other
-
-    `#{to_s} == #{other.to_s}`
+    %x{
+      if (other.$$is_string) {
+        return self.toString() === other.toString();
+      }
+      if (#{Opal.respond_to? `other`, :to_str}) {
+        return #{other == self};
+      }
+      return false;
+    }
   end
 
   alias eql? ==
@@ -99,8 +134,12 @@ class String
 
       if (index.$$is_range) {
         var exclude = index.exclude,
-            length  = index.end,
-            index   = index.begin;
+            length  = #{Opal.coerce_to(`index.end`, Integer, :to_int)},
+            index   = #{Opal.coerce_to(`index.begin`, Integer, :to_int)};
+
+        if (Math.abs(index) > size) {
+          return nil;
+        }
 
         if (index < 0) {
           index += size;
@@ -114,10 +153,6 @@ class String
           length += 1;
         }
 
-        if (index > size) {
-          return nil;
-        }
-
         length = length - index;
 
         if (length < 0) {
@@ -127,19 +162,63 @@ class String
         return self.substr(index, length);
       }
 
+
+      if (index.$$is_string) {
+        if (length != null) {
+          #{raise TypeError}
+        }
+        return self.indexOf(index) !== -1 ? index : nil;
+      }
+
+
+      if (index.$$is_regexp) {
+        var match = self.match(index);
+
+        if (match === null) {
+          #{$~ = nil}
+          return nil;
+        }
+
+        #{$~ = MatchData.new(`index`, `match`)}
+
+        if (length == null) {
+          return match[0];
+        }
+
+        length = #{Opal.coerce_to(`length`, Integer, :to_int)};
+
+        if (length < 0 && -length < match.length) {
+          return match[length += match.length];
+        }
+
+        if (length >= 0 && length < match.length) {
+          return match[length];
+        }
+
+        return nil;
+      }
+
+
+      index = #{Opal.coerce_to(`index`, Integer, :to_int)};
+
       if (index < 0) {
-        index += self.length;
+        index += size;
       }
 
       if (length == null) {
-        if (index >= self.length || index < 0) {
+        if (index >= size || index < 0) {
           return nil;
         }
-
         return self.substr(index, 1);
       }
 
-      if (index > self.length || index < 0) {
+      length = #{Opal.coerce_to(`length`, Integer, :to_int)};
+
+      if (length < 0) {
+        return nil;
+      }
+
+      if (index > size || index < 0) {
         return nil;
       }
 
@@ -155,8 +234,14 @@ class String
 
   def casecmp(other)
     other = Opal.coerce_to(other, String, :to_str).to_s
-
-    `self.toLowerCase()` <=> `other.toLowerCase()`
+    %x{
+      var ascii_only = /^[\x00-\x7F]*$/;
+      if (ascii_only.test(self) && ascii_only.test(other)) {
+        self = self.toLowerCase();
+        other = other.toLowerCase();
+      }
+    }
+    self <=> other
   end
 
   def center(width, padstr = ' ')
@@ -244,8 +329,30 @@ class String
     copy
   end
 
-  def count(str)
-    `(self.length - self.replace(new RegExp(str, 'g'), '').length) / str.length`
+  def count(*sets)
+    %x{
+      if (sets.length === 0) {
+        #{raise ArgumentError, "ArgumentError: wrong number of arguments (0 for 1+)"}
+      }
+      var char_class = char_class_from_char_sets(sets);
+      if (char_class === null) {
+        return 0;
+      }
+      return self.length - self.replace(new RegExp(char_class, 'g'), '').length;
+    }
+  end
+
+  def delete(*sets)
+    %x{
+      if (sets.length === 0) {
+        #{raise ArgumentError, "ArgumentError: wrong number of arguments (0 for 1+)"}
+      }
+      var char_class = char_class_from_char_sets(sets);
+      if (char_class === null) {
+        return self;
+      }
+      return self.replace(new RegExp(char_class, 'g'), '');
+    }
   end
 
   alias dup clone
@@ -269,10 +376,26 @@ class String
   end
 
   def each_line(separator = $/)
-    return split(separator) unless block_given?
+    return enum_for :each_line, separator unless block_given?
 
     %x{
-      var chomped  = #{chomp},
+      if (separator === nil) {
+        #{yield self};
+        return self;
+      }
+
+      separator = #{Opal.coerce_to(`separator`, String, :to_str)}
+
+      if (separator.length === 0) {
+        for (var a = self.split(/(\n{2,})/), i = 0, n = a.length; i < n; i += 2) {
+          if (a[i] || a[i + 1]) {
+            #{yield `(a[i] || "") + (a[i + 1] || "")`};
+          }
+        }
+        return self;
+      }
+
+      var chomped  = #{chomp(separator)},
           trailing = self.length != chomped.length,
           splitted = chomped.split(separator);
 
@@ -311,22 +434,73 @@ class String
   alias eql? ==
   alias equal? ===
 
-  def gsub(pattern, replace = undefined, &block)
-    if String === pattern || pattern.respond_to?(:to_str)
-      pattern = /#{Regexp.escape(pattern.to_str)}/
-    end
+  def gsub(pattern, replacement = undefined, &block)
+    %x{
+      var result = '', match_data = nil, index = 0, match, _replacement;
 
-    unless Regexp === pattern
-      raise TypeError, "wrong argument type #{pattern.class} (expected Regexp)"
-    end
+      if (pattern.$$is_regexp) {
+        pattern = new RegExp(pattern.source, 'gm' + (pattern.ignoreCase ? 'i' : ''));
+      } else {
+        pattern = #{Opal.coerce_to(`pattern`, String, :to_str)};
+        pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gm');
+      }
 
-    %x{
-      var pattern = pattern.toString(),
-          options = pattern.substr(pattern.lastIndexOf('/') + 1) + 'g',
-          regexp  = pattern.substr(1, pattern.lastIndexOf('/') - 1);
+      while (true) {
+        match = pattern.exec(self);
+
+        if (match === null) {
+          #{$~ = nil}
+          result += self.slice(index);
+          break;
+        }
+
+        match_data = #{MatchData.new `pattern`, `match`};
+
+        if (replacement === undefined) {
+          if (block === nil) {
+            #{raise ArgumentError, 'wrong number of arguments (1 for 2)'}
+          }
+          _replacement = block(match[0]);
+        }
+        else if (replacement.$$is_hash) {
+          _replacement = #{`replacement`[`match[0]`].to_s};
+        }
+        else {
+          if (!replacement.$$is_string) {
+            replacement = #{Opal.coerce_to(`replacement`, String, :to_str)};
+          }
+          _replacement = replacement.replace(/([\\]+)([0-9+&`'])/g, function (original, slashes, command) {
+            if (slashes.length % 2 === 0) {
+              return original;
+            }
+            switch (command) {
+            case "+":
+              for (var i = match.length - 1; i > 0; i--) {
+                if (match[i] !== undefined) {
+                  return slashes.slice(1) + match[i];
+                }
+              }
+              return '';
+            case "&": return slashes.slice(1) + match[0];
+            case "`": return slashes.slice(1) + self.slice(0, match.index);
+            case "'": return slashes.slice(1) + self.slice(match.index + match[0].length);
+            default:  return slashes.slice(1) + (match[command] || '');
+            }
+          }).replace(/\\\\/g, '\\');
+        }
+
+        if (pattern.lastIndex === match.index) {
+          result += (_replacement + self.slice(index, match.index + 1))
+          pattern.lastIndex += 1;
+        }
+        else {
+          result += (self.slice(index, match.index) + _replacement)
+        }
+        index = pattern.lastIndex;
+      }
 
-      self.$sub.$$p = block;
-      return self.$sub(new RegExp(regexp, options), replace);
+      #{$~ = `match_data`}
+      return result;
     }
   end
 
@@ -354,77 +528,72 @@ class String
     `self.indexOf(#{other.to_str}) !== -1`
   end
 
-  def index(what, offset = nil)
-    if String === what
-      what = what.to_s
-    elsif what.respond_to? :to_str
-      what = what.to_str.to_s
-    elsif not Regexp === what
-      raise TypeError, "type mismatch: #{what.class} given"
-    end
-
-    result = -1
-
-    if offset
-      offset = Opal.coerce_to offset, Integer, :to_int
-
-      %x{
-        var size = self.length;
-
+  def index(search, offset = undefined)
+    %x{
+      var index,
+          match,
+          regex;
+
+      if (offset === undefined) {
+        offset = 0;
+      } else {
+        offset = #{Opal.coerce_to(`offset`, Integer, :to_int)};
         if (offset < 0) {
-          offset = offset + size;
-        }
-
-        if (offset > size) {
-          return nil;
+          offset += self.length;
+          if (offset < 0) {
+            return nil;
+          }
         }
       }
 
-      if Regexp === what
-        result = (what =~ `self.substr(offset)`) || -1
-      else
-        result = `self.substr(offset).indexOf(what)`
-      end
-
-      %x{
-        if (result !== -1) {
-          result += offset;
+      if (search.$$is_regexp) {
+        regex = new RegExp(search.source, 'gm' + (search.ignoreCase ? 'i' : ''));
+        while (true) {
+          match = regex.exec(self);
+          if (match === null) {
+            #{$~ = nil};
+            index = -1;
+            break;
+          }
+          if (match.index >= offset) {
+            #{$~ = MatchData.new(`regex`, `match`)}
+            index = match.index;
+            break;
+          }
+          regex.lastIndex = match.index + 1;
+        }
+      } else {
+        search = #{Opal.coerce_to(`search`, String, :to_str)};
+        if (search.length === 0 && offset > self.length) {
+          index = -1;
+        } else {
+          index = self.indexOf(search, offset);
         }
       }
-    else
-      if Regexp === what
-        result = (what =~ self) || -1
-      else
-        result = `self.indexOf(what)`
-      end
-    end
 
-    unless `result === -1`
-      result
-    end
+      return index === -1 ? nil : index;
+    }
   end
 
   def inspect
     %x{
-      var escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
-          meta      = {
+      var escapable = /[\\\"\x00-\x1f\x7f-\x9f\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+          meta = {
+            '\u0007': '\\a',
+            '\u001b': '\\e',
             '\b': '\\b',
             '\t': '\\t',
             '\n': '\\n',
             '\f': '\\f',
             '\r': '\\r',
+            '\v': '\\v',
             '"' : '\\"',
             '\\': '\\\\'
-          };
-
-      escapable.lastIndex = 0;
-
-      return escapable.test(self) ? '"' + self.replace(escapable, function(a) {
-        var c = meta[a];
-
-        return typeof c === 'string' ? c :
-          '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
-      }) + '"' : '"' + self + '"';
+          },
+          escaped = self.replace(escapable, function (chr) {
+            return meta[chr] || '\\u' + ('0000' + chr.charCodeAt(0).toString(16).toUpperCase()).slice(-4);
+          });
+      return '"' + escaped.replace(/\#[\$\@\{]/g, '\\$&') + '"';
     }
   end
 
@@ -432,8 +601,9 @@ class String
     self
   end
 
-  def lines(separator = $/)
-    each_line(separator).to_a
+  def lines(separator = $/, &block)
+    e = each_line(separator, &block)
+    block ? self : e.to_a
   end
 
   def length
@@ -472,7 +642,7 @@ class String
 
   def match(pattern, pos = undefined, &block)
     if String === pattern || pattern.respond_to?(:to_str)
-      pattern = /#{Regexp.escape(pattern.to_str)}/
+      pattern = Regexp.new(pattern.to_str)
     end
 
     unless Regexp === pattern
@@ -484,29 +654,150 @@ class String
 
   def next
     %x{
-      if (self.length === 0) {
-        return "";
+      var i = self.length;
+      if (i === 0) {
+        return '';
       }
-
-      var initial = self.substr(0, self.length - 1);
-      var last    = String.fromCharCode(self.charCodeAt(self.length - 1) + 1);
-
-      return initial + last;
+      var result = self;
+      var first_alphanum_char_index = self.search(/[a-zA-Z0-9]/);
+      var carry = false;
+      var code;
+      while (i--) {
+        code = self.charCodeAt(i);
+        if ((code >= 48 && code <= 57) ||
+          (code >= 65 && code <= 90) ||
+          (code >= 97 && code <= 122)) {
+          switch (code) {
+          case 57:
+            carry = true;
+            code = 48;
+            break;
+          case 90:
+            carry = true;
+            code = 65;
+            break;
+          case 122:
+            carry = true;
+            code = 97;
+            break;
+          default:
+            carry = false;
+            code += 1;
+          }
+        } else {
+          if (first_alphanum_char_index === -1) {
+            if (code === 255) {
+              carry = true;
+              code = 0;
+            } else {
+              carry = false;
+              code += 1;
+            }
+          } else {
+            carry = true;
+          }
+        }
+        result = result.slice(0, i) + String.fromCharCode(code) + result.slice(i + 1);
+        if (carry && (i === 0 || i === first_alphanum_char_index)) {
+          switch (code) {
+          case 65:
+            break;
+          case 97:
+            break;
+          default:
+            code += 1;
+          }
+          if (i === 0) {
+            result = String.fromCharCode(code) + result;
+          } else {
+            result = result.slice(0, i) + String.fromCharCode(code) + result.slice(i);
+          }
+          carry = false;
+        }
+        if (!carry) {
+          break;
+        }
+      }
+      return result;
     }
   end
 
   alias next! <<
 
+  def oct
+    %x{
+      var result,
+          string = self,
+          radix = 8;
+
+      if (/^\s*_/.test(string)) {
+        return 0;
+      }
+
+      string = string.replace(/^(\s*[+-]?)(0[bodx]?)(.+)$/i, function (original, head, flag, tail) {
+        switch (tail.charAt(0)) {
+        case '+':
+        case '-':
+          return original;
+        case '0':
+          if (tail.charAt(1) === 'x' && flag === '0x') {
+            return original;
+          }
+        }
+        switch (flag) {
+        case '0b':
+          radix = 2;
+          break;
+        case '0':
+        case '0o':
+          radix = 8;
+          break;
+        case '0d':
+          radix = 10;
+          break;
+        case '0x':
+          radix = 16;
+          break;
+        }
+        return head + tail;
+      });
+
+      result = parseInt(string.replace(/_(?!_)/g, ''), radix);
+      return isNaN(result) ? 0 : result;
+    }
+  end
+
   def ord
     `self.charCodeAt(0)`
   end
 
-  def partition(str)
+  def partition(sep)
     %x{
-      var result = self.split(str);
-      var splitter = (result[0].length === self.length ? "" : str);
+      var i, m;
+
+      if (sep.$$is_regexp) {
+        m = sep.exec(self);
+        if (m === null) {
+          i = -1;
+        } else {
+          #{MatchData.new `sep`, `m`};
+          sep = m[0];
+          i = m.index;
+        }
+      } else {
+        sep = #{Opal.coerce_to(`sep`, String, :to_str)};
+        i = self.indexOf(sep);
+      }
 
-      return [result[0], splitter, result.slice(1).join(str.toString())];
+      if (i === -1) {
+        return [self, '', ''];
+      }
+
+      return [
+        self.slice(0, i),
+        self.slice(i, i + sep.length),
+        self.slice(i + sep.length)
+      ];
     }
   end
 
@@ -516,48 +807,46 @@ class String
 
   alias reverse! <<
 
-  # TODO handle case where search is regexp
   def rindex(search, offset = undefined)
     %x{
-      var search_type = (search == null ? Opal.NilClass : search.constructor);
-      if (search_type != String && search_type != RegExp) {
-        var msg = "type mismatch: " + search_type + " given";
-        #{raise TypeError.new(`msg`)};
-      }
-
-      if (self.length == 0) {
-        return search.length == 0 ? 0 : nil;
-      }
+      var i, m, r, _m;
 
-      var result = -1;
-      if (offset != null) {
+      if (offset === undefined) {
+        offset = self.length;
+      } else {
+        offset = #{Opal.coerce_to(`offset`, Integer, :to_int)};
         if (offset < 0) {
-          offset = self.length + offset;
-        }
-
-        if (search_type == String) {
-          result = self.lastIndexOf(search, offset);
-        }
-        else {
-          result = self.substr(0, offset + 1).$reverse().search(search);
-          if (result !== -1) {
-            result = offset - result;
+          offset += self.length;
+          if (offset < 0) {
+            return nil;
           }
         }
       }
-      else {
-        if (search_type == String) {
-          result = self.lastIndexOf(search);
-        }
-        else {
-          result = self.$reverse().search(search);
-          if (result !== -1) {
-            result = self.length - 1 - result;
+
+      if (search.$$is_regexp) {
+        m = null;
+        r = new RegExp(search.source, 'gm' + (search.ignoreCase ? 'i' : ''));
+        while (true) {
+          _m = r.exec(self);
+          if (_m === null || _m.index > offset) {
+            break;
           }
+          m = _m;
+          r.lastIndex = m.index + 1;
+        }
+        if (m === null) {
+          #{$~ = nil}
+          i = -1;
+        } else {
+          #{MatchData.new `r`, `m`};
+          i = m.index;
         }
+      } else {
+        search = #{Opal.coerce_to(`search`, String, :to_str)};
+        i = self.lastIndexOf(search, offset);
       }
 
-      return result === -1 ? nil : result;
+      return i === -1 ? nil : i;
     }
   end
 
@@ -581,34 +870,79 @@ class String
     }
   end
 
+  def rpartition(sep)
+    %x{
+      var i, m, r, _m;
+
+      if (sep.$$is_regexp) {
+        m = null;
+        r = new RegExp(sep.source, 'gm' + (sep.ignoreCase ? 'i' : ''));
+
+        while (true) {
+          _m = r.exec(self);
+          if (_m === null) {
+            break;
+          }
+          m = _m;
+          r.lastIndex = m.index + 1;
+        }
+
+        if (m === null) {
+          i = -1;
+        } else {
+          #{MatchData.new `r`, `m`};
+          sep = m[0];
+          i = m.index;
+        }
+
+      } else {
+        sep = #{Opal.coerce_to(`sep`, String, :to_str)};
+        i = self.lastIndexOf(sep);
+      }
+
+      if (i === -1) {
+        return ['', '', self];
+      }
+
+      return [
+        self.slice(0, i),
+        self.slice(i, i + sep.length),
+        self.slice(i + sep.length)
+      ];
+    }
+  end
+
   def rstrip
-    `self.replace(/\s*$/, '')`
+    `self.replace(/[\s\u0000]*$/, '')`
   end
 
   def scan(pattern, &block)
     %x{
-      if (pattern.global) {
-        // should we clear it afterwards too?
-        pattern.lastIndex = 0;
-      }
-      else {
-        // rewrite regular expression to add the global flag to capture pre/post match
-        pattern = new RegExp(pattern.source, 'g' + (pattern.multiline ? 'm' : '') + (pattern.ignoreCase ? 'i' : ''));
+      var result = [],
+          match_data = nil,
+          match;
+
+      if (pattern.$$is_regexp) {
+        pattern = new RegExp(pattern.source, 'gm' + (pattern.ignoreCase ? 'i' : ''));
+      } else {
+        pattern = #{Opal.coerce_to(`pattern`, String, :to_str)};
+        pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gm');
       }
 
-      var result = [];
-      var match;
-
       while ((match = pattern.exec(self)) != null) {
-        var match_data = #{MatchData.new `pattern`, `match`};
+        match_data = #{MatchData.new `pattern`, `match`};
         if (block === nil) {
-          match.length == 1 ? result.push(match[0]) : result.push(match.slice(1));
+          match.length == 1 ? result.push(match[0]) : result.push(#{`match_data`.captures});
+        } else {
+          match.length == 1 ? block(match[0]) : block.call(self, #{`match_data`.captures});
         }
-        else {
-          match.length == 1 ? block(match[0]) : block.apply(self, match.slice(1));
+        if (pattern.lastIndex === match.index) {
+          pattern.lastIndex += 1;
         }
       }
 
+      #{$~ = `match_data`}
+
       return (block !== nil ? self : result);
     }
   end
@@ -748,20 +1082,11 @@ class String
       if (sets.length === 0) {
         return self.replace(/(.)\1+/g, '$1');
       }
-    }
-
-    %x{
-      var set = #{Opal.coerce_to(`sets[0]`, String, :to_str).chars};
-
-      for (var i = 1, length = sets.length; i < length; i++) {
-        set = #{`set` & Opal.coerce_to(`sets[i]`, String, :to_str).chars};
-      }
-
-      if (set.length === 0) {
+      var char_class = char_class_from_char_sets(sets);
+      if (char_class === null) {
         return self;
       }
-
-      return self.replace(new RegExp("([" + #{Regexp.escape(`set`.join)} + "])\\1+", "g"), "$1");
+      return self.replace(new RegExp('(' + char_class + ')\\1+', 'g'), '$1');
     }
   end
 
@@ -782,78 +1107,60 @@ class String
   end
 
   def strip
-    `self.replace(/^\s*/, '').replace(/\s*$/, '')`
+    `self.replace(/^\s*/, '').replace(/[\s\u0000]*$/, '')`
   end
 
   alias strip! <<
 
-  %x{
-    // convert Ruby back reference to JavaScript back reference
-    function convertReplace(replace) {
-      return replace.replace(
-        /(^|[^\\])\\(\d)/g, function(a, b, c) { return b + '$' + c }
-      ).replace(
-        /(^|[^\\])(\\\\)+\\\\(\d)/g, '$1$2\\$3'
-      ).replace(
-        /(^|[^\\])(?:(\\)\\)+([^\\]|$)/g, '$1$2$3'
-      );
-    }
-  }
-
-  def sub(pattern, replace = undefined, &block)
+  def sub(pattern, replacement = undefined, &block)
     %x{
-      if (typeof(pattern) !== 'string' && !pattern.$$is_regexp) {
-        pattern = #{Opal.coerce_to! pattern, String, :to_str};
+      if (!pattern.$$is_regexp) {
+        pattern = #{Opal.coerce_to(`pattern`, String, :to_str)};
+        pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
       }
 
-      if (replace !== undefined) {
-        if (#{replace.is_a?(Hash)}) {
-          return self.replace(pattern, function(str) {
-            var value = #{replace[str]};
+      var result = pattern.exec(self);
 
-            return (value == null) ? nil : #{value.to_s};
-          });
-        }
-        else {
-          if (typeof(replace) !== 'string') {
-            replace = #{Opal.coerce_to! replace, String, :to_str};
-          }
+      if (result === null) {
+        #{$~ = nil}
+        return self.toString();
+      }
+
+      #{MatchData.new `pattern`, `result`}
 
-          replace = convertReplace(replace);
-          return self.replace(pattern, replace);
+      if (replacement === undefined) {
+        if (block === nil) {
+          #{raise ArgumentError, 'wrong number of arguments (1 for 2)'}
         }
+        return self.slice(0, result.index) + block(result[0]) + self.slice(result.index + result[0].length);
+      }
 
+      if (replacement.$$is_hash) {
+        return self.slice(0, result.index) + #{`replacement`[`result[0]`].to_s} + self.slice(result.index + result[0].length);
       }
-      else if (block != null && block !== nil) {
-        return self.replace(pattern, function() {
-          // FIXME: this should be a formal MatchData object with all the goodies
-          var match_data = []
-          for (var i = 0, len = arguments.length; i < len; i++) {
-            var arg = arguments[i];
-            if (arg == undefined) {
-              match_data.push(nil);
-            }
-            else {
-              match_data.push(arg);
-            }
-          }
 
-          var str = match_data.pop();
-          var offset = match_data.pop();
-          var match_len = match_data.length;
+      replacement = #{Opal.coerce_to(`replacement`, String, :to_str)};
 
-          // $1, $2, $3 not being parsed correctly in Ruby code
-          for (var i = 1; i < match_len; i++) {
-            Opal.gvars[String(i)] = match_data[i];
+      replacement = replacement.replace(/([\\]+)([0-9+&`'])/g, function (original, slashes, command) {
+        if (slashes.length % 2 === 0) {
+          return original;
+        }
+        switch (command) {
+        case "+":
+          for (var i = result.length - 1; i > 0; i--) {
+            if (result[i] !== undefined) {
+              return slashes.slice(1) + result[i];
+            }
           }
-          #{$& = `match_data[0]`};
-          #{$~ = `match_data`};
-          return block(match_data[0]);
-        });
-      }
-      else {
-        #{raise ArgumentError, 'wrong number of arguments (1 for 2)'}
-      }
+          return '';
+        case "&": return slashes.slice(1) + result[0];
+        case "`": return slashes.slice(1) + self.slice(0, result.index);
+        case "'": return slashes.slice(1) + self.slice(result.index + result[0].length);
+        default:  return slashes.slice(1) + (result[command] || '');
+        }
+      }).replace(/\\\\/g, '\\');
+
+      return self.slice(0, result.index) + replacement + self.slice(result.index + result[0].length);
     }
   end
 
@@ -864,13 +1171,21 @@ class String
 
   def sum(n = 16)
     %x{
-      var result = 0;
+      n = #{Opal.coerce_to(`n`, Integer, :to_int)};
 
-      for (var i = 0, length = self.length; i < length; i++) {
-        result += (self.charCodeAt(i) % ((1 << n) - 1));
+      var result = 0,
+          length = self.length,
+          i = 0;
+
+      for (; i < length; i++) {
+        result += self.charCodeAt(i);
       }
 
-      return result;
+      if (n <= 0) {
+        return result;
+      }
+
+      return result & (Math.pow(2, n) - 1);
     }
   end
 
@@ -909,13 +1224,60 @@ class String
 
   def to_i(base = 10)
     %x{
-      var result = parseInt(self, base);
+      var result,
+          string = self.toLowerCase(),
+          radix = #{Opal.coerce_to(`base`, Integer, :to_int)};
+
+      if (radix === 1 || radix < 0 || radix > 36) {
+        #{raise ArgumentError, "invalid radix #{`radix`}"}
+      }
 
-      if (isNaN(result)) {
+      if (/^\s*_/.test(string)) {
         return 0;
       }
 
-      return result;
+      string = string.replace(/^(\s*[+-]?)(0[bodx]?)(.+)$/, function (original, head, flag, tail) {
+        switch (tail.charAt(0)) {
+        case '+':
+        case '-':
+          return original;
+        case '0':
+          if (tail.charAt(1) === 'x' && flag === '0x' && (radix === 0 || radix === 16)) {
+            return original;
+          }
+        }
+        switch (flag) {
+        case '0b':
+          if (radix === 0 || radix === 2) {
+            radix = 2;
+            return head + tail;
+          }
+          break;
+        case '0':
+        case '0o':
+          if (radix === 0 || radix === 8) {
+            radix = 8;
+            return head + tail;
+          }
+          break;
+        case '0d':
+          if (radix === 0 || radix === 10) {
+            radix = 10;
+            return head + tail;
+          }
+          break;
+        case '0x':
+          if (radix === 0 || radix === 16) {
+            radix = 16;
+            return head + tail;
+          }
+          break;
+        }
+        return original
+      });
+
+      result = parseInt(string.replace(/_(?!_)/g, ''), radix);
+      return isNaN(result) ? 0 : result;
     }
   end
 
@@ -939,6 +1301,8 @@ class 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{
       if (from.length == 0 || from === to) {
         return self;
@@ -952,7 +1316,7 @@ class String
 
       var inverse = false;
       var global_sub = null;
-      if (from_chars[0] === '^') {
+      if (from_chars[0] === '^' && from_chars.length > 1) {
         inverse = true;
         from_chars.shift();
         global_sub = to_chars[to_length - 1]
@@ -981,9 +1345,12 @@ class String
           }
         }
         else if (in_range) {
-          var start = last_from.charCodeAt(0) + 1;
+          var start = last_from.charCodeAt(0);
           var end = ch.charCodeAt(0);
-          for (var c = start; c < end; c++) {
+          if (start > end) {
+            #{raise ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
+          }
+          for (var c = start + 1; c < end; c++) {
             from_chars_expanded.push(String.fromCharCode(c));
           }
           from_chars_expanded.push(ch);
@@ -1027,9 +1394,12 @@ class String
               }
             }
             else if (in_range) {
-              var start = last_from.charCodeAt(0) + 1;
+              var start = last_from.charCodeAt(0);
               var end = ch.charCodeAt(0);
-              for (var c = start; c < end; c++) {
+              if (start > end) {
+                #{raise ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
+              }
+              for (var c = start + 1; c < end; c++) {
                 to_chars_expanded.push(String.fromCharCode(c));
               }
               to_chars_expanded.push(ch);
@@ -1076,6 +1446,8 @@ class String
   alias tr! <<
 
   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{
       if (from.length == 0) {
         return self;
@@ -1089,7 +1461,7 @@ class String
 
       var inverse = false;
       var global_sub = null;
-      if (from_chars[0] === '^') {
+      if (from_chars[0] === '^' && from_chars.length > 1) {
         inverse = true;
         from_chars.shift();
         global_sub = to_chars[to_length - 1]
@@ -1118,9 +1490,12 @@ class String
           }
         }
         else if (in_range) {
-          var start = last_from.charCodeAt(0) + 1;
+          var start = last_from.charCodeAt(0);
           var end = ch.charCodeAt(0);
-          for (var c = start; c < end; c++) {
+          if (start > end) {
+            #{raise ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
+          }
+          for (var c = start + 1; c < end; c++) {
             from_chars_expanded.push(String.fromCharCode(c));
           }
           from_chars_expanded.push(ch);
@@ -1164,9 +1539,12 @@ class String
               }
             }
             else if (in_range) {
-              var start = last_from.charCodeAt(0) + 1;
+              var start = last_from.charCodeAt(0);
               var end = ch.charCodeAt(0);
-              for (var c = start; c < end; c++) {
+              if (start > end) {
+                #{raise ArgumentError, "invalid range \"#{`String.fromCharCode(start)`}-#{`String.fromCharCode(end)`}\" in string transliteration"}
+              }
+              for (var c = start + 1; c < end; c++) {
                 to_chars_expanded.push(String.fromCharCode(c));
               }
               to_chars_expanded.push(ch);
@@ -1243,6 +1621,139 @@ class String
   def frozen?
     true
   end
+
+  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();
+
+      if (s.length === 1 && stop.length === 1) {
+
+        a = s.charCodeAt(0);
+        b = stop.charCodeAt(0);
+
+        while (a <= b) {
+          if (excl && a === b) {
+            break;
+          }
+          block(String.fromCharCode(a));
+          a += 1;
+        }
+
+      } else if (parseInt(s).toString() === s && parseInt(stop).toString() === stop) {
+
+        a = parseInt(s);
+        b = parseInt(stop);
+
+        while (a <= b) {
+          if (excl && a === b) {
+            break;
+          }
+          block(a.toString());
+          a += 1;
+        }
+
+      } else {
+
+        while (s.length <= stop.length && s <= stop) {
+          if (excl && s === stop) {
+            break;
+          }
+          block(s);
+          s = #{`s`.succ};
+        }
+
+      }
+      return self;
+    }
+  end
+
+  %x{
+    function char_class_from_char_sets(sets) {
+      function explode_sequences_in_character_set(set) {
+        var result = '',
+            i, len = set.length,
+            curr_char,
+            skip_next_dash,
+            char_code_from,
+            char_code_upto,
+            char_code;
+        for (i = 0; i < len; i++) {
+          curr_char = set.charAt(i);
+          if (curr_char === '-' && i > 0 && i < (len - 1) && !skip_next_dash) {
+            char_code_from = set.charCodeAt(i - 1);
+            char_code_upto = set.charCodeAt(i + 1);
+            if (char_code_from > char_code_upto) {
+              #{raise ArgumentError, "invalid range \"#{`char_code_from`}-#{`char_code_upto`}\" in string transliteration"}
+            }
+            for (char_code = char_code_from + 1; char_code < char_code_upto + 1; char_code++) {
+              result += String.fromCharCode(char_code);
+            }
+            skip_next_dash = true;
+            i++;
+          } else {
+            skip_next_dash = (curr_char === '\\');
+            result += curr_char;
+          }
+        }
+        return result;
+      }
+
+      function intersection(setA, setB) {
+        if (setA.length === 0) {
+          return setB;
+        }
+        var result = '',
+            i, len = setA.length,
+            chr;
+        for (i = 0; i < len; i++) {
+          chr = setA.charAt(i);
+          if (setB.indexOf(chr) !== -1) {
+            result += chr;
+          }
+        }
+        return result;
+      }
+
+      var i, len, set, neg, chr, tmp,
+          pos_intersection = '',
+          neg_intersection = '';
+
+      for (i = 0, len = sets.length; i < len; i++) {
+        set = #{Opal.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) {
+          neg_intersection = intersection(neg_intersection, set);
+        } else {
+          pos_intersection = intersection(pos_intersection, set);
+        }
+      }
+
+      if (pos_intersection.length > 0 && neg_intersection.length > 0) {
+        tmp = '';
+        for (i = 0, len = pos_intersection.length; i < len; i++) {
+          chr = pos_intersection.charAt(i);
+          if (neg_intersection.indexOf(chr) === -1) {
+            tmp += chr;
+          }
+        }
+        pos_intersection = tmp;
+        neg_intersection = '';
+      }
+
+      if (pos_intersection.length > 0) {
+        return '[' + #{Regexp.escape(`pos_intersection`)} + ']';
+      }
+
+      if (neg_intersection.length > 0) {
+        return '[^' + #{Regexp.escape(`neg_intersection`)} + ']';
+      }
+
+      return null;
+    }
+  }
 end
 
 Symbol = String