re2 2.23.0-aarch64-linux-gnu → 2.25.0-aarch64-linux-gnu

data/ext/re2/re2.cc

@@ -51,7 +51,7 @@ 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, id_unanchored,
           id_anchor, id_anchor_start, id_anchor_both, id_exception,
-          id_submatches, id_startpos, id_endpos;
+          id_submatches, id_startpos, id_endpos, id_symbolize_names;
 
 inline VALUE encoded_str_new(const char *str, long length, RE2::Options::Encoding encoding) {
   if (encoding == RE2::Options::EncodingUTF8) {
@@ -128,6 +128,10 @@ static void parse_re2_options(RE2::Options* re2_options, const VALUE options) {
 static void re2_matchdata_mark(void *ptr) {
   re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
   rb_gc_mark_movable(m->regexp);
+
+  /* Text must not be movable because StringPiece matches hold pointers into
+   * its underlying buffer; moving the string would invalidate them.
+   */
   rb_gc_mark(m->text);
 }
 
@@ -172,6 +176,10 @@ static const rb_data_type_t re2_matchdata_data_type = {
 static void re2_scanner_mark(void *ptr) {
   re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
   rb_gc_mark_movable(s->regexp);
+
+  /* Text must not be movable because the StringPiece input holds a pointer
+   * into its underlying buffer; moving the string would invalidate it.
+   */
   rb_gc_mark(s->text);
 }
 
@@ -245,6 +253,61 @@ static const rb_data_type_t re2_regexp_data_type = {
   RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
+static re2_pattern *unwrap_re2_regexp(VALUE self) {
+  re2_pattern *p;
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  if (!p->pattern) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::Regexp");
+  }
+  return p;
+}
+
+static re2_matchdata *unwrap_re2_matchdata(VALUE self) {
+  re2_matchdata *m;
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  if (!RTEST(m->regexp)) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::MatchData");
+  }
+  return m;
+}
+
+static re2_scanner *unwrap_re2_scanner(VALUE self) {
+  re2_scanner *c;
+  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  if (!RTEST(c->regexp)) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::Scanner");
+  }
+  return c;
+}
+
+/*
+ * Returns an array of names of all named capturing groups. Names are returned
+ * in alphabetical order rather than definition order, as RE2 stores named
+ * groups internally in a sorted map.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @return [Array<String>] an array of names of named capturing groups
+ * @example
+ *   RE2::Regexp.new('(?P<a>\d+) (?P<b>\w+)').names #=> ["a", "b"]
+ */
+static VALUE re2_regexp_names(const VALUE self) {
+  re2_pattern *p = unwrap_re2_regexp(self);
+
+  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
+  VALUE names = rb_ary_new2(groups.size());
+
+  for (std::map<std::string, int>::const_iterator it = groups.begin(); it != groups.end(); ++it) {
+    rb_ary_push(names,
+        encoded_str_new(it->first.data(), it->first.size(),
+          p->pattern->options().encoding()));
+  }
+
+  return names;
+}
+
 static VALUE re2_matchdata_allocate(VALUE klass) {
   re2_matchdata *m;
 
@@ -269,8 +332,7 @@ static VALUE re2_scanner_allocate(VALUE klass) {
  *   m.string #=> "bob 123"
  */
 static VALUE re2_matchdata_string(const VALUE self) {
-  re2_matchdata *m;
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   return m->text;
 }
@@ -287,8 +349,7 @@ static VALUE re2_matchdata_string(const VALUE self) {
  *   c.string #=> "foo"
  */
 static VALUE re2_scanner_string(const VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   return c->text;
 }
@@ -302,8 +363,7 @@ static VALUE re2_scanner_string(const VALUE self) {
  *   c.eof? #=> true
  */
 static VALUE re2_scanner_eof(const VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   return BOOL2RUBY(c->eof);
 }
@@ -320,8 +380,7 @@ static VALUE re2_scanner_eof(const VALUE self) {
  *   e.scan #=> ["1"]
  */
 static VALUE re2_scanner_rewind(VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   delete c->input;
   c->input = new(std::nothrow) re2::StringPiece(
@@ -336,6 +395,34 @@ static VALUE re2_scanner_rewind(VALUE self) {
   return self;
 }
 
+static VALUE re2_scanner_initialize_copy(VALUE self, VALUE other) {
+  re2_scanner *self_c;
+  re2_scanner *other_c = unwrap_re2_scanner(other);
+
+  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, self_c);
+
+  if (self_c->input) {
+    delete self_c->input;
+  }
+
+  RB_OBJ_WRITE(self, &self_c->regexp, other_c->regexp);
+  RB_OBJ_WRITE(self, &self_c->text, other_c->text);
+  self_c->number_of_capturing_groups = other_c->number_of_capturing_groups;
+  self_c->eof = other_c->eof;
+
+  if (other_c->input) {
+    self_c->input = new(std::nothrow) re2::StringPiece(*other_c->input);
+    if (self_c->input == 0) {
+      rb_raise(rb_eNoMemError,
+               "not enough memory to allocate StringPiece for input");
+    }
+  } else {
+    self_c->input = NULL;
+  }
+
+  return self;
+}
+
 /*
  * Scan the given text incrementally for matches using
  * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/re2.h#L447-L463
@@ -356,11 +443,8 @@ static VALUE re2_scanner_rewind(VALUE self) {
  *   s.scan #=> ["bar"]
  */
 static VALUE re2_scanner_scan(VALUE self) {
-  re2_pattern *p;
-  re2_scanner *c;
-
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
-  TypedData_Get_Struct(c->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_scanner *c = unwrap_re2_scanner(self);
+  re2_pattern *p = unwrap_re2_regexp(c->regexp);
 
   std::vector<RE2::Arg> argv(c->number_of_capturing_groups);
   std::vector<RE2::Arg*> args(c->number_of_capturing_groups);
@@ -409,11 +493,8 @@ static VALUE re2_scanner_scan(VALUE self) {
 }
 
 static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   int id;
 
@@ -458,14 +539,12 @@ static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
  *
  * @return [Integer] the number of elements
  * @example
- *   m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *   m.size   #=> 2
  *   m.length #=> 2
  */
 static VALUE re2_matchdata_size(const VALUE self) {
-  re2_matchdata *m;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   return INT2FIX(m->number_of_matches);
 }
@@ -477,14 +556,12 @@ static VALUE re2_matchdata_size(const VALUE self) {
  * @return [Integer, nil] the offset of the start of the match or `nil` if
  *   there is no such submatch
  * @example
- *   m = RE2::Regexp.new('ob (\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('ob (\d+)').partial_match("bob 123")
  *   m.begin(0) #=> 1
  *   m.begin(1) #=> 4
  */
 static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
-  re2_matchdata *m;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
   if (match == NULL) {
@@ -504,14 +581,12 @@ static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
  * @return [Integer, nil] the offset of the character following the end of the
  *   match or `nil` if there is no such match
  * @example
- *   m = RE2::Regexp.new('ob (\d+) b').match("bob 123 bob")
+ *   m = RE2::Regexp.new('ob (\d+) b').partial_match("bob 123 bob")
  *   m.end(0) #=> 9
  *   m.end(1) #=> 7
  */
 static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
-  re2_matchdata *m;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
   if (match == NULL) {
@@ -523,17 +598,129 @@ static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
   }
 }
 
+/*
+ * Returns the portion of the original string before the match.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @return [String] the portion of the original string before the match
+ * @example
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123 456")
+ *   m.pre_match #=> "bob "
+ */
+static VALUE re2_matchdata_pre_match(const VALUE self) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
+
+  re2::StringPiece *match = &m->matches[0];
+  if (match->empty()) {
+    return Qnil;
+  }
+
+  long offset = match->data() - RSTRING_PTR(m->text);
+
+  return encoded_str_new(RSTRING_PTR(m->text), offset,
+      p->pattern->options().encoding());
+}
+
+/*
+ * Returns the portion of the original string after the match.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @return [String] the portion of the original string after the match
+ * @example
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123 456")
+ *   m.post_match #=> " 456"
+ */
+static VALUE re2_matchdata_post_match(const VALUE self) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
+
+  re2::StringPiece *match = &m->matches[0];
+  if (match->empty()) {
+    return Qnil;
+  }
+
+  long start = (match->data() - RSTRING_PTR(m->text)) + match->size();
+  long remaining = RSTRING_LEN(m->text) - start;
+
+  return encoded_str_new(RSTRING_PTR(m->text) + start, remaining,
+      p->pattern->options().encoding());
+}
+
+/*
+ * Returns a two-element array containing the beginning and ending offsets of
+ * the nth match.
+ *
+ * @param [Integer, String, Symbol] n the name or number of the match
+ * @return [Array<Integer>, nil] a two-element array with the beginning and
+ *   ending offsets of the match or `nil` if there is no such match
+ * @example
+ *   m = RE2::Regexp.new('ob (\d+)').partial_match("bob 123")
+ *   m.offset(0) #=> [1, 7]
+ *   m.offset(1) #=> [4, 7]
+ */
+static VALUE re2_matchdata_offset(const VALUE self, VALUE n) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+
+  re2::StringPiece *match = re2_matchdata_find_match(n, self);
+  if (match == NULL) {
+    return Qnil;
+  }
+
+  long start = match->data() - RSTRING_PTR(m->text);
+  long end_pos = start + match->size();
+
+  VALUE array = rb_ary_new2(2);
+  rb_ary_push(array, LONG2NUM(rb_str_sublen(m->text, start)));
+  rb_ary_push(array, LONG2NUM(rb_str_sublen(m->text, end_pos)));
+
+  return array;
+}
+
+/*
+ * Returns the length of the nth match in characters. This is equivalent to
+ * `m[n].length` but without allocating a new string.
+ *
+ * @param [Integer, String, Symbol] n the name or number of the match
+ * @return [Integer, nil] the length of the match or `nil` if there is no such
+ *   match
+ * @example
+ *   m = RE2::Regexp.new('(?P<word>\w+) (?P<number>\d+)').partial_match("alice 123")
+ *   m.match_length(0)       #=> 9
+ *   m.match_length(1)       #=> 5
+ *   m.match_length(:number) #=> 3
+ */
+static VALUE re2_matchdata_match_length(const VALUE self, VALUE n) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+
+  re2::StringPiece *match = re2_matchdata_find_match(n, self);
+  if (match == NULL) {
+    return Qnil;
+  }
+
+  long start = match->data() - RSTRING_PTR(m->text);
+  long end_pos = start + match->size();
+  long char_len = rb_str_sublen(m->text, end_pos) - rb_str_sublen(m->text, start);
+
+  return LONG2NUM(char_len);
+}
+
 /*
  * Returns the {RE2::Regexp} used in the match.
  *
  * @return [RE2::Regexp] the regular expression used in the match
  * @example
- *   m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *   m.regexp #=> #<RE2::Regexp /(\d+)/>
  */
 static VALUE re2_matchdata_regexp(const VALUE self) {
-  re2_matchdata *m;
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   return m->regexp;
 }
@@ -547,8 +734,7 @@ static VALUE re2_matchdata_regexp(const VALUE self) {
  *   c.regexp #=> #<RE2::Regexp /(\d+)/>
  */
 static VALUE re2_scanner_regexp(const VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   return c->regexp;
 }
@@ -569,15 +755,12 @@ static VALUE re2_regexp_allocate(VALUE klass) {
  *
  * @return [Array<String, nil>] the array of matches
  * @example
- *   m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *   m.to_a #=> ["123", "123"]
  */
 static VALUE re2_matchdata_to_a(const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   VALUE array = rb_ary_new2(m->number_of_matches);
   for (int i = 0; i < m->number_of_matches; ++i) {
@@ -595,11 +778,8 @@ static VALUE re2_matchdata_to_a(const VALUE self) {
 }
 
 static VALUE re2_matchdata_nth_match(int nth, const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   if (nth < 0 || nth >= m->number_of_matches) {
     return Qnil;
@@ -616,11 +796,8 @@ static VALUE re2_matchdata_nth_match(int nth, const VALUE self) {
 }
 
 static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
   std::map<std::string, int>::const_iterator search = groups.find(name);
@@ -645,7 +822,7 @@ static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self
  *   @param [Integer] index the index of the match to fetch
  *   @return [String, nil] the specified match or `nil` if it isn't present
  *   @example
- *     m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *     m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *     m[0] #=> "123"
  *
  * @overload [](start, length)
@@ -655,7 +832,7 @@ static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self
  *   @param [Integer] length the number of elements to fetch
  *   @return [Array<String, nil>] the specified matches
  *   @example
- *     m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *     m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *     m[0, 1] #=> ["123"]
  *
  * @overload [](range)
@@ -664,8 +841,8 @@ static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self
  *   @param [Range] range the range of match indexes to fetch
  *   @return [Array<String, nil>] the specified matches
  *   @example
- *     m = RE2::Regexp.new('(\d+)').match("bob 123")
- *     m[0..1] #=> "[123", "123"]
+ *     m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
+ *     m[0..1] #=> ["123", "123"]
  *
  * @overload [](name)
  *   Access a particular match by name.
@@ -673,7 +850,7 @@ static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self
  *   @param [String, Symbol] name the name of the match to fetch
  *   @return [String, nil] the specific match or `nil` if it isn't present
  *   @example
- *     m = RE2::Regexp.new('(?P<number>\d+)').match("bob 123")
+ *     m = RE2::Regexp.new('(?P<number>\d+)').partial_match("bob 123")
  *     m["number"] #=> "123"
  *     m[:number]  #=> "123"
  */
@@ -697,6 +874,9 @@ static VALUE re2_matchdata_aref(int argc, VALUE *argv, const VALUE self) {
  * Returns the entire matched string.
  *
  * @return [String] the entire matched string
+ * @example
+ *   m = RE2::Regexp.new('(?P<number>\d+)').partial_match("bob 123")
+ *   m.to_s #=> "123"
  */
 static VALUE re2_matchdata_to_s(const VALUE self) {
   return re2_matchdata_nth_match(0, self);
@@ -711,15 +891,12 @@ static VALUE re2_matchdata_to_s(const VALUE self) {
  *
  * @return [String] a printable version of the match
  * @example
- *   m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *   m.inspect #=> "#<RE2::MatchData \"123\" 1:\"123\">"
  */
 static VALUE re2_matchdata_inspect(const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   std::ostringstream output;
   output << "#<RE2::MatchData";
@@ -749,7 +926,7 @@ static VALUE re2_matchdata_inspect(const VALUE self) {
 }
 
 /*
- * Returns the array of submatches for pattern matching.
+ * Returns the array of submatches.
  *
  * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
  * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
@@ -758,11 +935,12 @@ static VALUE re2_matchdata_inspect(const VALUE self) {
  *
  * @return [Array<String, nil>] the array of submatches
  * @example
- *   m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
+ *   m.captures    #=> ["123"]
  *   m.deconstruct #=> ["123"]
  *
  * @example pattern matching
- *   case RE2::Regexp.new('(\d+) (\d+)').match("bob 123 456")
+ *   case RE2::Regexp.new('(\d+) (\d+)').partial_match("bob 123 456")
  *   in x, y
  *     puts "Matched #{x} #{y}"
  *   else
@@ -770,11 +948,8 @@ static VALUE re2_matchdata_inspect(const VALUE self) {
  *   end
  */
 static VALUE re2_matchdata_deconstruct(const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   VALUE array = rb_ary_new2(m->number_of_matches - 1);
   for (int i = 1; i < m->number_of_matches; ++i) {
@@ -806,14 +981,14 @@ static VALUE re2_matchdata_deconstruct(const VALUE self) {
  * @param [Array<Symbol>, nil] keys an array of `Symbol` capturing group names
  *   or `nil` to return all names
  * @example
- *   m = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
+ *   m = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').partial_match('123 abc')
  *   m.deconstruct_keys(nil)                #=> {numbers: "123", letters: "abc"}
  *   m.deconstruct_keys([:numbers])         #=> {numbers: "123"}
  *   m.deconstruct_keys([:fruit])           #=> {}
  *   m.deconstruct_keys([:letters, :fruit]) #=> {letters: "abc"}
  *
  * @example pattern matching
- *   case RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
+ *   case RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').partial_match('123 abc')
  *   in numbers:, letters:
  *     puts "Numbers: #{numbers}, letters: #{letters}"
  *   else
@@ -821,11 +996,8 @@ static VALUE re2_matchdata_deconstruct(const VALUE self) {
  *   end
  */
 static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
   VALUE capturing_groups = rb_hash_new();
@@ -833,7 +1005,7 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
   if (NIL_P(keys)) {
     for (std::map<std::string, int>::const_iterator it = groups.begin(); it != groups.end(); ++it) {
       rb_hash_aset(capturing_groups,
-          ID2SYM(rb_intern(it->first.data())),
+          ID2SYM(rb_intern2(it->first.data(), it->first.size())),
           re2_matchdata_nth_match(it->second, self));
     }
   } else {
@@ -858,6 +1030,150 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
   return capturing_groups;
 }
 
+/*
+ * Returns a hash of capturing group names to matched strings.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @overload named_captures
+ *   Returns a hash with string keys.
+ *
+ *   @return [Hash] a hash of capturing group names to matching strings
+ *   @example
+ *     m = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').partial_match('123 abc')
+ *     m.named_captures #=> {"numbers" => "123", "letters" => "abc"}
+ *
+ * @overload named_captures(symbolize_names:)
+ *   Returns a hash with string or symbol keys.
+ *
+ *   @param [Boolean] symbolize_names whether to return group names as symbols
+ *   @return [Hash] a hash of capturing group names to matching strings
+ *   @example
+ *     m = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').partial_match('123 abc')
+ *     m.named_captures
+ *     #=> {"numbers" => "123", "letters" => "abc"}
+ *     m.named_captures(symbolize_names: true) #=> {numbers: "123", letters: "abc"}
+ */
+static VALUE re2_matchdata_named_captures(int argc, VALUE *argv, const VALUE self) {
+  VALUE opts;
+  rb_scan_args(argc, argv, "0:", &opts);
+
+  bool symbolize = false;
+  if (!NIL_P(opts)) {
+    VALUE sym = rb_hash_aref(opts, ID2SYM(id_symbolize_names));
+    symbolize = RTEST(sym);
+  }
+
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
+
+  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
+  VALUE result = rb_hash_new();
+
+  for (std::map<std::string, int>::const_iterator it = groups.begin(); it != groups.end(); ++it) {
+    VALUE key;
+    if (symbolize) {
+      key = ID2SYM(rb_intern2(it->first.data(), it->first.size()));
+    } else {
+      key = encoded_str_new(it->first.data(), it->first.size(),
+              p->pattern->options().encoding());
+    }
+    rb_hash_aset(result, key, re2_matchdata_nth_match(it->second, self));
+  }
+
+  return result;
+}
+
+/*
+ * Returns an array of names of named capturing groups. Names are returned in
+ * alphabetical order rather than definition order, as RE2 stores named groups
+ * internally in a sorted map.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @return [Array<String>] an array of names of named capturing groups
+ * @example
+ *   m = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').partial_match('123 abc')
+ *   m.names #=> ["letters", "numbers"]
+ */
+static VALUE re2_matchdata_names(const VALUE self) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+
+  return re2_regexp_names(m->regexp);
+}
+
+/*
+ * Returns an array of match values at the given indices or names.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @param [Integer, String, Symbol] indexes the indices or names of
+ *   the matches to fetch
+ * @return [Array<String, nil>] the values at the given indices or names
+ * @example
+ *   m = RE2::Regexp.new('(?P<a>\d+) (?P<b>\d+)').partial_match("123 456")
+ *   m.values_at(1, 2)   #=> ["123", "456"]
+ *   m.values_at(:a, :b) #=> ["123", "456"]
+ *   m.values_at(1, :b)  #=> ["123", "456"]
+ */
+static VALUE re2_matchdata_values_at(int argc, VALUE *argv, const VALUE self) {
+  unwrap_re2_matchdata(self);
+
+  VALUE result = rb_ary_new2(argc);
+
+  for (int i = 0; i < argc; ++i) {
+    VALUE idx = argv[i];
+
+    if (TYPE(idx) == T_STRING) {
+      rb_ary_push(result, re2_matchdata_named_match(
+            std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)), self));
+    } else if (SYMBOL_P(idx)) {
+      rb_ary_push(result, re2_matchdata_named_match(
+            rb_id2name(SYM2ID(idx)), self));
+    } else {
+      rb_ary_push(result, re2_matchdata_nth_match(NUM2INT(idx), self));
+    }
+  }
+
+  return result;
+}
+
+static VALUE re2_matchdata_initialize_copy(VALUE self, VALUE other) {
+  re2_matchdata *self_m;
+  re2_matchdata *other_m = unwrap_re2_matchdata(other);
+
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, self_m);
+
+  if (self_m->matches) {
+    delete[] self_m->matches;
+  }
+
+  self_m->number_of_matches = other_m->number_of_matches;
+  RB_OBJ_WRITE(self, &self_m->regexp, other_m->regexp);
+  RB_OBJ_WRITE(self, &self_m->text, other_m->text);
+
+  if (other_m->matches) {
+    self_m->matches = new(std::nothrow) re2::StringPiece[other_m->number_of_matches];
+    if (self_m->matches == 0) {
+      rb_raise(rb_eNoMemError,
+               "not enough memory to allocate StringPiece for matches");
+    }
+    for (int i = 0; i < other_m->number_of_matches; ++i) {
+      self_m->matches[i] = other_m->matches[i];
+    }
+  } else {
+    self_m->matches = NULL;
+  }
+
+  return self;
+}
+
 /*
  * Shorthand to compile a new {RE2::Regexp}.
  *
@@ -913,6 +1229,10 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
 
   TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
+  if (p->pattern) {
+    delete p->pattern;
+  }
+
   if (RTEST(options)) {
     RE2::Options re2_options;
     parse_re2_options(&re2_options, options);
@@ -931,6 +1251,25 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
+static VALUE re2_regexp_initialize_copy(VALUE self, VALUE other) {
+  re2_pattern *self_p;
+  re2_pattern *other_p = unwrap_re2_regexp(other);
+
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, self_p);
+
+  if (self_p->pattern) {
+    delete self_p->pattern;
+  }
+
+  self_p->pattern = new(std::nothrow) RE2(other_p->pattern->pattern(),
+                                          other_p->pattern->options());
+  if (self_p->pattern == 0) {
+    rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
+  }
+
+  return self;
+}
+
 /*
  * Returns a printable version of the regular expression.
  *
@@ -945,9 +1284,7 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
  *   re2.inspect #=> "#<RE2::Regexp /woo?/>"
  */
 static VALUE re2_regexp_inspect(const VALUE self) {
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   std::ostringstream output;
 
@@ -970,8 +1307,7 @@ static VALUE re2_regexp_inspect(const VALUE self) {
  *   re2.to_s #=> "woo?"
  */
 static VALUE re2_regexp_to_s(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return encoded_str_new(p->pattern->pattern().data(),
       p->pattern->pattern().size(),
@@ -987,8 +1323,7 @@ static VALUE re2_regexp_to_s(const VALUE self) {
  *   re2.ok? #=> true
  */
 static VALUE re2_regexp_ok(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->ok());
 }
@@ -1003,8 +1338,7 @@ static VALUE re2_regexp_ok(const VALUE self) {
  *   re2.utf8? #=> true
  */
 static VALUE re2_regexp_utf8(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().encoding() == RE2::Options::EncodingUTF8);
 }
@@ -1019,8 +1353,7 @@ static VALUE re2_regexp_utf8(const VALUE self) {
  *   re2.posix_syntax? #=> true
  */
 static VALUE re2_regexp_posix_syntax(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().posix_syntax());
 }
@@ -1035,8 +1368,7 @@ static VALUE re2_regexp_posix_syntax(const VALUE self) {
  *   re2.longest_match? #=> true
  */
 static VALUE re2_regexp_longest_match(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().longest_match());
 }
@@ -1051,8 +1383,7 @@ static VALUE re2_regexp_longest_match(const VALUE self) {
  *   re2.log_errors? #=> true
  */
 static VALUE re2_regexp_log_errors(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().log_errors());
 }
@@ -1066,8 +1397,7 @@ static VALUE re2_regexp_log_errors(const VALUE self) {
  *   re2.max_mem #=> 1024
  */
 static VALUE re2_regexp_max_mem(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return INT2FIX(p->pattern->options().max_mem());
 }
@@ -1082,8 +1412,7 @@ static VALUE re2_regexp_max_mem(const VALUE self) {
  *   re2.literal? #=> true
  */
 static VALUE re2_regexp_literal(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().literal());
 }
@@ -1098,8 +1427,7 @@ static VALUE re2_regexp_literal(const VALUE self) {
  *   re2.never_nl? #=> true
  */
 static VALUE re2_regexp_never_nl(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().never_nl());
 }
@@ -1114,8 +1442,7 @@ static VALUE re2_regexp_never_nl(const VALUE self) {
  *   re2.case_sensitive? #=> true
  */
 static VALUE re2_regexp_case_sensitive(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().case_sensitive());
 }
@@ -1144,8 +1471,7 @@ static VALUE re2_regexp_case_insensitive(const VALUE self) {
  *   re2.perl_classes? #=> true
  */
 static VALUE re2_regexp_perl_classes(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().perl_classes());
 }
@@ -1160,8 +1486,7 @@ static VALUE re2_regexp_perl_classes(const VALUE self) {
  *   re2.word_boundary? #=> true
  */
 static VALUE re2_regexp_word_boundary(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().word_boundary());
 }
@@ -1176,8 +1501,7 @@ static VALUE re2_regexp_word_boundary(const VALUE self) {
  *   re2.one_line? #=> true
  */
 static VALUE re2_regexp_one_line(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().one_line());
 }
@@ -1189,8 +1513,7 @@ static VALUE re2_regexp_one_line(const VALUE self) {
  * @return [String, nil] the error string or `nil`
  */
 static VALUE re2_regexp_error(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   if (p->pattern->ok()) {
     return Qnil;
@@ -1210,8 +1533,7 @@ static VALUE re2_regexp_error(const VALUE self) {
  * @return [String, nil] the offending portion of the regexp or `nil`
  */
 static VALUE re2_regexp_error_arg(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   if (p->pattern->ok()) {
     return Qnil;
@@ -1230,8 +1552,7 @@ static VALUE re2_regexp_error_arg(const VALUE self) {
  * @return [Integer] the regexp "cost"
  */
 static VALUE re2_regexp_program_size(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return INT2FIX(p->pattern->ProgramSize());
 }
@@ -1242,9 +1563,7 @@ static VALUE re2_regexp_program_size(const VALUE self) {
  * @return [Hash] the options
  */
 static VALUE re2_regexp_options(const VALUE self) {
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
   VALUE options = rb_hash_new();
 
   rb_hash_aset(options, ID2SYM(id_utf8),
@@ -1294,8 +1613,7 @@ static VALUE re2_regexp_options(const VALUE self) {
  * @return [Integer] the number of capturing subpatterns
  */
 static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return INT2FIX(p->pattern->NumberOfCapturingGroups());
 }
@@ -1310,9 +1628,7 @@ static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
  * @return [Hash] a hash of names to capturing indices
  */
 static VALUE re2_regexp_named_capturing_groups(const VALUE self) {
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
   const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
   VALUE capturing_groups = rb_hash_new();
 
@@ -1418,7 +1734,7 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
   /* Ensure text is a string. */
   StringValue(text);
 
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  p = unwrap_re2_regexp(self);
 
   int n;
   int startpos = 0;
@@ -1561,16 +1877,15 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
  * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/re2.h#L413-L427
  * `PartialMatch`}.
  *
+ * @param [String] text the text to search
  * @return [Boolean] whether the match was successful
  * @raise [TypeError] if text cannot be coerced to a `String`
  */
 static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
-  re2_pattern *p;
-
   /* Ensure text is a string. */
   StringValue(text);
 
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(RE2::PartialMatch(
         re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)), *p->pattern));
@@ -1581,16 +1896,15 @@ static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
  * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/re2.h#L376-L411
  * `FullMatch`}.
  *
+ * @param [String] text the text to search
  * @return [Boolean] whether the match was successful
  * @raise [TypeError] if text cannot be coerced to a `String`
  */
 static VALUE re2_regexp_full_match_p(const VALUE self, VALUE text) {
-  re2_pattern *p;
-
   /* Ensure text is a string. */
   StringValue(text);
 
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(RE2::FullMatch(
         re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)), *p->pattern));
@@ -1612,10 +1926,8 @@ static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
   /* Ensure text is a string. */
   StringValue(text);
 
-  re2_pattern *p;
+  re2_pattern *p = unwrap_re2_regexp(self);
   re2_scanner *c;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
   VALUE scanner = rb_class_new_instance(0, 0, re2_cScanner);
   TypedData_Get_Struct(scanner, re2_scanner, &re2_scanner_data_type, c);
 
@@ -1675,11 +1987,11 @@ static VALUE re2_regexp_match_has_endpos_argument_p(VALUE) {
  * @raise [TypeError] if the given rewrite or pattern (if not provided as a
  *   {RE2::Regexp}) cannot be coerced to `String`s
  * @example
- *   RE2.Replace("hello there", "hello", "howdy") #=> "howdy there"
+ *   RE2.replace("hello there", "hello", "howdy") #=> "howdy there"
  *   re2 = RE2::Regexp.new("hel+o")
- *   RE2.Replace("hello there", re2, "yo")        #=> "yo there"
+ *   RE2.replace("hello there", re2, "yo")        #=> "yo there"
  */
-static VALUE re2_Replace(VALUE, VALUE str, VALUE pattern,
+static VALUE re2_replace(VALUE, VALUE str, VALUE pattern,
     VALUE rewrite) {
   /* Ensure rewrite is a string. */
   StringValue(rewrite);
@@ -1694,7 +2006,7 @@ static VALUE re2_Replace(VALUE, VALUE str, VALUE pattern,
 
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
-    TypedData_Get_Struct(pattern, re2_pattern, &re2_regexp_data_type, p);
+    p = unwrap_re2_regexp(pattern);
     RE2::Replace(&str_as_string, *p->pattern,
         re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
 
@@ -1729,10 +2041,10 @@ static VALUE re2_Replace(VALUE, VALUE str, VALUE pattern,
  * @return [String] the resulting string
  * @example
  *   re2 = RE2::Regexp.new("oo?")
- *   RE2.GlobalReplace("whoops-doops", re2, "e") #=> "wheps-deps"
- *   RE2.GlobalReplace("hello there", "e", "i")  #=> "hillo thiri"
+ *   RE2.global_replace("whoops-doops", re2, "e") #=> "wheps-deps"
+ *   RE2.global_replace("hello there", "e", "i")  #=> "hillo thiri"
  */
-static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
+static VALUE re2_global_replace(VALUE, VALUE str, VALUE pattern,
                                VALUE rewrite) {
   /* Ensure rewrite is a string. */
   StringValue(rewrite);
@@ -1746,7 +2058,7 @@ static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
 
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
-    TypedData_Get_Struct(pattern, re2_pattern, &re2_regexp_data_type, p);
+    p = unwrap_re2_regexp(pattern);
     RE2::GlobalReplace(&str_as_string, *p->pattern,
         re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
 
@@ -1764,6 +2076,71 @@ static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
   }
 }
 
+/*
+ * If `pattern` matches `text`, returns a copy of `rewrite` with substitutions
+ * using
+ * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/re2.h#L499-L510
+ * `Extract`}. Non-matching portions of `text` are ignored.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @param [String] text the string from which to extract
+ * @param [String, RE2::Regexp] pattern a regexp matching the text
+ * @param [String] rewrite the rewrite string with `\1`-style substitutions
+ * @return [String, nil] the extracted string on a successful match or nil if
+ *   there is no match
+ * @raise [TypeError] if the given rewrite or pattern (if not provided as a
+ *   {RE2::Regexp}) cannot be coerced to `String`s
+ * @example
+ *   RE2.extract("alice@example.com", '(\w+)@(\w+)', '\2-\1')
+ *   #=> "example-alice"
+ *   RE2.extract("no match", '(\d+)', '\1') #=> nil
+ */
+static VALUE re2_extract(VALUE, VALUE text, VALUE pattern,
+    VALUE rewrite) {
+  /* Ensure rewrite and text are strings. */
+  StringValue(rewrite);
+  StringValue(text);
+
+  re2_pattern *p;
+  std::string out;
+  bool extracted;
+
+  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
+    p = unwrap_re2_regexp(pattern);
+    extracted = RE2::Extract(
+        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
+        *p->pattern,
+        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)),
+        &out);
+
+    if (extracted) {
+      return encoded_str_new(out.data(), out.size(),
+          p->pattern->options().encoding());
+    } else {
+      return Qnil;
+    }
+  } else {
+    /* Ensure pattern is a string. */
+    StringValue(pattern);
+
+    extracted = RE2::Extract(
+        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
+        RE2(re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern))),
+        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)),
+        &out);
+
+    if (extracted) {
+      return encoded_str_new(out.data(), out.size(),
+          RE2::Options::EncodingUTF8);
+    } else {
+      return Qnil;
+    }
+  }
+}
+
 /*
  * Returns a version of `str` with all potentially meaningful regexp characters
  * escaped using
@@ -1775,9 +2152,12 @@ static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
  * @raise [TypeError] if the given unquoted string cannot be coerced to a `String`
  * @return [String] the escaped string
  * @example
- *   RE2::Regexp.escape("1.5-2.0?") #=> "1\.5\-2\.0\?"
+ *   RE2.escape("1.5-2.0?")         #=> "1\\.5\\-2\\.0\\?"
+ *   RE2.quote("1.5-2.0?")          #=> "1\\.5\\-2\\.0\\?"
+ *   RE2::Regexp.escape("1.5-2.0?") #=> "1\\.5\\-2\\.0\\?"
+ *   RE2::Regexp.quote("1.5-2.0?")  #=> "1\\.5\\-2\\.0\\?"
  */
-static VALUE re2_QuoteMeta(VALUE, VALUE unquoted) {
+static VALUE re2_escape(VALUE, VALUE unquoted) {
   StringValue(unquoted);
 
   std::string quoted_string = RE2::QuoteMeta(
@@ -1818,6 +2198,15 @@ static const rb_data_type_t re2_set_data_type = {
   RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
+static re2_set *unwrap_re2_set(VALUE self) {
+  re2_set *s;
+  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  if (!s->set) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::Set");
+  }
+  return s;
+}
+
 static VALUE re2_set_allocate(VALUE klass) {
   re2_set *s;
   VALUE result = TypedData_Make_Struct(klass, re2_set, &re2_set_data_type, s);
@@ -1825,6 +2214,10 @@ static VALUE re2_set_allocate(VALUE klass) {
   return result;
 }
 
+static VALUE re2_set_initialize_copy(VALUE, VALUE) {
+  rb_raise(rb_eTypeError, "cannot copy RE2::Set");
+}
+
 /*
  * Returns a new {RE2::Set} object, a collection of patterns that can be
  * searched for simultaneously.
@@ -1895,6 +2288,10 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
     parse_re2_options(&re2_options, options);
   }
 
+  if (s->set) {
+    delete s->set;
+  }
+
   s->set = new(std::nothrow) RE2::Set(re2_options, re2_anchor);
   if (s->set == 0) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2::Set object");
@@ -1919,8 +2316,7 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
 static VALUE re2_set_add(VALUE self, VALUE pattern) {
   StringValue(pattern);
 
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  re2_set *s = unwrap_re2_set(self);
 
   int index;
   VALUE msg;
@@ -1951,8 +2347,7 @@ static VALUE re2_set_add(VALUE self, VALUE pattern) {
  *   set.compile #=> true
  */
 static VALUE re2_set_compile(VALUE self) {
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  re2_set *s = unwrap_re2_set(self);
 
   return BOOL2RUBY(s->set->Compile());
 }
@@ -1968,8 +2363,7 @@ static VALUE re2_set_compile(VALUE self) {
  */
 static VALUE re2_set_size(VALUE self) {
 #ifdef HAVE_SET_SIZE
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  re2_set *s = unwrap_re2_set(self);
 
   return INT2FIX(s->set->Size());
 #else
@@ -2052,8 +2446,7 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
   rb_scan_args(argc, argv, "11", &str, &options);
 
   StringValue(str);
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  re2_set *s = unwrap_re2_set(self);
 
   if (RTEST(options)) {
     Check_Type(options, T_HASH);
@@ -2147,6 +2540,14 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_matchdata_begin), 1);
   rb_define_method(re2_cMatchData, "end",
       RUBY_METHOD_FUNC(re2_matchdata_end), 1);
+  rb_define_method(re2_cMatchData, "pre_match",
+      RUBY_METHOD_FUNC(re2_matchdata_pre_match), 0);
+  rb_define_method(re2_cMatchData, "post_match",
+      RUBY_METHOD_FUNC(re2_matchdata_post_match), 0);
+  rb_define_method(re2_cMatchData, "offset",
+      RUBY_METHOD_FUNC(re2_matchdata_offset), 1);
+  rb_define_method(re2_cMatchData, "match_length",
+      RUBY_METHOD_FUNC(re2_matchdata_match_length), 1);
   rb_define_method(re2_cMatchData, "[]", RUBY_METHOD_FUNC(re2_matchdata_aref),
       -1);
   rb_define_method(re2_cMatchData, "to_s",
@@ -2155,8 +2556,18 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_matchdata_inspect), 0);
   rb_define_method(re2_cMatchData, "deconstruct",
       RUBY_METHOD_FUNC(re2_matchdata_deconstruct), 0);
+  rb_define_method(re2_cMatchData, "captures",
+      RUBY_METHOD_FUNC(re2_matchdata_deconstruct), 0);
+  rb_define_method(re2_cMatchData, "named_captures",
+      RUBY_METHOD_FUNC(re2_matchdata_named_captures), -1);
+  rb_define_method(re2_cMatchData, "names",
+      RUBY_METHOD_FUNC(re2_matchdata_names), 0);
+  rb_define_method(re2_cMatchData, "values_at",
+      RUBY_METHOD_FUNC(re2_matchdata_values_at), -1);
   rb_define_method(re2_cMatchData, "deconstruct_keys",
       RUBY_METHOD_FUNC(re2_matchdata_deconstruct_keys), 1);
+  rb_define_method(re2_cMatchData, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_matchdata_initialize_copy), 1);
 
   rb_define_method(re2_cScanner, "string",
       RUBY_METHOD_FUNC(re2_scanner_string), 0);
@@ -2168,11 +2579,15 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_scanner_scan), 0);
   rb_define_method(re2_cScanner, "rewind",
       RUBY_METHOD_FUNC(re2_scanner_rewind), 0);
+  rb_define_method(re2_cScanner, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_scanner_initialize_copy), 1);
 
   rb_define_singleton_method(re2_cRegexp, "match_has_endpos_argument?",
       RUBY_METHOD_FUNC(re2_regexp_match_has_endpos_argument_p), 0);
   rb_define_method(re2_cRegexp, "initialize",
       RUBY_METHOD_FUNC(re2_regexp_initialize), -1);
+  rb_define_method(re2_cRegexp, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_regexp_initialize_copy), 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);
@@ -2186,6 +2601,10 @@ extern "C" void Init_re2(void) {
       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, "named_captures",
+      RUBY_METHOD_FUNC(re2_regexp_named_capturing_groups), 0);
+  rb_define_method(re2_cRegexp, "names",
+      RUBY_METHOD_FUNC(re2_regexp_names), 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_p),
@@ -2240,22 +2659,34 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_set_size_p), 0);
   rb_define_method(re2_cSet, "initialize",
       RUBY_METHOD_FUNC(re2_set_initialize), -1);
+  rb_define_method(re2_cSet, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_set_initialize_copy), 1);
   rb_define_method(re2_cSet, "add", RUBY_METHOD_FUNC(re2_set_add), 1);
   rb_define_method(re2_cSet, "compile", RUBY_METHOD_FUNC(re2_set_compile), 0);
   rb_define_method(re2_cSet, "match", RUBY_METHOD_FUNC(re2_set_match), -1);
   rb_define_method(re2_cSet, "size", RUBY_METHOD_FUNC(re2_set_size), 0);
   rb_define_method(re2_cSet, "length", RUBY_METHOD_FUNC(re2_set_size), 0);
 
+  rb_define_module_function(re2_mRE2, "replace",
+      RUBY_METHOD_FUNC(re2_replace), 3);
   rb_define_module_function(re2_mRE2, "Replace",
-      RUBY_METHOD_FUNC(re2_Replace), 3);
+      RUBY_METHOD_FUNC(re2_replace), 3);
+  rb_define_module_function(re2_mRE2, "global_replace",
+      RUBY_METHOD_FUNC(re2_global_replace), 3);
   rb_define_module_function(re2_mRE2, "GlobalReplace",
-      RUBY_METHOD_FUNC(re2_GlobalReplace), 3);
+      RUBY_METHOD_FUNC(re2_global_replace), 3);
+  rb_define_module_function(re2_mRE2, "extract",
+      RUBY_METHOD_FUNC(re2_extract), 3);
   rb_define_module_function(re2_mRE2, "QuoteMeta",
-      RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
+      RUBY_METHOD_FUNC(re2_escape), 1);
+  rb_define_module_function(re2_mRE2, "escape",
+      RUBY_METHOD_FUNC(re2_escape), 1);
+  rb_define_module_function(re2_mRE2, "quote",
+      RUBY_METHOD_FUNC(re2_escape), 1);
   rb_define_singleton_method(re2_cRegexp, "escape",
-      RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
+      RUBY_METHOD_FUNC(re2_escape), 1);
   rb_define_singleton_method(re2_cRegexp, "quote",
-      RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
+      RUBY_METHOD_FUNC(re2_escape), 1);
 
   // (see RE2::Regexp#initialize)
   rb_define_singleton_method(re2_cRegexp, "compile",
@@ -2283,4 +2714,5 @@ extern "C" void Init_re2(void) {
   id_submatches = rb_intern("submatches");
   id_startpos = rb_intern("startpos");
   id_endpos = rb_intern("endpos");
+  id_symbolize_names = rb_intern("symbolize_names");
 }