re2 0.6.0.pre → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65fc1ca01f0f974602264152462be26110297250
-  data.tar.gz: e5fdd3a7c238d629d75d76032b557658f993553b
+  metadata.gz: dbde479e41f910dff23edbc656cbc6ab092c322c
+  data.tar.gz: c69628eea5d97fae581078584353b3125b06134d
 SHA512:
-  metadata.gz: cbc9be6aef0659c89a13c0481b951467f009702e13cd4c6c426d4851c563ad16888959e2c878c79090e221909cd18f391b2bf3026b3cdaaf9d86317884e11c07
-  data.tar.gz: 94b8ea6f3f3cf1b353fa82c70611e2623c93fea6c189f1bac02435c8bf3a5cacfde032ad95b5a855ea4e1c63f3f94a0b66b1174ad42a269e6e5d6ed4b9793df3
+  metadata.gz: fbceef56880f497c8d09da21123a12056ba5bc4c351bc7e49f88b657b323fc7e9d775bb1e48836222941954ffd356f6709348eb6d9b3f7bdfa0899b77e1d0e57
+  data.tar.gz: f5a1724a484d227cb9499611c285ceeb60fbf27e99b6cfe7a67c71eb3d7272745740eb79e25a5ba828cb25ec667cc51778429a26eca95b6569d94f814c0a48b3

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2013, Paul Mucur.
+Copyright (c) 2010-2014, Paul Mucur.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -90,51 +90,24 @@ As of 0.3.0, you can use named groups:
 => "40"
 ```
 
-As of 0.4.0, you can mix `RE2::String` into strings to provide helpers from
-the opposite direction:
-
-```console
-> require "re2/string"
-> string = "My name is Robert Paulson"
-=> "My name is Robert Paulson"
-> string.extend(RE2::String)
-=> "My name is Robert Paulson"
-> string.re2_sub("Robert", "Dave")
-=> "My name is Dave Paulson"
-> string.re2_gsub("a", "e")
-=> "My neme is Deve Peulson"
-> string.re2_match('D(\S+)')
-=> #<RE2::MatchData "Deve" 1:"eve">
-> string.re2_escape
-=> "My\\ neme\\ is\\ Deve\\ Peulson"
-```
-
-If you want these available to all strings, you can reopen `String` like so:
-
-```ruby
-class String
-  include RE2::String
-end
-```
-
-As of 0.5.0, you can use `RE2::Regexp#consume` to incrementally scan text for
+As of 0.6.0, you can use `RE2::Regexp#scan` to incrementally scan text for
 matches (similar in purpose to Ruby's
 [`String#scan`](http://ruby-doc.org/core-2.0.0/String.html#method-i-scan)).
-Calling `consume` will return an `RE2::Consumer` which is
+Calling `scan` will return an `RE2::Scanner` which is
 [enumerable](http://ruby-doc.org/core-2.0.0/Enumerable.html) meaning you can
 use `each` to iterate through the matches (and even use
 [`Enumerator::Lazy`](http://ruby-doc.org/core-2.0/Enumerator/Lazy.html)):
 
 ```ruby
 re = RE2('(\w+)')
-consumer = re.consume("It is a truth universally acknowledged")
-consumer.each do |match|
+scanner = re.scan("It is a truth universally acknowledged")
+scanner.each do |match|
   puts match
 end
 
-consumer.rewind
+scanner.rewind
 
-enum = consumer.to_enum
+enum = scanner.to_enum
 enum.next #=> ["It"]
 enum.next #=> ["is"]
 ```
@@ -155,7 +128,7 @@ Features
 * Checking for matches with `re2 =~ text`, `re2 === text` (for use in `case`
   statements) and `re2 !~ text`
 
-* Incrementally scanning text with `re2.consume(text)`
+* Incrementally scanning text with `re2.scan(text)`
 
 * Checking regular expression compilation with `re2.ok?`, `re2.error` and
   `re2.error_arg`
@@ -165,16 +138,15 @@ Features
 * Checking the options for an expression with `re2.options` or individually
   with `re2.case_sensitive?`
 
-* Performing in-place replacement with [`RE2.Replace(str, pattern,
-  replace)`](http://code.google.com/p/re2/source/browse/re2/re2.h#335)
+* Performing a single string replacement with `pattern.replace(replacement,
+  original)`
 
-* Performing in-place global replacement with [`RE2.GlobalReplace(str,
-  pattern,
-  replace)`](http://code.google.com/p/re2/source/browse/re2/re2.h#352)
+* Performing a global string replacement with
+  `pattern.replace_all(replacement, original)`
 
 * Escaping regular expressions with
-  [`RE2::Regexp.escape(unquoted)`](http://code.google.com/p/re2/source/browse/re2/re2.h#377),
-  `RE2::Regexp.quote(unquoted)` or `RE2.QuoteMeta(unquoted)`
+  [`RE2.escape(unquoted)`](http://code.google.com/p/re2/source/browse/re2/re2.h#377) and
+  `RE2.quote(unquoted)`
 
 Contact
 -------

data/ext/re2/re2.cc

@@ -2,7 +2,7 @@
  * re2 (http://github.com/mudge/re2)
  * Ruby bindings to re2, an "efficient, principled regular expression library"
  *
- * Copyright (c) 2010-2013, Paul Mucur (http://mudge.name)
+ * Copyright (c) 2010-2014, Paul Mucur (http://mudge.name)
  * Released under the BSD Licence, please see LICENSE.txt
  */
 
@@ -22,14 +22,23 @@ extern "C" {
     #include <ruby/encoding.h>
     #define ENCODED_STR_NEW(str, length, encoding) \
       ({ \
-       VALUE _string = rb_str_new((const char *)str, (long)length); \
-       int _enc = rb_enc_find_index((int)encoding); \
-       rb_enc_associate_index(_string, _enc); \
-       _string; \
-       })
+        VALUE _string = rb_str_new(str, length); \
+        int _enc = rb_enc_find_index(encoding); \
+        rb_enc_associate_index(_string, _enc); \
+        _string; \
+      })
+    #define ENCODED_STR_NEW2(str, length, str2) \
+      ({ \
+        VALUE _string = rb_str_new(str, length); \
+        int _enc = rb_enc_get_index(str2); \
+        rb_enc_associate_index(_string, _enc); \
+        _string; \
+      })
   #else
     #define ENCODED_STR_NEW(str, length, encoding) \
       rb_str_new((const char *)str, (long)length)
+    #define ENCODED_STR_NEW2(str, length, str2) \
+      rb_str_new((const char *)str, (long)length)
   #endif
 
   #define BOOL2RUBY(v) (v ? Qtrue : Qfalse)
@@ -62,12 +71,12 @@ extern "C" {
   } re2_matchdata;
 
   typedef struct {
-    re2::StringPiece input;
-    int argc;
+    re2::StringPiece *input;
+    int number_of_capturing_groups;
     VALUE regexp, text;
-  } re2_consumer;
+  } re2_scanner;
 
-  VALUE re2_mRE2, re2_cRegexp, re2_cMatchData, re2_cConsumer;
+  VALUE re2_mRE2, re2_cRegexp, re2_cMatchData, re2_cScanner;
 
   /* Symbols used in RE2 options. */
   static ID id_utf8, id_posix_syntax, id_longest_match, id_log_errors,
@@ -86,12 +95,15 @@ extern "C" {
     free(self);
   }
 
-  void re2_consumer_mark(re2_consumer* self) {
+  void re2_scanner_mark(re2_scanner* self) {
     rb_gc_mark(self->regexp);
     rb_gc_mark(self->text);
   }
 
-  void re2_consumer_free(re2_consumer* self) {
+  void re2_scanner_free(re2_scanner* self) {
+    if (self->input) {
+      delete self->input;
+    }
     free(self);
   }
 
@@ -108,10 +120,10 @@ extern "C" {
         re2_matchdata_free, m);
   }
 
-  static VALUE re2_consumer_allocate(VALUE klass) {
-    re2_consumer *c;
-    return Data_Make_Struct(klass, re2_consumer, re2_consumer_mark,
-        re2_consumer_free, c);
+  static VALUE re2_scanner_allocate(VALUE klass) {
+    re2_scanner *c;
+    return Data_Make_Struct(klass, re2_scanner, re2_scanner_mark,
+        re2_scanner_free, c);
   }
 
   /*
@@ -130,37 +142,36 @@ extern "C" {
   }
 
   /*
-   * Returns the string passed into the consumer.
+   * Returns the string passed into the scanner.
    *
    * @return [String] the original string.
    * @example
-   *   c = RE2::Regexp.new('(\d+)').consume("foo")
+   *   c = RE2::Regexp.new('(\d+)').scan("foo")
    *   c.string #=> "foo"
    */
-  static VALUE re2_consumer_string(VALUE self) {
-    re2_consumer *c;
-    Data_Get_Struct(self, re2_consumer, c);
+  static VALUE re2_scanner_string(VALUE self) {
+    re2_scanner *c;
+    Data_Get_Struct(self, re2_scanner, c);
 
     return c->text;
   }
 
   /*
-   * Rewind the consumer to the start of the string.
+   * Rewind the scanner to the start of the string.
    *
    * @example
-   *   c = RE2::Regexp.new('(\d+)').consume("1 2 3")
-   *   e = c.to_enum
-   *   e.next #=> ["1"]
-   *   e.next #=> ["2"]
-   *   c.rewind
-   *   e.next #=> ["1"]
+   *   s = RE2::Regexp.new('(\d+)').scan("1 2 3")
+   *   e = s.to_enum
+   *   e.scan #=> ["1"]
+   *   e.scan #=> ["2"]
+   *   s.rewind
+   *   e.scan #=> ["1"]
    */
-  static VALUE re2_consumer_rewind(VALUE self) {
-    re2_consumer *c;
-    Data_Get_Struct(self, re2_consumer, c);
-    re2::StringPiece input(RSTRING_PTR(c->text));
+  static VALUE re2_scanner_rewind(VALUE self) {
+    re2_scanner *c;
+    Data_Get_Struct(self, re2_scanner, c);
 
-    c->input = input;
+    c->input = new(nothrow) re2::StringPiece(StringValuePtr(c->text));
 
     return self;
   }
@@ -171,31 +182,33 @@ extern "C" {
    *
    * @return [Array<String>] the matches.
    * @example
-   *   c = RE2::Regexp.new('(\w+)').consume("Foo bar baz")
-   *   c.consume #=> ["Foo"]
-   *   c.consume #=> ["bar"]
+   *   s = RE2::Regexp.new('(\w+)').scan("Foo bar baz")
+   *   s.scan #=> ["Foo"]
+   *   s.scan #=> ["bar"]
    */
-  static VALUE re2_consumer_consume(VALUE self) {
+  static VALUE re2_scanner_scan(VALUE self) {
     int i;
     re2_pattern *p;
-    re2_consumer *c;
+    re2_scanner *c;
     VALUE result;
 
-    Data_Get_Struct(self, re2_consumer, c);
+    Data_Get_Struct(self, re2_scanner, c);
     Data_Get_Struct(c->regexp, re2_pattern, p);
 
-    vector<RE2::Arg> argv(c->argc);
-    vector<RE2::Arg*> args(c->argc);
-    vector<string> matches(c->argc);
+    vector<RE2::Arg> argv(c->number_of_capturing_groups);
+    vector<RE2::Arg*> args(c->number_of_capturing_groups);
+    vector<string> matches(c->number_of_capturing_groups);
 
-    for (i = 0; i < c->argc; i++) {
-      args[i] = &argv[i];
+    for (i = 0; i < c->number_of_capturing_groups; i++) {
+      matches[i] = "";
       argv[i] = &matches[i];
+      args[i] = &argv[i];
     }
 
-    if (RE2::FindAndConsumeN(&c->input, *p->pattern, &args[0], c->argc)) {
-      result = rb_ary_new2(c->argc);
-      for (i = 0; i < c->argc; i++) {
+    if (RE2::FindAndConsumeN(c->input, *p->pattern, &args[0],
+          c->number_of_capturing_groups)) {
+      result = rb_ary_new2(c->number_of_capturing_groups);
+      for (i = 0; i < c->number_of_capturing_groups; i++) {
         if (matches[i].empty()) {
           rb_ary_push(result, Qnil);
         } else {
@@ -242,16 +255,16 @@ extern "C" {
   }
 
   /*
-   * Returns the {RE2::Regexp} used in the consumer.
+   * Returns the {RE2::Regexp} used in the scanner.
    *
-   * @return [RE2::Regexp] the regexp used in the consumer
+   * @return [RE2::Regexp] the regexp used in the scanner
    * @example
-   *   c = RE2::Regexp.new('(\d+)').consume("bob 123")
+   *   c = RE2::Regexp.new('(\d+)').scan("bob 123")
    *   c.regexp    #=> #<RE2::Regexp /(\d+)/>
    */
-  static VALUE re2_consumer_regexp(VALUE self) {
-    re2_consumer *c;
-    Data_Get_Struct(self, re2_consumer, c);
+  static VALUE re2_scanner_regexp(VALUE self) {
+    re2_scanner *c;
+    Data_Get_Struct(self, re2_scanner, c);
 
     return c->regexp;
   }
@@ -1061,31 +1074,31 @@ extern "C" {
   }
 
   /*
-   * Returns a {RE2::Consumer} for scanning the given text incrementally.
+   * Returns a {RE2::Scanner} for scanning the given text incrementally.
    *
    * @example
-   *   c = RE2::Regexp.new('(\w+)').consume("Foo bar baz")
+   *   c = RE2::Regexp.new('(\w+)').scan("Foo bar baz")
    */
-  static VALUE re2_regexp_consume(VALUE self, VALUE text) {
+  static VALUE re2_regexp_scan(VALUE self, VALUE text) {
     re2_pattern *p;
-    re2_consumer *c;
-    VALUE consumer;
-    re2::StringPiece input(RSTRING_PTR(text));
+    re2_scanner *c;
+    VALUE scanner;
 
     Data_Get_Struct(self, re2_pattern, p);
-    consumer = rb_class_new_instance(0, 0, re2_cConsumer);
-    Data_Get_Struct(consumer, re2_consumer, c);
-    c->input = input;
+    scanner = rb_class_new_instance(0, 0, re2_cScanner);
+    Data_Get_Struct(scanner, re2_scanner, c);
+
+    c->input = new(nothrow) re2::StringPiece(StringValuePtr(text));
     c->regexp = self;
     c->text = text;
-    c->argc = p->pattern->NumberOfCapturingGroups();
+    c->number_of_capturing_groups = p->pattern->NumberOfCapturingGroups();
 
-    return consumer;
+    return scanner;
   }
 
   /*
-   * Replaces the first occurrence +pattern+ in +str+ with
-   * +rewrite+ <i>in place</i>.
+   * Returns a copy of +str+ with the first occurrence +pattern+
+   * replaced with +rewrite+.
    *
    * @param [String] str the string to modify
    * @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
@@ -1095,18 +1108,10 @@ extern "C" {
    *   RE2.Replace("hello there", "hello", "howdy") #=> "howdy there"
    *   re2 = RE2.new("hel+o")
    *   RE2.Replace("hello there", re2, "yo")        #=> "yo there"
-   *   text = "Good morning"
-   *   RE2.Replace(text, "morn", "even")            #=> "Good evening"
-   *   text                                         #=> "Good evening"
    */
   static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
       VALUE rewrite) {
-
-    /* Look out for frozen strings. */
-    rb_check_frozen(str);
-
     UNUSED(self);
-    VALUE repl;
     re2_pattern *p;
 
     /* Convert all the inputs to be pumped into RE2::Replace. */
@@ -1116,71 +1121,53 @@ extern "C" {
     if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
       Data_Get_Struct(pattern, re2_pattern, p);
       RE2::Replace(&str_as_string, *p->pattern, StringValuePtr(rewrite));
+
+      return ENCODED_STR_NEW(str_as_string.data(), str_as_string.size(),
+          p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");
     } else {
       RE2::Replace(&str_as_string, StringValuePtr(pattern),
           StringValuePtr(rewrite));
-    }
 
-    /* Save the replacement as a VALUE. */
-    repl = rb_str_new(str_as_string.data(), str_as_string.size());
-
-    /* Replace the original string with the replacement. */
-    if (RSTRING_LEN(str) != RSTRING_LEN(repl)) {
-      rb_str_resize(str, RSTRING_LEN(repl));
+      return ENCODED_STR_NEW2(str_as_string.data(), str_as_string.size(),
+          pattern);
     }
-    memcpy(RSTRING_PTR(str), RSTRING_PTR(repl), RSTRING_LEN(repl));
 
-    return str;
   }
 
   /*
-   * Replaces every occurrence of +pattern+ in +str+ with
-   * +rewrite+ <i>in place</i>.
+   * Return a copy of +str+ with +pattern+ replaced by +rewrite+.
    *
    * @param [String] str the string to modify
    * @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
    * @param [String] rewrite the string to replace with
    * @return [String] the resulting string
    * @example
-   *   RE2.GlobalReplace("hello there", "e", "i")   #=> "hillo thiri"
    *   re2 = RE2.new("oo?")
    *   RE2.GlobalReplace("whoops-doops", re2, "e")  #=> "wheps-deps"
-   *   text = "Good morning"
-   *   RE2.GlobalReplace(text, "o", "ee")           #=> "Geeeed meerning"
-   *   text                                          #=> "Geeeed meerning"
+   *   RE2.GlobalReplace("hello there", "e", "i")   #=> "hillo thiri"
    */
   static VALUE re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern,
                                  VALUE rewrite) {
-
-    /* Look out for frozen strings. */
-    rb_check_frozen(str);
-
     UNUSED(self);
 
     /* Convert all the inputs to be pumped into RE2::GlobalReplace. */
     re2_pattern *p;
     string str_as_string(StringValuePtr(str));
-    VALUE repl;
 
     /* Do the replacement. */
     if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
       Data_Get_Struct(pattern, re2_pattern, p);
       RE2::GlobalReplace(&str_as_string, *p->pattern, StringValuePtr(rewrite));
+
+      return ENCODED_STR_NEW(str_as_string.data(), str_as_string.size(),
+          p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");
     } else {
       RE2::GlobalReplace(&str_as_string, StringValuePtr(pattern),
                          StringValuePtr(rewrite));
-    }
 
-    /* Save the replacement as a VALUE. */
-    repl = rb_str_new(str_as_string.data(), str_as_string.size());
-
-    /* Replace the original string with the replacement. */
-    if (RSTRING_LEN(str) != RSTRING_LEN(repl)) {
-      rb_str_resize(str, RSTRING_LEN(repl));
+      return ENCODED_STR_NEW2(str_as_string.data(), str_as_string.size(),
+          pattern);
     }
-    memcpy(RSTRING_PTR(str), RSTRING_PTR(repl), RSTRING_LEN(repl));
-
-    return str;
   }
 
   /*
@@ -1203,13 +1190,13 @@ extern "C" {
     re2_mRE2 = rb_define_module("RE2");
     re2_cRegexp = rb_define_class_under(re2_mRE2, "Regexp", rb_cObject);
     re2_cMatchData = rb_define_class_under(re2_mRE2, "MatchData", rb_cObject);
-    re2_cConsumer = rb_define_class_under(re2_mRE2, "Consumer", rb_cObject);
+    re2_cScanner = rb_define_class_under(re2_mRE2, "Scanner", rb_cObject);
 
     rb_define_alloc_func(re2_cRegexp, (VALUE (*)(VALUE))re2_regexp_allocate);
     rb_define_alloc_func(re2_cMatchData,
         (VALUE (*)(VALUE))re2_matchdata_allocate);
-    rb_define_alloc_func(re2_cConsumer,
-        (VALUE (*)(VALUE))re2_consumer_allocate);
+    rb_define_alloc_func(re2_cScanner,
+        (VALUE (*)(VALUE))re2_scanner_allocate);
 
     rb_define_method(re2_cMatchData, "string",
         RUBY_METHOD_FUNC(re2_matchdata_string), 0);
@@ -1227,14 +1214,14 @@ extern "C" {
     rb_define_method(re2_cMatchData, "inspect",
         RUBY_METHOD_FUNC(re2_matchdata_inspect), 0);
 
-    rb_define_method(re2_cConsumer, "string",
-        RUBY_METHOD_FUNC(re2_consumer_string), 0);
-    rb_define_method(re2_cConsumer, "regexp",
-        RUBY_METHOD_FUNC(re2_consumer_regexp), 0);
-    rb_define_method(re2_cConsumer, "consume",
-        RUBY_METHOD_FUNC(re2_consumer_consume), 0);
-    rb_define_method(re2_cConsumer, "rewind",
-        RUBY_METHOD_FUNC(re2_consumer_rewind), 0);
+    rb_define_method(re2_cScanner, "string",
+        RUBY_METHOD_FUNC(re2_scanner_string), 0);
+    rb_define_method(re2_cScanner, "regexp",
+        RUBY_METHOD_FUNC(re2_scanner_regexp), 0);
+    rb_define_method(re2_cScanner, "scan",
+        RUBY_METHOD_FUNC(re2_scanner_scan), 0);
+    rb_define_method(re2_cScanner, "rewind",
+        RUBY_METHOD_FUNC(re2_scanner_rewind), 0);
 
     rb_define_method(re2_cRegexp, "initialize",
         RUBY_METHOD_FUNC(re2_regexp_initialize), -1);
@@ -1259,7 +1246,8 @@ extern "C" {
         RUBY_METHOD_FUNC(re2_regexp_match_query), 1);
     rb_define_method(re2_cRegexp, "===",
         RUBY_METHOD_FUNC(re2_regexp_match_query), 1);
-    rb_define_method(re2_cRegexp, "consume", RUBY_METHOD_FUNC(re2_regexp_consume), 1);
+    rb_define_method(re2_cRegexp, "scan",
+        RUBY_METHOD_FUNC(re2_regexp_scan), 1);
     rb_define_method(re2_cRegexp, "to_s", RUBY_METHOD_FUNC(re2_regexp_to_s), 0);
     rb_define_method(re2_cRegexp, "to_str", RUBY_METHOD_FUNC(re2_regexp_to_s),
         0);

data/lib/re2.rb

@@ -1,7 +1,7 @@
 # re2 (http://github.com/mudge/re2)
 # Ruby bindings to re2, an "efficient, principled regular expression library"
 #
-# Copyright (c) 2010-2013, Paul Mucur (http://mudge.name)
+# Copyright (c) 2010-2014, Paul Mucur (http://mudge.name)
 # Released under the BSD Licence, please see LICENSE.txt
 require "re2.so"
-require "re2/consumer"
+require "re2/scanner"

data/lib/re2/{consumer.rb → scanner.rb}

@@ -1,10 +1,10 @@
 module RE2
-  class Consumer
+  class Scanner
     include Enumerable
 
     def each
       if block_given?
-        while matches = consume
+        while matches = scan
           yield matches
         end
       else

data/lib/re2/string.rb

@@ -1,7 +1,7 @@
 # re2 (http://github.com/mudge/re2)
 # Ruby bindings to re2, an "efficient, principled regular expression library"
 #
-# Copyright (c) 2010-2013, Paul Mucur (http://mudge.name)
+# Copyright (c) 2010-2014, Paul Mucur (http://mudge.name)
 # Released under the BSD Licence, please see LICENSE.txt
 
 require "re2"
@@ -9,21 +9,6 @@ require "re2"
 module RE2
   module String
 
-    # Replaces the first occurrence +pattern+ with +rewrite+ <i>in place</i>.
-    #
-    # @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
-    # @param [String] rewrite the string to replace with
-    # @example
-    #   "hello there".re2_sub!("hello", "howdy") #=> "howdy there"
-    #   re2 = RE2.new("hel+o")
-    #   "hello there".re2_sub!(re2, "yo")        #=> "yo there"
-    #   text = "Good morning"
-    #   text.re2_sub!("morn", "even")            #=> "Good evening"
-    #   text                                     #=> "Good evening"
-    def re2_sub!(*args)
-      RE2.Replace(self, *args)
-    end
-
     # Replaces the first occurrence +pattern+ with +rewrite+ and returns a new
     # string.
     #
@@ -37,22 +22,7 @@ module RE2
     #   text.re2_sub("morn", "even")            #=> "Good evening"
     #   text                                    #=> "Good morning"
     def re2_sub(*args)
-      dup.re2_sub!(*args)
-    end
-
-    # Replaces every occurrence of +pattern+ with +rewrite+ <i>in place</i>.
-    #
-    # @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
-    # @param [String] rewrite the string to replace with
-    # @example
-    #   "hello there".re2_gsub!("e", "i")   #=> "hillo thiri"
-    #   re2 = RE2.new("oo?")
-    #   "whoops-doops".re2_gsub!(re2, "e")  #=> "wheps-deps"
-    #   text = "Good morning"
-    #   text.re2_gsub!("o", "ee")           #=> "Geeeed meerning"
-    #   text                                #=> "Geeeed meerning"
-    def re2_gsub!(*args)
-      RE2.GlobalReplace(self, *args)
+      RE2.Replace(self, *args)
     end
 
     # Replaces every occurrence of +pattern+ with +rewrite+ and return a new string.
@@ -67,7 +37,7 @@ module RE2
     #   text.re2_gsub("o", "ee")           #=> "Geeeed meerning"
     #   text                               #=> "Good morning"
     def re2_gsub(*args)
-      dup.re2_gsub!(*args)
+      RE2.GlobalReplace(self, *args)
     end
 
     # Match the pattern and return either a boolean (if no submatches are required)

data/spec/re2/regexp_spec.rb

@@ -392,12 +392,12 @@ describe RE2::Regexp do
     end
   end
 
-  describe "#consume" do
-    it "returns a consumer" do
+  describe "#scan" do
+    it "returns a scanner" do
       r = RE2::Regexp.new('(\w+)')
-      consumer = r.consume("It is a truth universally acknowledged")
+      scanner = r.scan("It is a truth universally acknowledged")
 
-      consumer.must_be_instance_of(RE2::Consumer)
+      scanner.must_be_instance_of(RE2::Scanner)
     end
   end
 end

data/spec/re2/scanner_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+describe RE2::Scanner do
+  describe "#regexp" do
+    it "returns the original pattern for the scanner" do
+      re = RE2::Regexp.new('(\w+)')
+      scanner = re.scan("It is a truth")
+
+      scanner.regexp.must_be_same_as(re)
+    end
+  end
+
+  describe "#string" do
+    it "returns the original text for the scanner" do
+      re = RE2::Regexp.new('(\w+)')
+      text = "It is a truth"
+      scanner = re.scan(text)
+
+      scanner.string.must_be_same_as(text)
+    end
+  end
+
+  describe "#scan" do
+    it "returns the next array of matches" do
+      r = RE2::Regexp.new('(\w+)')
+      scanner = r.scan("It is a truth universally acknowledged")
+      scanner.scan.must_equal(["It"])
+      scanner.scan.must_equal(["is"])
+      scanner.scan.must_equal(["a"])
+      scanner.scan.must_equal(["truth"])
+      scanner.scan.must_equal(["universally"])
+      scanner.scan.must_equal(["acknowledged"])
+      scanner.scan.must_be_nil
+    end
+
+    it "returns an empty array if there are no capturing groups" do
+      r = RE2::Regexp.new('\w+')
+      scanner = r.scan("Foo bar")
+      scanner.scan.must_equal([])
+    end
+
+    it "returns nil if there is no match" do
+      r = RE2::Regexp.new('\d+')
+      scanner = r.scan("Foo bar")
+      scanner.scan.must_be_nil
+    end
+  end
+
+  it "is enumerable" do
+    r = RE2::Regexp.new('(\d)')
+    scanner = r.scan("There are 1 some 2 numbers 3")
+    scanner.must_be_kind_of(Enumerable)
+  end
+
+  describe "#each" do
+    it "yields each match" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("There are 1 some 2 numbers 3")
+      matches = []
+      scanner.each do |match|
+        matches << match
+      end
+
+      matches.must_equal([["1"], ["2"], ["3"]])
+    end
+
+    it "returns an enumerator when not given a block" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("There are 1 some 2 numbers 3")
+
+      # Prior to Ruby 1.9, Enumerator was within Enumerable.
+      if defined?(Enumerator)
+        scanner.each.must_be_kind_of(Enumerator)
+      elsif defined?(Enumerable::Enumerator)
+        scanner.each.must_be_kind_of(Enumerable::Enumerator)
+      end
+    end
+  end
+
+  describe "#rewind" do
+    it "resets any consumption" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("There are 1 some 2 numbers 3")
+      scanner.to_enum.first.must_equal(["1"])
+      scanner.to_enum.first.must_equal(["2"])
+      scanner.rewind
+      scanner.to_enum.first.must_equal(["1"])
+    end
+  end
+end

data/spec/re2/string_spec.rb

@@ -6,28 +6,6 @@ class String
 end
 
 describe RE2::String do
-  describe "#re2_sub!" do
-    it "delegates to RE2.Replace to perform replacement" do
-      "My name is Robert Paulson".re2_sub!('Robert', 'Crobert').must_equal("My name is Crobert Paulson")
-    end
-
-    it "does perform an in-place replacement" do
-      string = "My name is Robert Paulson"
-      string.re2_sub!('Robert', 'Crobert').must_be_same_as(string)
-    end
-  end
-
-  describe "#re2_gsub!" do
-    it "delegates to RE2.GlobalReplace to perform replacement" do
-      "My name is Robert Paulson".re2_gsub!('a', 'e').must_equal("My neme is Robert Peulson")
-    end
-
-    it "does perform an in-place replacement" do
-      string = "My name is Robert Paulson"
-      string.re2_gsub!('a', 'e').must_be_same_as(string)
-    end
-  end
-
   describe "#re2_sub" do
     it "delegates to RE2.Replace to perform replacement" do
       "My name is Robert Paulson".re2_sub('Robert', 'Crobert').must_equal("My name is Crobert Paulson")

data/spec/re2_spec.rb

@@ -14,11 +14,11 @@ describe RE2 do
       RE2.Replace("Good morning", "(?i)gOOD MORNING", "hi").must_equal("hi")
     end
 
-    it "performs replacements in-place" do
+    it "does not perform replacements in-place" do
       name = "Robert"
       replacement = RE2.Replace(name, "R", "Cr")
       replacement.must_equal("Crobert")
-      name.must_be_same_as(replacement)
+      name.wont_be_same_as(replacement)
     end
 
     it "supports passing an RE2::Regexp as the pattern" do
@@ -31,12 +31,6 @@ describe RE2 do
       RE2.Replace("Good morning", re, "hi").must_equal("hi")
     end
 
-    it "raises an error if the string is frozen" do
-      frozen_name = "Arnold".freeze
-
-      proc { RE2.Replace(frozen_name, "o", "a") }.must_raise(TypeError, RuntimeError)
-    end
-
     if String.method_defined?(:encoding)
       it "preserves the original string's encoding" do
         original = "Foo"
@@ -59,11 +53,11 @@ describe RE2 do
       RE2.GlobalReplace("Robert", "(?i)r", "w").must_equal("wobewt")
     end
 
-    it "performs replacement in-place" do
+    it "does not perform replacement in-place" do
       name = "Robert"
       replacement = RE2.GlobalReplace(name, "(?i)R", "w")
       replacement.must_equal("wobewt")
-      name.must_be_same_as(replacement)
+      name.wont_be_same_as(replacement)
     end
 
     it "supports passing an RE2::Regexp as the pattern" do
@@ -75,12 +69,6 @@ describe RE2 do
       re = RE2::Regexp.new('gOOD MORNING', :case_sensitive => false)
       RE2.GlobalReplace("Good morning Good morning", re, "hi").must_equal("hi hi")
     end
-
-    it "raises an error if the string is frozen" do
-      frozen_name = "Arnold".freeze
-
-      proc { RE2.GlobalReplace(frozen_name, "o", "a") }.must_raise(TypeError, RuntimeError)
-    end
   end
 
   describe "#QuoteMeta" do

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 0.6.0.pre
+  version: 0.6.0
 platform: ruby
 authors:
 - Paul Mucur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-15 00:00:00.000000000 Z
+date: 2014-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Ruby bindings to re2, "an efficient, principled regular expression library".
@@ -45,23 +45,24 @@ extensions:
 - ext/re2/extconf.rb
 extra_rdoc_files: []
 files:
+- LICENSE.txt
+- README.md
+- Rakefile
 - ext/re2/extconf.rb
 - ext/re2/re2.cc
 - lib/re2.rb
-- lib/re2/consumer.rb
+- lib/re2/scanner.rb
 - lib/re2/string.rb
-- LICENSE.txt
-- README.md
-- Rakefile
-- spec/spec_helper.rb
-- spec/re2_spec.rb
 - spec/kernel_spec.rb
-- spec/re2/regexp_spec.rb
 - spec/re2/match_data_spec.rb
+- spec/re2/regexp_spec.rb
+- spec/re2/scanner_spec.rb
 - spec/re2/string_spec.rb
-- spec/re2/consumer_spec.rb
+- spec/re2_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/mudge/re2
-licenses: []
+licenses:
+- BSD
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -69,17 +70,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Ruby bindings to re2.
@@ -90,4 +91,4 @@ test_files:
 - spec/re2/regexp_spec.rb
 - spec/re2/match_data_spec.rb
 - spec/re2/string_spec.rb
-- spec/re2/consumer_spec.rb
+- spec/re2/scanner_spec.rb

data/spec/re2/consumer_spec.rb

@@ -1,90 +0,0 @@
-require "spec_helper"
-
-describe RE2::Consumer do
-  describe "#regexp" do
-    it "returns the original pattern for the consumer" do
-      re = RE2::Regexp.new('(\w+)')
-      consumer = re.consume("It is a truth")
-
-      consumer.regexp.must_be_same_as(re)
-    end
-  end
-
-  describe "#string" do
-    it "returns the original text for the consumer" do
-      re = RE2::Regexp.new('(\w+)')
-      text = "It is a truth"
-      consumer = re.consume(text)
-
-      consumer.string.must_be_same_as(text)
-    end
-  end
-
-  describe "#consume" do
-    it "returns the next array of matches" do
-      r = RE2::Regexp.new('(\w+)')
-      consumer = r.consume("It is a truth universally acknowledged")
-      consumer.consume.must_equal(["It"])
-      consumer.consume.must_equal(["is"])
-      consumer.consume.must_equal(["a"])
-      consumer.consume.must_equal(["truth"])
-      consumer.consume.must_equal(["universally"])
-      consumer.consume.must_equal(["acknowledged"])
-      consumer.consume.must_be_nil
-    end
-
-    it "returns an empty array if there are no capturing groups" do
-      r = RE2::Regexp.new('\w+')
-      consumer = r.consume("Foo bar")
-      consumer.consume.must_equal([])
-    end
-
-    it "returns nil if there is no match" do
-      r = RE2::Regexp.new('\d+')
-      consumer = r.consume("Foo bar")
-      consumer.consume.must_be_nil
-    end
-  end
-
-  it "is enumerable" do
-    r = RE2::Regexp.new('(\d)')
-    consumer = r.consume("There are 1 some 2 numbers 3")
-    consumer.must_be_kind_of(Enumerable)
-  end
-
-  describe "#each" do
-    it "yields each match" do
-      r = RE2::Regexp.new('(\d)')
-      consumer = r.consume("There are 1 some 2 numbers 3")
-      matches = []
-      consumer.each do |match|
-        matches << match
-      end
-
-      matches.must_equal([["1"], ["2"], ["3"]])
-    end
-
-    it "returns an enumerator when not given a block" do
-      r = RE2::Regexp.new('(\d)')
-      consumer = r.consume("There are 1 some 2 numbers 3")
-
-      # Prior to Ruby 1.9, Enumerator was within Enumerable.
-      if defined?(Enumerator)
-        consumer.each.must_be_kind_of(Enumerator)
-      elsif defined?(Enumerable::Enumerator)
-        consumer.each.must_be_kind_of(Enumerable::Enumerator)
-      end
-    end
-  end
-
-  describe "#rewind" do
-    it "resets any consumption" do
-      r = RE2::Regexp.new('(\d)')
-      consumer = r.consume("There are 1 some 2 numbers 3")
-      consumer.to_enum.first.must_equal(["1"])
-      consumer.to_enum.first.must_equal(["2"])
-      consumer.rewind
-      consumer.to_enum.first.must_equal(["1"])
-    end
-  end
-end