re2 0.5.0 → 0.6.0.pre

checksums.yaml

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

data/LICENSE.txt

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

data/README.md

@@ -1,34 +1,45 @@
 re2 [![Build Status](https://secure.travis-ci.org/mudge/re2.png?branch=master)](http://travis-ci.org/mudge/re2)
 ===
 
-A Ruby binding to [re2][], an "efficient, principled regular expression library".
+A Ruby binding to [re2][], an "efficient, principled regular expression
+library".
 
 Installation
 ------------
 
-You will need [re2][] installed as well as a C++ compiler such as [gcc][] (on Debian and Ubuntu, this is provided by the [build-essential][] package). If you are using Mac OS X, I recommend installing re2 with [Homebrew][] by running the following:
+You will need [re2][] installed as well as a C++ compiler such as [gcc][] (on
+Debian and Ubuntu, this is provided by the [build-essential][] package). If
+you are using Mac OS X, I recommend installing re2 with [Homebrew][] by
+running the following:
 
-    $ brew install --HEAD re2
+    $ brew install re2
 
 If you are using Debian, you can install the [libre2-dev][] package like so:
 
     $ sudo apt-get install libre2-dev
 
-If you are using a packaged Ruby distribution, make sure you also have the Ruby header files installed such as those provided by the [ruby-dev][] package on Debian and Ubuntu.
+If you are using a packaged Ruby distribution, make sure you also have the
+Ruby header files installed such as those provided by the [ruby-dev][] package
+on Debian and Ubuntu.
 
-You can then install the library via RubyGems with `gem install re2` or `gem install re2 -- --with-re2-dir=/opt/local/re2` if re2 is not installed in the default location of `/usr/local/`.
+You can then install the library via RubyGems with `gem install re2` or `gem
+install re2 -- --with-re2-dir=/opt/local/re2` if re2 is not installed in the
+default location of `/usr/local/`.
 
 Documentation
 -------------
 
-Full documentation automatically generated from the latest version is available at <http://rubydoc.info/github/mudge/re2>.
+Full documentation automatically generated from the latest version is
+available at <http://rubydoc.info/github/mudge/re2>.
 
-Bear in mind that re2's regular expression syntax differs from PCRE, see the [official syntax page][] for more details.
+Bear in mind that re2's regular expression syntax differs from PCRE, see the
+[official syntax page][] for more details.
 
 Usage
 -----
 
-You can use re2 as a mostly drop-in replacement for Ruby's own [Regexp][] and [MatchData][] classes:
+You can use re2 as a mostly drop-in replacement for Ruby's own [Regexp][] and
+[MatchData][] classes:
 
 ```console
 $ irb -rubygems
@@ -49,14 +60,17 @@ $ irb -rubygems
 => nil
 ```
 
-As `RE2::Regexp.new` (or `RE2::Regexp.compile`) can be quite verbose, a helper method has been defined against `Kernel` so you can use a shorter version to create regular expressions:
+As `RE2::Regexp.new` (or `RE2::Regexp.compile`) can be quite verbose, a helper
+method has been defined against `Kernel` so you can use a shorter version to
+create regular expressions:
 
 ```console
 > RE2('(\d+)')
 => #<RE2::Regexp /(\d+)/>
 ```
 
-Note the use of *single quotes* as double quotes will interpret `\d` as `d` as in the following example:
+Note the use of *single quotes* as double quotes will interpret `\d` as `d` as
+in the following example:
 
 ```console
 > RE2("(\d+)")
@@ -76,7 +90,8 @@ 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:
+As of 0.4.0, you can mix `RE2::String` into strings to provide helpers from
+the opposite direction:
 
 ```console
 > require "re2/string"
@@ -102,28 +117,64 @@ class String
 end
 ```
 
+As of 0.5.0, you can use `RE2::Regexp#consume` 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
+[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|
+  puts match
+end
+
+consumer.rewind
+
+enum = consumer.to_enum
+enum.next #=> ["It"]
+enum.next #=> ["is"]
+```
+
 Features
 --------
 
-* Pre-compiling regular expressions with [`RE2::Regexp.new(re)`](http://code.google.com/p/re2/source/browse/re2/re2.h#96), `RE2::Regexp.compile(re)` or `RE2(re)` (including specifying options, e.g. `RE2::Regexp.new("pattern", :case_sensitive => false)`
+* Pre-compiling regular expressions with
+  [`RE2::Regexp.new(re)`](http://code.google.com/p/re2/source/browse/re2/re2.h#96),
+  `RE2::Regexp.compile(re)` or `RE2(re)` (including specifying options, e.g.
+  `RE2::Regexp.new("pattern", :case_sensitive => false)`
 
-* Extracting matches with `re2.match(text)` (and an exact number of matches with `re2.match(text, number_of_matches)` such as `re2.match("123-234", 2)`)
+* Extracting matches with `re2.match(text)` (and an exact number of matches
+  with `re2.match(text, number_of_matches)` such as `re2.match("123-234", 2)`)
 
 * Extracting matches by name (both with strings and symbols)
 
-* Checking for matches with `re2 =~ text`, `re2 === text` (for use in `case` statements) and `re2 !~ text`
+* Checking for matches with `re2 =~ text`, `re2 === text` (for use in `case`
+  statements) and `re2 !~ text`
 
-* Checking regular expression compilation with `re2.ok?`, `re2.error` and `re2.error_arg`
+* Incrementally scanning text with `re2.consume(text)`
+
+* Checking regular expression compilation with `re2.ok?`, `re2.error` and
+  `re2.error_arg`
 
 * Checking regular expression "cost" with `re2.program_size`
 
-* Checking the options for an expression with `re2.options` or individually with `re2.case_sensitive?`
+* 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 in-place replacement with [`RE2.Replace(str, pattern,
+  replace)`](http://code.google.com/p/re2/source/browse/re2/re2.h#335)
 
-* Performing in-place global replacement with [`RE2.GlobalReplace(str, pattern, replace)`](http://code.google.com/p/re2/source/browse/re2/re2.h#352)
+* Performing in-place global replacement with [`RE2.GlobalReplace(str,
+  pattern,
+  replace)`](http://code.google.com/p/re2/source/browse/re2/re2.h#352)
 
-* 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)`
+* 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)`
 
 Contact
 -------
@@ -139,3 +190,4 @@ All feedback should go to the mailing list: <mailto:ruby.re2@librelist.com>
   [Homebrew]: http://mxcl.github.com/homebrew
   [libre2-dev]: http://packages.debian.org/search?keywords=libre2-dev
   [official syntax page]: http://code.google.com/p/re2/wiki/Syntax
+

data/Rakefile

@@ -1,9 +1,7 @@
 require 'rake/extensiontask'
 require 'rake/testtask'
 
-Rake::ExtensionTask.new('re2') do |e|
-  # e.config_options << "--with-re2-dir=/opt/local/re2"
-end
+Rake::ExtensionTask.new('re2')
 
 Rake::TestTask.new do |t|
   t.libs << "spec"

data/ext/re2/re2.cc

@@ -2,18 +2,35 @@
  * re2 (http://github.com/mudge/re2)
  * Ruby bindings to re2, an "efficient, principled regular expression library"
  *
- * Copyright (c) 2010-2012, Paul Mucur (http://mudge.name)
+ * Copyright (c) 2010-2013, Paul Mucur (http://mudge.name)
  * Released under the BSD Licence, please see LICENSE.txt
  */
 
 #include <re2/re2.h>
+#include <ruby.h>
 #include <string>
 #include <sstream>
-using namespace std;
+#include <vector>
+using std::string;
+using std::ostringstream;
+using std::nothrow;
+using std::map;
+using std::vector;
 
 extern "C" {
-
-  #include <ruby.h>
+  #ifdef HAVE_RUBY_ENCODING_H
+    #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; \
+       })
+  #else
+    #define ENCODED_STR_NEW(str, length, encoding) \
+      rb_str_new((const char *)str, (long)length)
+  #endif
 
   #define BOOL2RUBY(v) (v ? Qtrue : Qfalse)
   #define UNUSED(x) ((void)x)
@@ -44,41 +61,57 @@ extern "C" {
     VALUE regexp, text;
   } re2_matchdata;
 
-  VALUE re2_mRE2, re2_cRegexp, re2_cMatchData;
+  typedef struct {
+    re2::StringPiece input;
+    int argc;
+    VALUE regexp, text;
+  } re2_consumer;
+
+  VALUE re2_mRE2, re2_cRegexp, re2_cMatchData, re2_cConsumer;
 
   /* Symbols used in RE2 options. */
   static ID id_utf8, id_posix_syntax, id_longest_match, id_log_errors,
             id_max_mem, id_literal, id_never_nl, id_case_sensitive,
             id_perl_classes, id_word_boundary, id_one_line;
 
-  void re2_matchdata_mark(re2_matchdata* self)
-  {
+  void re2_matchdata_mark(re2_matchdata* self) {
     rb_gc_mark(self->regexp);
     rb_gc_mark(self->text);
   }
 
-  void re2_matchdata_free(re2_matchdata* self)
-  {
+  void re2_matchdata_free(re2_matchdata* self) {
     if (self->matches) {
       delete[] self->matches;
     }
     free(self);
   }
 
-  void
-  re2_regexp_free(re2_pattern* self)
-  {
+  void re2_consumer_mark(re2_consumer* self) {
+    rb_gc_mark(self->regexp);
+    rb_gc_mark(self->text);
+  }
+
+  void re2_consumer_free(re2_consumer* self) {
+    free(self);
+  }
+
+  void re2_regexp_free(re2_pattern* self) {
     if (self->pattern) {
       delete self->pattern;
     }
     free(self);
   }
 
-  static VALUE
-  re2_matchdata_allocate(VALUE klass)
-  {
+  static VALUE re2_matchdata_allocate(VALUE klass) {
     re2_matchdata *m;
-    return Data_Make_Struct(klass, re2_matchdata, re2_matchdata_mark, re2_matchdata_free, m);
+    return Data_Make_Struct(klass, re2_matchdata, re2_matchdata_mark,
+        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);
   }
 
   /*
@@ -89,15 +122,95 @@ extern "C" {
    *   m = RE2::Regexp.new('(\d+)').match("bob 123")
    *   m.string  #=> "bob 123"
    */
-  static VALUE
-  re2_matchdata_string(VALUE self)
-  {
+  static VALUE re2_matchdata_string(VALUE self) {
     re2_matchdata *m;
     Data_Get_Struct(self, re2_matchdata, m);
 
     return m->text;
   }
 
+  /*
+   * Returns the string passed into the consumer.
+   *
+   * @return [String] the original string.
+   * @example
+   *   c = RE2::Regexp.new('(\d+)').consume("foo")
+   *   c.string #=> "foo"
+   */
+  static VALUE re2_consumer_string(VALUE self) {
+    re2_consumer *c;
+    Data_Get_Struct(self, re2_consumer, c);
+
+    return c->text;
+  }
+
+  /*
+   * Rewind the consumer 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"]
+   */
+  static VALUE re2_consumer_rewind(VALUE self) {
+    re2_consumer *c;
+    Data_Get_Struct(self, re2_consumer, c);
+    re2::StringPiece input(RSTRING_PTR(c->text));
+
+    c->input = input;
+
+    return self;
+  }
+
+  /*
+   * Scan the given text incrementally for matches, returning an array of
+   * matches on each subsequent call. Returns nil if no matches are found.
+   *
+   * @return [Array<String>] the matches.
+   * @example
+   *   c = RE2::Regexp.new('(\w+)').consume("Foo bar baz")
+   *   c.consume #=> ["Foo"]
+   *   c.consume #=> ["bar"]
+   */
+  static VALUE re2_consumer_consume(VALUE self) {
+    int i;
+    re2_pattern *p;
+    re2_consumer *c;
+    VALUE result;
+
+    Data_Get_Struct(self, re2_consumer, 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);
+
+    for (i = 0; i < c->argc; i++) {
+      args[i] = &argv[i];
+      argv[i] = &matches[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 (matches[i].empty()) {
+          rb_ary_push(result, Qnil);
+        } else {
+          rb_ary_push(result, ENCODED_STR_NEW(matches[i].data(),
+                matches[i].size(),
+                p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1"));
+        }
+      }
+    } else {
+      result = Qnil;
+    }
+
+    return result;
+  }
+
   /*
    * Returns the number of elements in the match array (including nils).
    *
@@ -107,9 +220,7 @@ extern "C" {
    *   m.size      #=> 2
    *   m.length    #=> 2
    */
-  static VALUE
-  re2_matchdata_size(VALUE self)
-  {
+  static VALUE re2_matchdata_size(VALUE self) {
     re2_matchdata *m;
     Data_Get_Struct(self, re2_matchdata, m);
 
@@ -124,17 +235,28 @@ extern "C" {
    *   m = RE2::Regexp.new('(\d+)').match("bob 123")
    *   m.regexp    #=> #<RE2::Regexp /(\d+)/>
    */
-  static VALUE
-  re2_matchdata_regexp(VALUE self)
-  {
+  static VALUE re2_matchdata_regexp(VALUE self) {
     re2_matchdata *m;
     Data_Get_Struct(self, re2_matchdata, m);
     return m->regexp;
   }
 
-  static VALUE
-  re2_regexp_allocate(VALUE klass)
-  {
+  /*
+   * Returns the {RE2::Regexp} used in the consumer.
+   *
+   * @return [RE2::Regexp] the regexp used in the consumer
+   * @example
+   *   c = RE2::Regexp.new('(\d+)').consume("bob 123")
+   *   c.regexp    #=> #<RE2::Regexp /(\d+)/>
+   */
+  static VALUE re2_consumer_regexp(VALUE self) {
+    re2_consumer *c;
+    Data_Get_Struct(self, re2_consumer, c);
+
+    return c->regexp;
+  }
+
+  static VALUE re2_regexp_allocate(VALUE klass) {
     re2_pattern *p;
     return Data_Make_Struct(klass, re2_pattern, 0, re2_regexp_free, p);
   }
@@ -147,15 +269,15 @@ extern "C" {
    *   m = RE2::Regexp.new('(\d+)').match("bob 123")
    *   m.to_a    #=> ["123", "123"]
    */
-  static VALUE
-  re2_matchdata_to_a(VALUE self)
-  {
+  static VALUE re2_matchdata_to_a(VALUE self) {
     int i;
     re2_matchdata *m;
+    re2_pattern *p;
     re2::StringPiece match;
     VALUE array;
 
     Data_Get_Struct(self, re2_matchdata, m);
+    Data_Get_Struct(m->regexp, re2_pattern, p);
 
     array = rb_ary_new2(m->number_of_matches);
     for (i = 0; i < m->number_of_matches; i++) {
@@ -163,20 +285,21 @@ extern "C" {
         rb_ary_push(array, Qnil);
       } else {
         match = m->matches[i];
-        rb_ary_push(array, rb_str_new(match.data(), match.size()));
+        rb_ary_push(array, ENCODED_STR_NEW(match.data(), match.size(),
+              p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1"));
       }
     }
 
     return array;
   }
 
-  static VALUE
-  re2_matchdata_nth_match(int nth, VALUE self)
-  {
+  static VALUE re2_matchdata_nth_match(int nth, VALUE self) {
     re2_matchdata *m;
+    re2_pattern *p;
     re2::StringPiece match;
 
     Data_Get_Struct(self, re2_matchdata, m);
+    Data_Get_Struct(m->regexp, re2_pattern, p);
 
     if (nth < 0 || nth >= m->number_of_matches) {
       return Qnil;
@@ -186,14 +309,13 @@ extern "C" {
       if (match.empty()) {
         return Qnil;
       } else {
-        return rb_str_new(match.data(), match.size());
+        return ENCODED_STR_NEW(match.data(), match.size(),
+            p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");
       }
     }
   }
 
-  static VALUE
-  re2_matchdata_named_match(const char* name, VALUE self)
-  {
+  static VALUE re2_matchdata_named_match(const char* name, VALUE self) {
     int idx;
     re2_matchdata *m;
     re2_pattern *p;
@@ -256,9 +378,7 @@ extern "C" {
    *     m["number"] #=> "123"
    *     m[:number]  #=> "123"
    */
-  static VALUE
-  re2_matchdata_aref(int argc, VALUE *argv, VALUE self)
-  {
+  static VALUE re2_matchdata_aref(int argc, VALUE *argv, VALUE self) {
     VALUE idx, rest;
     rb_scan_args(argc, argv, "11", &idx, &rest);
 
@@ -278,9 +398,7 @@ extern "C" {
    *
    * @return [String] the entire matched string
    */
-  static VALUE
-  re2_matchdata_to_s(VALUE self)
-  {
+  static VALUE re2_matchdata_to_s(VALUE self) {
     return re2_matchdata_nth_match(0, self);
   }
 
@@ -292,17 +410,15 @@ extern "C" {
    *   m = RE2::Regexp.new('(\d+)').match("bob 123")
    *   m.inspect    #=> "#<RE2::MatchData \"123\" 1:\"123\">"
    */
-  static VALUE
-  re2_matchdata_inspect(VALUE self)
-  {
+  static VALUE re2_matchdata_inspect(VALUE self) {
     int i;
     re2_matchdata *m;
+    re2_pattern *p;
     VALUE match, result;
     ostringstream output;
 
     Data_Get_Struct(self, re2_matchdata, m);
-
-    result = rb_str_new("#<RE2::MatchData", 16);
+    Data_Get_Struct(m->regexp, re2_pattern, p);
 
     output << "#<RE2::MatchData";
 
@@ -324,7 +440,8 @@ extern "C" {
 
     output << ">";
 
-    result = rb_str_new(output.str().data(), output.str().length());
+    result = ENCODED_STR_NEW(output.str().data(), output.str().length(),
+        p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");
 
     return result;
   }
@@ -339,9 +456,7 @@ extern "C" {
    * @see RE2::Regexp.new
    *
    */
-  static VALUE
-  re2_re2(int argc, VALUE *argv, VALUE self)
-  {
+  static VALUE re2_re2(int argc, VALUE *argv, VALUE self) {
     UNUSED(self);
     return rb_class_new_instance(argc, argv, re2_cRegexp);
   }
@@ -358,7 +473,8 @@ extern "C" {
    *
    *   @param [String] pattern the pattern to compile
    *   @return [RE2::Regexp] an RE2::Regexp with the specified pattern
-   *   @raise [NoMemoryError] if memory could not be allocated for the compiled pattern
+   *   @raise [NoMemoryError] if memory could not be allocated for the compiled
+   *                          pattern
    *
    * @overload initialize(pattern, options)
    *   Returns a new {RE2::Regexp} object with a compiled version of
@@ -380,11 +496,9 @@ extern "C" {
    *   @return [RE2::Regexp] an RE2::Regexp with the specified pattern and options
    *   @raise [NoMemoryError] if memory could not be allocated for the compiled pattern
    */
-  static VALUE
-  re2_regexp_initialize(int argc, VALUE *argv, VALUE self)
-  {
+  static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
     VALUE pattern, options, utf8, posix_syntax, longest_match, log_errors,
-          max_mem, literal, never_nl, case_sensitive, perl_classes, 
+          max_mem, literal, never_nl, case_sensitive, perl_classes,
           word_boundary, one_line;
     re2_pattern *p;
 
@@ -453,9 +567,9 @@ extern "C" {
         re2_options.set_one_line(RTEST(one_line));
       }
 
-      p->pattern = new (nothrow) RE2(StringValuePtr(pattern), re2_options);
+      p->pattern = new(nothrow) RE2(StringValuePtr(pattern), re2_options);
     } else {
-      p->pattern = new (nothrow) RE2(StringValuePtr(pattern));
+      p->pattern = new(nothrow) RE2(StringValuePtr(pattern));
     }
 
     if (p->pattern == 0) {
@@ -473,9 +587,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?")
    *   re2.inspect    #=> "#<RE2::Regexp /woo?/>"
    */
-  static VALUE
-  re2_regexp_inspect(VALUE self)
-  {
+  static VALUE re2_regexp_inspect(VALUE self) {
     re2_pattern *p;
     VALUE result;
     ostringstream output;
@@ -484,7 +596,8 @@ extern "C" {
 
     output << "#<RE2::Regexp /" << p->pattern->pattern() << "/>";
 
-    result = rb_str_new(output.str().data(), output.str().length());
+    result = ENCODED_STR_NEW(output.str().data(), output.str().length(),
+        p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");
 
     return result;
   }
@@ -497,12 +610,12 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?")
    *   re2.to_s    #=> "woo?"
    */
-  static VALUE
-  re2_regexp_to_s(VALUE self)
-  {
+  static VALUE re2_regexp_to_s(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
-    return rb_str_new(p->pattern->pattern().data(), p->pattern->pattern().size());
+    return ENCODED_STR_NEW(p->pattern->pattern().data(),
+        p->pattern->pattern().size(),
+        p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");
   }
 
   /*
@@ -514,9 +627,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?")
    *   re2.ok?    #=> true
    */
-  static VALUE
-  re2_regexp_ok(VALUE self)
-  {
+  static VALUE re2_regexp_ok(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return BOOL2RUBY(p->pattern->ok());
@@ -531,9 +642,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?", :utf8 => true)
    *   re2.utf8?    #=> true
    */
-  static VALUE
-  re2_regexp_utf8(VALUE self)
-  {
+  static VALUE re2_regexp_utf8(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return BOOL2RUBY(p->pattern->options().utf8());
@@ -548,9 +657,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?", :posix_syntax => true)
    *   re2.posix_syntax?    #=> true
    */
-  static VALUE
-  re2_regexp_posix_syntax(VALUE self)
-  {
+  static VALUE re2_regexp_posix_syntax(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return BOOL2RUBY(p->pattern->options().posix_syntax());
@@ -565,9 +672,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?", :longest_match => true)
    *   re2.longest_match?    #=> true
    */
-  static VALUE
-  re2_regexp_longest_match(VALUE self)
-  {
+  static VALUE re2_regexp_longest_match(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return BOOL2RUBY(p->pattern->options().longest_match());
@@ -582,9 +687,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?", :log_errors => true)
    *   re2.log_errors?    #=> true
    */
-  static VALUE
-  re2_regexp_log_errors(VALUE self)
-  {
+  static VALUE re2_regexp_log_errors(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return BOOL2RUBY(p->pattern->options().log_errors());
@@ -599,9 +702,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?", :max_mem => 1024)
    *   re2.max_mem    #=> 1024
    */
-  static VALUE
-  re2_regexp_max_mem(VALUE self)
-  {
+  static VALUE re2_regexp_max_mem(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return INT2FIX(p->pattern->options().max_mem());
@@ -616,9 +717,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?", :literal => true)
    *   re2.literal?    #=> true
    */
-  static VALUE
-  re2_regexp_literal(VALUE self)
-  {
+  static VALUE re2_regexp_literal(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return BOOL2RUBY(p->pattern->options().literal());
@@ -633,9 +732,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?", :never_nl => true)
    *   re2.never_nl?    #=> true
    */
-  static VALUE
-  re2_regexp_never_nl(VALUE self)
-  {
+  static VALUE re2_regexp_never_nl(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return BOOL2RUBY(p->pattern->options().never_nl());
@@ -650,9 +747,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?", :case_sensitive => true)
    *   re2.case_sensitive?    #=> true
    */
-  static VALUE
-  re2_regexp_case_sensitive(VALUE self)
-  {
+  static VALUE re2_regexp_case_sensitive(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return BOOL2RUBY(p->pattern->options().case_sensitive());
@@ -668,9 +763,7 @@ extern "C" {
    *   re2.case_insensitive?    #=> false
    *   re2.casefold?    #=> false
    */
-  static VALUE
-  re2_regexp_case_insensitive(VALUE self)
-  {
+  static VALUE re2_regexp_case_insensitive(VALUE self) {
     return BOOL2RUBY(re2_regexp_case_sensitive(self) != Qtrue);
   }
 
@@ -683,9 +776,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?", :perl_classes => true)
    *   re2.perl_classes?    #=> true
    */
-  static VALUE
-  re2_regexp_perl_classes(VALUE self)
-  {
+  static VALUE re2_regexp_perl_classes(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return BOOL2RUBY(p->pattern->options().perl_classes());
@@ -700,9 +791,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?", :word_boundary => true)
    *   re2.word_boundary?    #=> true
    */
-  static VALUE
-  re2_regexp_word_boundary(VALUE self)
-  {
+  static VALUE re2_regexp_word_boundary(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return BOOL2RUBY(p->pattern->options().word_boundary());
@@ -717,9 +806,7 @@ extern "C" {
    *   re2 = RE2::Regexp.new("woo?", :one_line => true)
    *   re2.one_line?    #=> true
    */
-  static VALUE
-  re2_regexp_one_line(VALUE self)
-  {
+  static VALUE re2_regexp_one_line(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return BOOL2RUBY(p->pattern->options().one_line());
@@ -731,9 +818,7 @@ extern "C" {
    *
    * @return [String, nil] the error string or nil
    */
-  static VALUE
-  re2_regexp_error(VALUE self)
-  {
+  static VALUE re2_regexp_error(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     if (p->pattern->ok()) {
@@ -749,15 +834,15 @@ extern "C" {
    *
    * @return [String, nil] the offending portion of the regexp or nil
    */
-  static VALUE
-  re2_regexp_error_arg(VALUE self)
-  {
+  static VALUE re2_regexp_error_arg(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     if (p->pattern->ok()) {
       return Qnil;
     } else {
-      return rb_str_new(p->pattern->error_arg().data(), p->pattern->error_arg().size());
+      return ENCODED_STR_NEW(p->pattern->error_arg().data(),
+          p->pattern->error_arg().size(),
+          p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");
     }
   }
 
@@ -768,9 +853,7 @@ extern "C" {
    *
    * @return [Fixnum] the regexp "cost"
    */
-  static VALUE
-  re2_regexp_program_size(VALUE self)
-  {
+  static VALUE re2_regexp_program_size(VALUE self) {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
     return INT2FIX(p->pattern->ProgramSize());
@@ -782,9 +865,7 @@ extern "C" {
    *
    * @return [Hash] the options
    */
-  static VALUE
-  re2_regexp_options(VALUE self)
-  {
+  static VALUE re2_regexp_options(VALUE self) {
     VALUE options;
     re2_pattern *p;
 
@@ -837,9 +918,7 @@ extern "C" {
    *
    * @return [Fixnum] the number of capturing subpatterns
    */
-  static VALUE
-  re2_regexp_number_of_capturing_groups(VALUE self)
-  {
+  static VALUE re2_regexp_number_of_capturing_groups(VALUE self) {
     re2_pattern *p;
 
     Data_Get_Struct(self, re2_pattern, p);
@@ -851,9 +930,7 @@ extern "C" {
    *
    * @return [Hash] a hash of names to capturing indices
    */
-  static VALUE
-  re2_regexp_named_capturing_groups(VALUE self)
-  {
+  static VALUE re2_regexp_named_capturing_groups(VALUE self) {
     VALUE capturing_groups;
     re2_pattern *p;
     map<string, int> groups;
@@ -865,7 +942,8 @@ extern "C" {
 
     for (iterator = groups.begin(); iterator != groups.end(); iterator++) {
       rb_hash_aset(capturing_groups,
-          rb_str_new(iterator->first.data(), iterator->first.size()),
+          ENCODED_STR_NEW(iterator->first.data(), iterator->first.size(),
+            p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1"),
           INT2FIX(iterator->second));
     }
 
@@ -916,9 +994,7 @@ extern "C" {
    *     r.match('woo', 1) #=> #<RE2::MatchData "woo" 1:"o">
    *     r.match('woo', 3) #=> #<RE2::MatchData "woo" 1:"o" 2:"o" 3:nil>
    */
-  static VALUE
-  re2_regexp_match(int argc, VALUE *argv, VALUE self)
-  {
+  static VALUE re2_regexp_match(int argc, VALUE *argv, VALUE self) {
     int n;
     bool matched;
     re2_pattern *p;
@@ -936,7 +1012,8 @@ extern "C" {
     }
 
     if (n == 0) {
-      matched = match(p->pattern, StringValuePtr(text), 0, (int)RSTRING_LEN(text), RE2::UNANCHORED, 0, 0);
+      matched = match(p->pattern, StringValuePtr(text), 0,
+          static_cast<int>(RSTRING_LEN(text)), RE2::UNANCHORED, 0, 0);
       return BOOL2RUBY(matched);
     } else {
 
@@ -945,18 +1022,21 @@ extern "C" {
 
       matchdata = rb_class_new_instance(0, 0, re2_cMatchData);
       Data_Get_Struct(matchdata, re2_matchdata, m);
-      m->matches = new (nothrow) re2::StringPiece[n];
+      m->matches = new(nothrow) re2::StringPiece[n];
       m->regexp = self;
       m->text = rb_str_dup(text);
       rb_str_freeze(m->text);
 
       if (m->matches == 0) {
-        rb_raise(rb_eNoMemError, "not enough memory to allocate StringPieces for matches");
+        rb_raise(rb_eNoMemError,
+                 "not enough memory to allocate StringPieces for matches");
       }
 
       m->number_of_matches = n;
 
-      matched = match(p->pattern, StringValuePtr(text), 0, (int)RSTRING_LEN(text), RE2::UNANCHORED, m->matches, n);
+      matched = match(p->pattern, StringValuePtr(text), 0,
+                      static_cast<int>(RSTRING_LEN(text)),
+                      RE2::UNANCHORED, m->matches, n);
 
       if (matched) {
         return matchdata;
@@ -972,9 +1052,7 @@ extern "C" {
    *
    * @return [Boolean] whether the match was successful
    */
-  static VALUE
-  re2_regexp_match_query(VALUE self, VALUE text)
-  {
+  static VALUE re2_regexp_match_query(VALUE self, VALUE text) {
     VALUE argv[2];
     argv[0] = text;
     argv[1] = INT2FIX(0);
@@ -983,7 +1061,30 @@ extern "C" {
   }
 
   /*
-   * Replaces the first occurrence +pattern+ in +str+ with 
+   * Returns a {RE2::Consumer} for scanning the given text incrementally.
+   *
+   * @example
+   *   c = RE2::Regexp.new('(\w+)').consume("Foo bar baz")
+   */
+  static VALUE re2_regexp_consume(VALUE self, VALUE text) {
+    re2_pattern *p;
+    re2_consumer *c;
+    VALUE consumer;
+    re2::StringPiece input(RSTRING_PTR(text));
+
+    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;
+    c->regexp = self;
+    c->text = text;
+    c->argc = p->pattern->NumberOfCapturingGroups();
+
+    return consumer;
+  }
+
+  /*
+   * Replaces the first occurrence +pattern+ in +str+ with
    * +rewrite+ <i>in place</i>.
    *
    * @param [String] str the string to modify
@@ -996,11 +1097,10 @@ extern "C" {
    *   RE2.Replace("hello there", re2, "yo")        #=> "yo there"
    *   text = "Good morning"
    *   RE2.Replace(text, "morn", "even")            #=> "Good evening"
-   *   text                                          #=> "Good evening"
+   *   text                                         #=> "Good evening"
    */
-  static VALUE
-  re2_Replace(VALUE self, VALUE str, VALUE pattern, VALUE rewrite)
-  {
+  static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
+      VALUE rewrite) {
 
     /* Look out for frozen strings. */
     rb_check_frozen(str);
@@ -1017,7 +1117,8 @@ extern "C" {
       Data_Get_Struct(pattern, re2_pattern, p);
       RE2::Replace(&str_as_string, *p->pattern, StringValuePtr(rewrite));
     } else {
-      RE2::Replace(&str_as_string, StringValuePtr(pattern), StringValuePtr(rewrite));
+      RE2::Replace(&str_as_string, StringValuePtr(pattern),
+          StringValuePtr(rewrite));
     }
 
     /* Save the replacement as a VALUE. */
@@ -1033,7 +1134,7 @@ extern "C" {
   }
 
   /*
-   * Replaces every occurrence of +pattern+ in +str+ with 
+   * Replaces every occurrence of +pattern+ in +str+ with
    * +rewrite+ <i>in place</i>.
    *
    * @param [String] str the string to modify
@@ -1048,9 +1149,8 @@ extern "C" {
    *   RE2.GlobalReplace(text, "o", "ee")           #=> "Geeeed meerning"
    *   text                                          #=> "Geeeed meerning"
    */
-  static VALUE
-  re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern, VALUE rewrite)
-  {
+  static VALUE re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern,
+                                 VALUE rewrite) {
 
     /* Look out for frozen strings. */
     rb_check_frozen(str);
@@ -1067,7 +1167,8 @@ extern "C" {
       Data_Get_Struct(pattern, re2_pattern, p);
       RE2::GlobalReplace(&str_as_string, *p->pattern, StringValuePtr(rewrite));
     } else {
-      RE2::GlobalReplace(&str_as_string, StringValuePtr(pattern), StringValuePtr(rewrite));
+      RE2::GlobalReplace(&str_as_string, StringValuePtr(pattern),
+                         StringValuePtr(rewrite));
     }
 
     /* Save the replacement as a VALUE. */
@@ -1092,70 +1193,121 @@ extern "C" {
    * @example
    *   RE2::Regexp.escape("1.5-2.0?")    #=> "1\.5\-2\.0\?"
    */
-  static VALUE
-  re2_QuoteMeta(VALUE self, VALUE unquoted)
-  {
+  static VALUE re2_QuoteMeta(VALUE self, VALUE unquoted) {
     UNUSED(self);
     string quoted_string = RE2::QuoteMeta(StringValuePtr(unquoted));
     return rb_str_new(quoted_string.data(), quoted_string.size());
   }
 
-  void
-  Init_re2()
-  {
+  void Init_re2(void) {
     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);
 
     rb_define_alloc_func(re2_cRegexp, (VALUE (*)(VALUE))re2_regexp_allocate);
-    rb_define_alloc_func(re2_cMatchData, (VALUE (*)(VALUE))re2_matchdata_allocate);
-
-    rb_define_method(re2_cMatchData, "string", RUBY_METHOD_FUNC(re2_matchdata_string), 0);
-    rb_define_method(re2_cMatchData, "regexp", RUBY_METHOD_FUNC(re2_matchdata_regexp), 0);
-    rb_define_method(re2_cMatchData, "to_a", RUBY_METHOD_FUNC(re2_matchdata_to_a), 0);
-    rb_define_method(re2_cMatchData, "size", RUBY_METHOD_FUNC(re2_matchdata_size), 0);
-    rb_define_method(re2_cMatchData, "length", RUBY_METHOD_FUNC(re2_matchdata_size), 0);
-    rb_define_method(re2_cMatchData, "[]", RUBY_METHOD_FUNC(re2_matchdata_aref), -1);
-    rb_define_method(re2_cMatchData, "to_s", RUBY_METHOD_FUNC(re2_matchdata_to_s), 0);
-    rb_define_method(re2_cMatchData, "inspect", RUBY_METHOD_FUNC(re2_matchdata_inspect), 0);
-
-    rb_define_method(re2_cRegexp, "initialize", RUBY_METHOD_FUNC(re2_regexp_initialize), -1);
+    rb_define_alloc_func(re2_cMatchData,
+        (VALUE (*)(VALUE))re2_matchdata_allocate);
+    rb_define_alloc_func(re2_cConsumer,
+        (VALUE (*)(VALUE))re2_consumer_allocate);
+
+    rb_define_method(re2_cMatchData, "string",
+        RUBY_METHOD_FUNC(re2_matchdata_string), 0);
+    rb_define_method(re2_cMatchData, "regexp",
+        RUBY_METHOD_FUNC(re2_matchdata_regexp), 0);
+    rb_define_method(re2_cMatchData, "to_a",
+        RUBY_METHOD_FUNC(re2_matchdata_to_a), 0);
+    rb_define_method(re2_cMatchData, "size",
+        RUBY_METHOD_FUNC(re2_matchdata_size), 0);
+    rb_define_method(re2_cMatchData, "length",
+        RUBY_METHOD_FUNC(re2_matchdata_size), 0);
+    rb_define_method(re2_cMatchData, "[]", RUBY_METHOD_FUNC(re2_matchdata_aref),
+        -1); rb_define_method(re2_cMatchData, "to_s",
+          RUBY_METHOD_FUNC(re2_matchdata_to_s), 0);
+    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_cRegexp, "initialize",
+        RUBY_METHOD_FUNC(re2_regexp_initialize), -1);
     rb_define_method(re2_cRegexp, "ok?", RUBY_METHOD_FUNC(re2_regexp_ok), 0);
-    rb_define_method(re2_cRegexp, "error", RUBY_METHOD_FUNC(re2_regexp_error), 0);
-    rb_define_method(re2_cRegexp, "error_arg", RUBY_METHOD_FUNC(re2_regexp_error_arg), 0);
-    rb_define_method(re2_cRegexp, "program_size", RUBY_METHOD_FUNC(re2_regexp_program_size), 0);
-    rb_define_method(re2_cRegexp, "options", RUBY_METHOD_FUNC(re2_regexp_options), 0);
-    rb_define_method(re2_cRegexp, "number_of_capturing_groups", RUBY_METHOD_FUNC(re2_regexp_number_of_capturing_groups), 0);
-    rb_define_method(re2_cRegexp, "named_capturing_groups", RUBY_METHOD_FUNC(re2_regexp_named_capturing_groups), 0);
-    rb_define_method(re2_cRegexp, "match", RUBY_METHOD_FUNC(re2_regexp_match), -1);
-    rb_define_method(re2_cRegexp, "match?", 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, "===", RUBY_METHOD_FUNC(re2_regexp_match_query), 1);
+    rb_define_method(re2_cRegexp, "error", RUBY_METHOD_FUNC(re2_regexp_error),
+        0);
+    rb_define_method(re2_cRegexp, "error_arg",
+        RUBY_METHOD_FUNC(re2_regexp_error_arg), 0);
+    rb_define_method(re2_cRegexp, "program_size",
+        RUBY_METHOD_FUNC(re2_regexp_program_size), 0);
+    rb_define_method(re2_cRegexp, "options",
+        RUBY_METHOD_FUNC(re2_regexp_options), 0);
+    rb_define_method(re2_cRegexp, "number_of_capturing_groups",
+        RUBY_METHOD_FUNC(re2_regexp_number_of_capturing_groups), 0);
+    rb_define_method(re2_cRegexp, "named_capturing_groups",
+        RUBY_METHOD_FUNC(re2_regexp_named_capturing_groups), 0);
+    rb_define_method(re2_cRegexp, "match", RUBY_METHOD_FUNC(re2_regexp_match),
+        -1);
+    rb_define_method(re2_cRegexp, "match?",
+        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, "===",
+        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, "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);
-    rb_define_method(re2_cRegexp, "pattern", RUBY_METHOD_FUNC(re2_regexp_to_s), 0);
-    rb_define_method(re2_cRegexp, "source", RUBY_METHOD_FUNC(re2_regexp_to_s), 0);
-    rb_define_method(re2_cRegexp, "inspect", RUBY_METHOD_FUNC(re2_regexp_inspect), 0);
-    rb_define_method(re2_cRegexp, "utf8?", RUBY_METHOD_FUNC(re2_regexp_utf8), 0);
-    rb_define_method(re2_cRegexp, "posix_syntax?", RUBY_METHOD_FUNC(re2_regexp_posix_syntax), 0);
-    rb_define_method(re2_cRegexp, "longest_match?", RUBY_METHOD_FUNC(re2_regexp_longest_match), 0);
-    rb_define_method(re2_cRegexp, "log_errors?", RUBY_METHOD_FUNC(re2_regexp_log_errors), 0);
-    rb_define_method(re2_cRegexp, "max_mem", RUBY_METHOD_FUNC(re2_regexp_max_mem), 0);
-    rb_define_method(re2_cRegexp, "literal?", RUBY_METHOD_FUNC(re2_regexp_literal), 0);
-    rb_define_method(re2_cRegexp, "never_nl?", RUBY_METHOD_FUNC(re2_regexp_never_nl), 0);
-    rb_define_method(re2_cRegexp, "case_sensitive?", RUBY_METHOD_FUNC(re2_regexp_case_sensitive), 0);
-    rb_define_method(re2_cRegexp, "case_insensitive?", RUBY_METHOD_FUNC(re2_regexp_case_insensitive), 0);
-    rb_define_method(re2_cRegexp, "casefold?", RUBY_METHOD_FUNC(re2_regexp_case_insensitive), 0);
-    rb_define_method(re2_cRegexp, "perl_classes?", RUBY_METHOD_FUNC(re2_regexp_perl_classes), 0);
-    rb_define_method(re2_cRegexp, "word_boundary?", RUBY_METHOD_FUNC(re2_regexp_word_boundary), 0);
-    rb_define_method(re2_cRegexp, "one_line?", RUBY_METHOD_FUNC(re2_regexp_one_line), 0);
-
-    rb_define_module_function(re2_mRE2, "Replace", RUBY_METHOD_FUNC(re2_Replace), 3);
-    rb_define_module_function(re2_mRE2, "GlobalReplace", RUBY_METHOD_FUNC(re2_GlobalReplace), 3);
-    rb_define_module_function(re2_mRE2, "QuoteMeta", RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
-    rb_define_singleton_method(re2_cRegexp, "escape", RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
-    rb_define_singleton_method(re2_cRegexp, "quote", RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
-    rb_define_singleton_method(re2_cRegexp, "compile", RUBY_METHOD_FUNC(rb_class_new_instance), -1);
+    rb_define_method(re2_cRegexp, "to_str", RUBY_METHOD_FUNC(re2_regexp_to_s),
+        0);
+    rb_define_method(re2_cRegexp, "pattern", RUBY_METHOD_FUNC(re2_regexp_to_s),
+        0);
+    rb_define_method(re2_cRegexp, "source", RUBY_METHOD_FUNC(re2_regexp_to_s),
+        0);
+    rb_define_method(re2_cRegexp, "inspect",
+        RUBY_METHOD_FUNC(re2_regexp_inspect), 0);
+    rb_define_method(re2_cRegexp, "utf8?", RUBY_METHOD_FUNC(re2_regexp_utf8),
+        0);
+    rb_define_method(re2_cRegexp, "posix_syntax?",
+        RUBY_METHOD_FUNC(re2_regexp_posix_syntax), 0);
+    rb_define_method(re2_cRegexp, "longest_match?",
+        RUBY_METHOD_FUNC(re2_regexp_longest_match), 0);
+    rb_define_method(re2_cRegexp, "log_errors?",
+        RUBY_METHOD_FUNC(re2_regexp_log_errors), 0);
+    rb_define_method(re2_cRegexp, "max_mem",
+        RUBY_METHOD_FUNC(re2_regexp_max_mem), 0);
+    rb_define_method(re2_cRegexp, "literal?",
+        RUBY_METHOD_FUNC(re2_regexp_literal), 0);
+    rb_define_method(re2_cRegexp, "never_nl?",
+        RUBY_METHOD_FUNC(re2_regexp_never_nl), 0);
+    rb_define_method(re2_cRegexp, "case_sensitive?",
+        RUBY_METHOD_FUNC(re2_regexp_case_sensitive), 0);
+    rb_define_method(re2_cRegexp, "case_insensitive?",
+        RUBY_METHOD_FUNC(re2_regexp_case_insensitive), 0);
+    rb_define_method(re2_cRegexp, "casefold?",
+        RUBY_METHOD_FUNC(re2_regexp_case_insensitive), 0);
+    rb_define_method(re2_cRegexp, "perl_classes?",
+        RUBY_METHOD_FUNC(re2_regexp_perl_classes), 0);
+    rb_define_method(re2_cRegexp, "word_boundary?",
+        RUBY_METHOD_FUNC(re2_regexp_word_boundary), 0);
+    rb_define_method(re2_cRegexp, "one_line?",
+        RUBY_METHOD_FUNC(re2_regexp_one_line), 0);
+
+    rb_define_module_function(re2_mRE2, "Replace",
+        RUBY_METHOD_FUNC(re2_Replace), 3);
+    rb_define_module_function(re2_mRE2, "GlobalReplace",
+        RUBY_METHOD_FUNC(re2_GlobalReplace), 3);
+    rb_define_module_function(re2_mRE2, "QuoteMeta",
+        RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
+    rb_define_singleton_method(re2_cRegexp, "escape",
+        RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
+    rb_define_singleton_method(re2_cRegexp, "quote",
+        RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
+    rb_define_singleton_method(re2_cRegexp, "compile",
+        RUBY_METHOD_FUNC(rb_class_new_instance), -1);
 
     rb_define_global_function("RE2", RUBY_METHOD_FUNC(re2_re2), -1);