opal 0.11.4 → 1.0.0.beta1

data/opal/corelib/string.rb

@@ -4,7 +4,18 @@ require 'corelib/regexp'
 class String < `String`
   include Comparable
 
-  `def.$$is_string = true`
+  %x{
+    Opal.defineProperty(#{self}.$$prototype, '$$is_string', true);
+
+    Opal.defineProperty(#{self}.$$prototype, '$$cast', function(string) {
+      var klass = this.$$class;
+      if (klass.$$constructor === String) {
+        return string;
+      } else {
+        return new klass.$$constructor(string);
+      }
+    });
+  }
 
   def __id__
     `self.toString()`
@@ -18,7 +29,7 @@ class String < `String`
 
   def self.new(str = '')
     str = Opal.coerce_to(str, String, :to_str)
-    `new String(str)`
+    `new self.$$constructor(str)`
   end
 
   def initialize(str = undefined)
@@ -47,7 +58,7 @@ class String < `String`
       }
 
       if (count === 0) {
-        return '';
+        return self.$$cast('');
       }
 
       var result = '',
@@ -72,7 +83,7 @@ class String < `String`
         string += string;
       }
 
-      return result;
+      return self.$$cast(result);
     }
   end
 
@@ -157,7 +168,7 @@ class String < `String`
           length = 0;
         }
 
-        return self.substr(index, length);
+        return self.$$cast(self.substr(index, length));
       }
 
 
@@ -165,7 +176,7 @@ class String < `String`
         if (length != null) {
           #{raise TypeError}
         }
-        return self.indexOf(index) !== -1 ? index : nil;
+        return self.indexOf(index) !== -1 ? self.$$cast(index) : nil;
       }
 
 
@@ -180,17 +191,17 @@ class String < `String`
         #{$~ = MatchData.new(`index`, `match`)}
 
         if (length == null) {
-          return match[0];
+          return self.$$cast(match[0]);
         }
 
         length = #{Opal.coerce_to(`length`, Integer, :to_int)};
 
         if (length < 0 && -length < match.length) {
-          return match[length += match.length];
+          return self.$$cast(match[length += match.length]);
         }
 
         if (length >= 0 && length < match.length) {
-          return match[length];
+          return self.$$cast(match[length]);
         }
 
         return nil;
@@ -207,7 +218,7 @@ class String < `String`
         if (index >= size || index < 0) {
           return nil;
         }
-        return self.substr(index, 1);
+        return self.$$cast(self.substr(index, 1));
       }
 
       length = #{Opal.coerce_to(`length`, Integer, :to_int)};
@@ -220,17 +231,22 @@ class String < `String`
         return nil;
       }
 
-      return self.substr(index, length);
+      return self.$$cast(self.substr(index, length));
     }
   end
 
   alias byteslice []
 
+  def b
+    force_encoding('binary')
+  end
+
   def capitalize
-    `self.charAt(0).toUpperCase() + self.substr(1).toLowerCase()`
+    `self.$$cast(self.charAt(0).toUpperCase() + self.substr(1).toLowerCase())`
   end
 
   def casecmp(other)
+    return nil unless other.respond_to?(:to_str)
     other = Opal.coerce_to(other, String, :to_str).to_s
     %x{
       var ascii_only = /^[\x00-\x7F]*$/;
@@ -242,6 +258,17 @@ class String < `String`
     self <=> other
   end
 
+  def casecmp?(other)
+    %x{
+      var cmp = #{casecmp(other)};
+      if (cmp === nil) {
+        return nil;
+      } else {
+        return cmp === 0;
+      }
+    }
+  end
+
   def center(width, padstr = ' ')
     width  = Opal.coerce_to(width, Integer, :to_int)
     padstr = Opal.coerce_to(padstr, String, :to_str).to_s
@@ -253,10 +280,10 @@ class String < `String`
     return self if `width <= self.length`
 
     %x{
-      var ljustified = #{ljust ((width + @length) / 2).ceil, padstr},
-          rjustified = #{rjust ((width + @length) / 2).floor, padstr};
+      var ljustified = #{ljust ((width + `self.length`) / 2).ceil, padstr},
+          rjustified = #{rjust ((width + `self.length`) / 2).floor, padstr};
 
-      return rjustified + ljustified.slice(self.length);
+      return self.$$cast(rjustified + ljustified.slice(self.length));
     }
   end
 
@@ -272,19 +299,25 @@ class String < `String`
     separator = Opal.coerce_to!(separator, String, :to_str).to_s
 
     %x{
+      var result;
+
       if (separator === "\n") {
-        return self.replace(/\r?\n?$/, '');
+        result = self.replace(/\r?\n?$/, '');
       }
       else if (separator === "") {
-        return self.replace(/(\r?\n)+$/, '');
+        result = self.replace(/(\r?\n)+$/, '');
       }
-      else if (self.length > separator.length) {
+      else if (self.length >= separator.length) {
         var tail = self.substr(self.length - separator.length, separator.length);
 
         if (tail === separator) {
-          return self.substr(0, self.length - separator.length);
+          result = self.substr(0, self.length - separator.length);
         }
       }
+
+      if (result != null) {
+        return self.$$cast(result);
+      }
     }
 
     self
@@ -292,18 +325,17 @@ class String < `String`
 
   def chop
     %x{
-      var length = self.length;
+      var length = self.length, result;
 
       if (length <= 1) {
-        return "";
+        result = "";
+      } else if (self.charAt(length - 1) === "\n" && self.charAt(length - 2) === "\r") {
+        result = self.substr(0, length - 2);
+      } else {
+        result = self.substr(0, length - 1);
       }
 
-      if (self.charAt(length - 1) === "\n" && self.charAt(length - 2) === "\r") {
-        return self.substr(0, length - 2);
-      }
-      else {
-        return self.substr(0, length - 1);
-      }
+      return self.$$cast(result);
     }
   end
 
@@ -327,7 +359,7 @@ class String < `String`
   def count(*sets)
     %x{
       if (sets.length === 0) {
-        #{raise ArgumentError, "ArgumentError: wrong number of arguments (0 for 1+)"}
+        #{raise ArgumentError, 'ArgumentError: wrong number of arguments (0 for 1+)'}
       }
       var char_class = char_class_from_char_sets(sets);
       if (char_class === null) {
@@ -340,22 +372,50 @@ class String < `String`
   def delete(*sets)
     %x{
       if (sets.length === 0) {
-        #{raise ArgumentError, "ArgumentError: wrong number of arguments (0 for 1+)"}
+        #{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'), '');
+      return self.$$cast(self.replace(new RegExp(char_class, 'g'), ''));
+    }
+  end
+
+  def delete_prefix(prefix)
+    %x{
+      if (!prefix.$$is_string) {
+        #{prefix = Opal.coerce_to(prefix, String, :to_str)}
+      }
+
+      if (self.slice(0, prefix.length) === prefix) {
+        return self.$$cast(self.slice(prefix.length));
+      } else {
+        return self;
+      }
+    }
+  end
+
+  def delete_suffix(suffix)
+    %x{
+      if (!suffix.$$is_string) {
+        #{suffix = Opal.coerce_to(suffix, String, :to_str)}
+      }
+
+      if (self.slice(self.length - suffix.length) === suffix) {
+        return self.$$cast(self.slice(0, self.length - suffix.length));
+      } else {
+        return self;
+      }
     }
   end
 
   def downcase
-    `self.toLowerCase()`
+    `self.$$cast(self.toLowerCase())`
   end
 
   def each_char(&block)
-    return enum_for(:each_char){self.size} unless block_given?
+    return enum_for(:each_char) { size } unless block_given?
 
     %x{
       for (var i = 0, length = self.length; i < length; i++) {
@@ -383,7 +443,8 @@ class String < `String`
       if (separator.length === 0) {
         for (a = self.split(/(\n{2,})/), i = 0, n = a.length; i < n; i += 2) {
           if (a[i] || a[i + 1]) {
-            Opal.yield1(block, (a[i] || "") + (a[i + 1] || ""));
+            var value = (a[i] || "") + (a[i + 1] || "");
+            Opal.yield1(block, self.$$cast(value));
           }
         }
 
@@ -396,10 +457,10 @@ class String < `String`
 
       for (i = 0, length = splitted.length; i < length; i++) {
         if (i < length - 1 || trailing) {
-          Opal.yield1(block, splitted[i] + separator);
+          Opal.yield1(block, self.$$cast(splitted[i] + separator));
         }
         else {
-          Opal.yield1(block, splitted[i]);
+          Opal.yield1(block, self.$$cast(splitted[i]));
         }
       }
     }
@@ -426,7 +487,6 @@ class String < `String`
     false
   end
 
-  alias eql? ==
   alias equal? ===
 
   def gsub(pattern, replacement = undefined, &block)
@@ -438,12 +498,13 @@ class String < `String`
       var result = '', match_data = nil, index = 0, match, _replacement;
 
       if (pattern.$$is_regexp) {
-        pattern = new RegExp(pattern.source, 'gm' + (pattern.ignoreCase ? 'i' : ''));
+        pattern = Opal.global_multiline_regexp(pattern);
       } else {
         pattern = #{Opal.coerce_to(`pattern`, String, :to_str)};
         pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gm');
       }
 
+      var lastIndex;
       while (true) {
         match = pattern.exec(self);
 
@@ -456,7 +517,9 @@ class String < `String`
         match_data = #{MatchData.new `pattern`, `match`};
 
         if (replacement === undefined) {
+          lastIndex = pattern.lastIndex;
           _replacement = block(match[0]);
+          pattern.lastIndex = lastIndex; // save and restore lastIndex
         }
         else if (replacement.$$is_hash) {
           _replacement = #{`replacement`[`match[0]`].to_s};
@@ -496,7 +559,7 @@ class String < `String`
       }
 
       #{$~ = `match_data`}
-      return result;
+      return self.$$cast(result);
     }
   end
 
@@ -536,7 +599,7 @@ class String < `String`
       }
 
       if (search.$$is_regexp) {
-        regex = new RegExp(search.source, 'gm' + (search.ignoreCase ? 'i' : ''));
+        regex = Opal.global_multiline_regexp(search);
         while (true) {
           match = regex.exec(self);
           if (match === null) {
@@ -587,7 +650,7 @@ class String < `String`
   end
 
   def intern
-    self
+    `self.toString()`
   end
 
   def lines(separator = $/, &block)
@@ -619,7 +682,7 @@ class String < `String`
         result += padstr;
       }
 
-      return self + result.slice(0, width);
+      return self.$$cast(self + result.slice(0, width));
     }
   end
 
@@ -643,11 +706,23 @@ class String < `String`
     pattern.match(self, pos, &block)
   end
 
+  def match?(pattern, pos = undefined)
+    if String === pattern || pattern.respond_to?(:to_str)
+      pattern = Regexp.new(pattern.to_str)
+    end
+
+    unless Regexp === pattern
+      raise TypeError, "wrong argument type #{pattern.class} (expected Regexp)"
+    end
+
+    pattern.match?(self, pos)
+  end
+
   def next
     %x{
       var i = self.length;
       if (i === 0) {
-        return '';
+        return self.$$cast('');
       }
       var result = self;
       var first_alphanum_char_index = self.search(/[a-zA-Z0-9]/);
@@ -709,7 +784,7 @@ class String < `String`
           break;
         }
       }
-      return result;
+      return self.$$cast(result);
     }
   end
 
@@ -812,7 +887,7 @@ class String < `String`
 
       if (search.$$is_regexp) {
         m = null;
-        r = new RegExp(search.source, 'gm' + (search.ignoreCase ? 'i' : ''));
+        r = Opal.global_multiline_regexp(search);
         while (true) {
           _m = r.exec(self);
           if (_m === null || _m.index > offset) {
@@ -853,7 +928,7 @@ class String < `String`
           result    = Array(patterns + 1).join(padstr),
           remaining = chars - result.length;
 
-      return result + padstr.slice(0, remaining) + self;
+      return self.$$cast(result + padstr.slice(0, remaining) + self);
     }
   end
 
@@ -863,7 +938,7 @@ class String < `String`
 
       if (sep.$$is_regexp) {
         m = null;
-        r = new RegExp(sep.source, 'gm' + (sep.ignoreCase ? 'i' : ''));
+        r = Opal.global_multiline_regexp(sep);
 
         while (true) {
           _m = r.exec(self);
@@ -910,7 +985,7 @@ class String < `String`
           match;
 
       if (pattern.$$is_regexp) {
-        pattern = new RegExp(pattern.source, 'gm' + (pattern.ignoreCase ? 'i' : ''));
+        pattern = Opal.global_multiline_regexp(pattern);
       } else {
         pattern = #{Opal.coerce_to(`pattern`, String, :to_str)};
         pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gm');
@@ -964,7 +1039,7 @@ class String < `String`
           i, ii;
 
       if (pattern.$$is_regexp) {
-        pattern = new RegExp(pattern.source, 'gm' + (pattern.ignoreCase ? 'i' : ''));
+        pattern = Opal.global_multiline_regexp(pattern);
       } else {
         pattern = #{Opal.coerce_to(pattern, String, :to_str).to_s};
         if (pattern === ' ') {
@@ -978,17 +1053,24 @@ class String < `String`
       result = string.split(pattern);
 
       if (result.length === 1 && result[0] === string) {
-        return result;
+        return [self.$$cast(result[0])];
       }
 
       while ((i = result.indexOf(undefined)) !== -1) {
         result.splice(i, 1);
       }
 
+      function castResult() {
+        for (i = 0; i < result.length; i++) {
+          result[i] = self.$$cast(result[i]);
+        }
+      }
+
       if (limit === 0) {
         while (result[result.length - 1] === '') {
           result.length -= 1;
         }
+        castResult();
         return result;
       }
 
@@ -1000,15 +1082,18 @@ class String < `String`
             result.push('');
           }
         }
+        castResult();
         return result;
       }
 
       if (match !== null && match[0] === '') {
         result.splice(limit - 1, result.length - 1, result.slice(limit - 1).join(''));
+        castResult();
         return result;
       }
 
       if (limit >= result.length) {
+        castResult();
         return result;
       }
 
@@ -1022,6 +1107,7 @@ class String < `String`
         match = pattern.exec(string);
       }
       result.splice(limit - 1, result.length - 1, string.slice(index));
+      castResult();
       return result;
     }
   end
@@ -1029,13 +1115,13 @@ class String < `String`
   def squeeze(*sets)
     %x{
       if (sets.length === 0) {
-        return self.replace(/(.)\1+/g, '$1');
+        return self.$$cast(self.replace(/(.)\1+/g, '$1'));
       }
       var char_class = char_class_from_char_sets(sets);
       if (char_class === null) {
         return self;
       }
-      return self.replace(new RegExp('(' + char_class + ')\\1+', 'g'), '$1');
+      return self.$$cast(self.replace(new RegExp('(' + char_class + ')\\1+', 'g'), '$1'));
     }
   end
 
@@ -1064,48 +1150,53 @@ class String < `String`
         pattern = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
       }
 
-      var result = pattern.exec(self);
+      var result, match = pattern.exec(self);
 
-      if (result === null) {
+      if (match === null) {
         #{$~ = nil}
-        return self.toString();
-      }
+        result = self.toString();
+      } else {
+        #{MatchData.new `pattern`, `match`}
 
-      #{MatchData.new `pattern`, `result`}
+        if (replacement === undefined) {
 
-      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 (block === nil) {
+            #{raise ArgumentError, 'wrong number of arguments (1 for 2)'}
+          }
+          result = self.slice(0, match.index) + block(match[0]) + self.slice(match.index + match[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 (replacement.$$is_hash) {
 
-      replacement = #{Opal.coerce_to(`replacement`, String, :to_str)};
+          result = self.slice(0, match.index) + #{`replacement`[`match[0]`].to_s} + self.slice(match.index + match[0].length);
 
-      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];
+        } else {
+
+          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;
             }
-          }
-          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] || '');
+            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, '\\');
+
+          result = self.slice(0, match.index) + replacement + self.slice(match.index + match[0].length);
         }
-      }).replace(/\\\\/g, '\\');
+      }
 
-      return self.slice(0, result.index) + replacement + self.slice(result.index + result[0].length);
+      return self.$$cast(result);
     }
   end
 
@@ -1222,16 +1313,33 @@ class String < `String`
   end
 
   def to_proc
-    sym = `self.valueOf()`
+    method_name = '$' + `self.valueOf()`
 
     proc do |*args, &block|
       %x{
         if (args.length === 0) {
-          #{raise ArgumentError, "no receiver given"}
+          #{raise ArgumentError, 'no receiver given'}
+        }
+
+        var recv = args[0];
+
+        if (recv == null) recv = nil;
+
+        var body = recv[#{method_name}];
+
+        if (!body) {
+          return recv.$method_missing.apply(recv, args);
+        }
+
+        if (typeof block === 'function') {
+          body.$$p = block;
+        }
+
+        if (args.length === 1) {
+          return body.call(recv);
+        } else {
+          return body.apply(recv, args.slice(1));
         }
-        var obj = args.shift();
-        if (obj == null) obj = nil;
-        return Opal.send(obj, sym, args, block);
       }
     end
   end
@@ -1384,7 +1492,7 @@ class String < `String`
           new_str += (sub != null ? sub : ch);
         }
       }
-      return new_str;
+      return self.$$cast(new_str);
     }
   end
 
@@ -1546,12 +1654,12 @@ class String < `String`
           }
         }
       }
-      return new_str;
+      return self.$$cast(new_str);
     }
   end
 
   def upcase
-    `self.toUpperCase()`
+    `self.$$cast(self.toUpperCase())`
   end
 
   def upto(stop, excl = false, &block)
@@ -1698,30 +1806,23 @@ class String < `String`
   end
 
   def self._load(*args)
-    self.new(*args)
+    new(*args)
   end
 
-  def unpack(pattern)
-    %x{
-      function stringToBytes(string) {
-        var i,
-            singleByte,
-            l = string.length,
-            result = [];
+  def unicode_normalize(form = undefined)
+    `self.toString()`
+  end
 
-        for (i = 0; i < l; i++) {
-          singleByte = string.charCodeAt(i);
-          result.push(singleByte);
-        }
-        return result;
-      }
-    }
-    case pattern
-    when "U*", "C*"
-      `stringToBytes(self);`
-    else
-      raise NotImplementedError
-    end
+  def unicode_normalized?(form = undefined)
+    true
+  end
+
+  def unpack(format)
+    raise "To use String#unpack, you must first require 'corelib/string/unpack'."
+  end
+
+  def unpack1(format)
+    raise "To use String#unpack1, you must first require 'corelib/string/unpack'."
   end
 end