Add optional startIndex to String.replaceFirst

BUG= https://code.google.com/p/dart/issues/detail?id=3194
R=lrn@google.com

Review URL: https://codereview.chromium.org//462463003

git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@39490 260f80e4-7a28-3924-810f-c04153c831b5

Author: lrhn

runtime/lib/string_patch.dart

@@ -414,23 +414,29 @@ class _StringBase {
     return pattern.allMatches(this.substring(startIndex)).isNotEmpty;
   }
 
-  String replaceFirst(Pattern pattern, String replacement) {
+  String replaceFirst(Pattern pattern,
+                      String replacement,
+                      [int startIndex = 0]) {
     if (pattern is! Pattern) {
       throw new ArgumentError("${pattern} is not a Pattern");
     }
     if (replacement is! String) {
       throw new ArgumentError("${replacement} is not a String");
     }
-    StringBuffer buffer = new StringBuffer();
-    int startIndex = 0;
-    Iterator iterator = pattern.allMatches(this).iterator;
-    if (iterator.moveNext()) {
-      Match match = iterator.current;
-      buffer..write(this.substring(startIndex, match.start))
-            ..write(replacement);
-      startIndex = match.end;
+    if (startIndex is! int) {
+      throw new ArgumentError("${startIndex} is not an int");
     }
-    return (buffer..write(this.substring(startIndex))).toString();
+    if ((startIndex < 0) || (startIndex > this.length)) {
+      throw new RangeError.range(startIndex, 0, this.length);
+    }
+    Iterator iterator =
+        startIndex == 0 ? pattern.allMatches(this).iterator
+                        : pattern.allMatches(this, startIndex).iterator;
+    if (!iterator.moveNext()) return this;
+    Match match = iterator.current;
+    return "${this.substring(0, match.start)}"
+           "$replacement"
+           "${this.substring(match.end)}";
   }
 
   String replaceAll(Pattern pattern, String replacement) {

sdk/lib/_internal/lib/js_string.dart

@@ -70,9 +70,13 @@ class JSString extends Interceptor implements String, JSIndexable {
     return stringReplaceAllFuncUnchecked(this, from, onMatch, onNonMatch);
   }
 
-  String replaceFirst(Pattern from, String to) {
+  String replaceFirst(Pattern from, String to, [int startIndex = 0]) {
     checkString(to);
-    return stringReplaceFirstUnchecked(this, from, to);
+    checkInt(startIndex);
+    if (startIndex < 0 || startIndex > this.length) {
+      throw new RangeError.range(startIndex, 0, this.length);
+    }
+    return stringReplaceFirstUnchecked(this, from, to, startIndex);
   }
 
   List<String> split(Pattern pattern) {

sdk/lib/_internal/lib/string_helper.dart

@@ -77,6 +77,14 @@ stringReplaceJS(receiver, replacer, to) {
   return JS('String', r'#.replace(#, #)', receiver, replacer, to);
 }
 
+stringReplaceFirstRE(receiver, regexp, to, startIndex) {
+  var match = regexp._execGlobal(receiver, startIndex);
+  if (match == null) return receiver;
+  var start = match.start;
+  var end = match.end;
+  return "${receiver.substring(0,start)}$to${receiver.substring(end)}";
+}
+
 const String ESCAPE_REGEXP = r'[[\]{}()*+?.\\^$|]';
 
 stringReplaceAllUnchecked(receiver, from, to) {
@@ -185,12 +193,16 @@ stringReplaceAllStringFuncUnchecked(receiver, pattern, onMatch, onNonMatch) {
 }
 
 
-stringReplaceFirstUnchecked(receiver, from, to) {
+stringReplaceFirstUnchecked(receiver, from, to, [int startIndex = 0]) {
   if (from is String) {
-    return stringReplaceJS(receiver, from, to);
+    var index = receiver.indexOf(from, startIndex);
+    if (index < 0) return receiver;
+    return '${receiver.substring(0, index)}$to'
+           '${receiver.substring(index + from.length)}';
   } else if (from is JSSyntaxRegExp) {
-    var re = regExpGetNative(from);
-    return stringReplaceJS(receiver, re, to);
+    return startIndex == 0 ?
+        stringReplaceJS(receiver, regExpGetNative(from), to) :
+        stringReplaceFirstRE(receiver, from, to, startIndex);
   } else {
     checkNull(from);
     // TODO(floitsch): implement generic String.replace (with patterns).

sdk/lib/core/string.dart

@@ -409,11 +409,12 @@ abstract class String implements Comparable<String>, Pattern {
 
   /**
    * Returns a new string in which  the first occurence of [from] in this string
-   * is replaced with [to]:
+   * is replaced with [to], starting from [startIndex]:
    *
    *     '0.0001'.replaceFirst(new RegExp(r'0'), ''); // '.0001'
+   *     '0.0001'.replaceFirst(new RegExp(r'0'), '7', 1); // '0.7001'
    */
-  String replaceFirst(Pattern from, String to);
+  String replaceFirst(Pattern from, String to, [int startIndex = 0]);
 
   /**
    * Replaces all substrings that match [from] with [replace].

tests/corelib/string_replace_test.dart

@@ -42,6 +42,51 @@ class StringReplaceTest {
 
     // Test replacing the empty string.
     Expect.equals("toAtoBtoCto", "AtoBtoCto".replaceFirst("", "to"));
+
+    // Test startIndex.
+    Expect.equals(
+        "foo-AAA-foo-bar", "foo-bar-foo-bar".replaceFirst("bar", "AAA", 4));
+
+    // Test startIndex skipping one case at the begining.
+    Expect.equals(
+        "foo-bar-AAA-bar", "foo-bar-foo-bar".replaceFirst("foo", "AAA", 1));
+
+    // Test startIndex skipping one case at the begining.
+    Expect.equals(
+        "foo-bar-foo-AAA", "foo-bar-foo-bar".replaceFirst("bar", "AAA", 5));
+
+    // Test startIndex replacing with the empty string.
+    Expect.equals(
+        "foo-bar--bar", "foo-bar-foo-bar".replaceFirst("foo", "", 1));
+
+    // Test startIndex with a RegExp with carat
+    Expect.equals(
+        "foo-bar-foo-bar",
+        "foo-bar-foo-bar".replaceFirst(new RegExp(r"^foo"), "", 8));
+
+    // Test startIndex with a RegExp
+    Expect.equals(
+        "aaa{3}X{3}", "aaa{3}aaa{3}".replaceFirst(new RegExp(r"a{3}"), "X", 1));
+
+    // Test startIndex with regexp-looking String
+    Expect.equals(
+        "aaa{3}aaX", "aaa{3}aaa{3}".replaceFirst("a{3}", "X", 3));
+
+    // Test negative startIndex
+    Expect.throws(
+        () => "hello".replaceFirst("h", "X", -1), (e) => e is RangeError);
+
+    // Test startIndex too large
+    Expect.throws(
+        () => "hello".replaceFirst("h", "X", 6), (e) => e is RangeError);
+
+    // Test null startIndex
+    Expect.throws(
+        () => "hello".replaceFirst("h", "X", null), (e) => e is ArgumentError);
+
+    // Test object startIndex
+    Expect.throws(
+        () => "hello".replaceFirst("h", "X", new Object()));
   }
 }