re2 2.24.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);
 }
 
@@ -272,6 +280,34 @@ static re2_scanner *unwrap_re2_scanner(VALUE self) {
   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;
 
@@ -503,7 +539,7 @@ 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
  */
@@ -520,7 +556,7 @@ 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
  */
@@ -545,7 +581,7 @@ 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
  */
@@ -562,12 +598,125 @@ 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) {
@@ -606,7 +755,7 @@ 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) {
@@ -673,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)
@@ -683,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)
@@ -692,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.
@@ -701,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"
  */
@@ -725,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);
@@ -739,7 +891,7 @@ 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) {
@@ -774,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
@@ -783,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
@@ -828,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
@@ -852,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 {
@@ -877,6 +1030,120 @@ 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);
@@ -1610,6 +1877,7 @@ 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`
  */
@@ -1628,6 +1896,7 @@ 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`
  */
@@ -1718,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);
@@ -1772,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);
@@ -1807,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
@@ -1818,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(
@@ -2203,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",
@@ -2211,6 +2556,14 @@ 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",
@@ -2248,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),
@@ -2310,16 +2667,26 @@ extern "C" void Init_re2(void) {
   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",
@@ -2347,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");
 }