re2 2.0.0-x86_64-darwin → 2.1.0-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 686f3ee1b0a2e66a51cb14e8432cb32ae502887fc26a1e8039ee2a2584ce4faf
-  data.tar.gz: 3ab70a1c6f3c0a0fbd6bc900c6159f11618b722c126f7376d2cec2cc36baf534
+  metadata.gz: ea860967fe64f6452e07f85449e0437708d9e69a2867942c097f5ddf35e11aef
+  data.tar.gz: e8c73abe9b730e38f8f4354fe56c97c6e01ce2940835c6f4dcccb974c9c2752a
 SHA512:
-  metadata.gz: a7dc8c80397a0bcf01eff7b0c25ef7237d3c229d33d3193db9e9c2e9d9fc453c70d7e2b5bf9b9c4af5ab477e26720f842408909799fbedc3d0d8573a421850ad
-  data.tar.gz: 4e7f93d67ce58af1d0e1831b49d2ee57b2e8c8c507f6f58d09fc5e9fbd566a400514a10dd5413f8684a01eaf0d952d436ed1256b1b79175003f78a34957a87aa
+  metadata.gz: 6ce1b910c7e9e5017fb206ebe9713db7ca9c0cc2b218fdf69c6e78e31af95cadf75607be3011b45e52f93d0fb6c2f92fcb4797bc084bb252e5828edb1cf4db3e
+  data.tar.gz: 542563bfd28615027f9e9ccb66e4998d9ec7ebf4bf13058c9d9d4c6e8005bf8dbcd2cc45a8b4dff3fa0288831e4cf61ca9020e646f17ade11124b54d6f07c84e

data/LICENSE-DEPENDENCIES.txt

@@ -0,0 +1,237 @@
+# Vendored Dependency Licenses
+
+The library re2 (which lives at https://github.com/mudge/re2) may include the source code for RE2 (which lives at https://github.com/google/re2) and Abseil (which lives at https://abseil.io).
+
+The license terms shipped with RE2 are included here for your convenience:
+
+// Copyright (c) 2009 The RE2 Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The license terms shipped with Abseil are included here for your convenience:
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/LICENSE.txt

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

data/README.md

@@ -1,18 +1,19 @@
 re2 [![Build Status](https://github.com/mudge/re2/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/mudge/re2/actions)
 ===
 
-A Ruby binding to [re2][], an "efficient, principled regular expression
-library".
+Ruby bindings to [RE2][], a "fast, safe, thread-friendly alternative to
+backtracking regular expression engines like those used in PCRE, Perl, and
+Python".
 
-**Current version:** 2.0.0  
+**Current version:** 2.1.0  
 **Supported Ruby versions:** 2.6, 2.7, 3.0, 3.1, 3.2  
-**Bundled re2 version:** libre2.11 (2023-09-01)  
-**Supported re2 versions:** libre2.0 (< 2020-03-02), libre2.1 (2020-03-02), libre2.6 (2020-03-03), libre2.7 (2020-05-01), libre2.8 (2020-07-06), libre2.9 (2020-11-01), libre2.10 (2022-12-01), libre2.11 (2023-07-01)
+**Bundled RE2 version:** libre2.11 (2023-09-01)  
+**Supported RE2 versions:** libre2.0 (< 2020-03-02), libre2.1 (2020-03-02), libre2.6 (2020-03-03), libre2.7 (2020-05-01), libre2.8 (2020-07-06), libre2.9 (2020-11-01), libre2.10 (2022-12-01), libre2.11 (2023-07-01)
 
 Installation
 ------------
 
-The gem comes bundled with a version of [re2][] and will compile itself (and
+The gem comes bundled with a version of [RE2][] and will compile itself (and
 any dependencies) on install. As compilation can take a while, precompiled
 native gems are available for Linux, Windows and macOS.
 
@@ -27,10 +28,10 @@ on these platforms:
 - `x86_64-darwin`
 - `x86_64-linux` (requires: glibc >= 2.17)
 
-If you wish to opt out of using the bundled libraries, you will need re2
+If you wish to opt out of using the bundled libraries, 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:
+is provided by the [build-essential][] package). If you are using macOS, I
+recommend installing RE2 with [Homebrew][] by running the following:
 
     $ brew install re2
 
@@ -38,7 +39,7 @@ If you are using Debian, you can install the [libre2-dev][] package like so:
 
     $ sudo apt-get install libre2-dev
 
-Recent versions of re2 require a compiler with C++14 support such as
+Recent versions of RE2 require a compiler with C++14 support such as
 [clang](http://clang.llvm.org/) 3.4 or [gcc](https://gcc.gnu.org/) 5.
 
 If you are using a packaged Ruby distribution, make sure you also have the
@@ -47,7 +48,7 @@ on Debian and Ubuntu.
 
 You can then install the library via RubyGems with `gem install re2 --platform=ruby --
 --enable-system-libraries` or `gem install re2 --platform=ruby -- --enable-system-libraries
---with-re2-dir=/path/to/re2/prefix` if re2 is not installed in any of the
+--with-re2-dir=/path/to/re2/prefix` if RE2 is not installed in any of the
 following default locations:
 
 * `/usr/local`
@@ -66,7 +67,7 @@ Documentation
 Full documentation automatically generated from the latest version is
 available at <http://mudge.name/re2/>.
 
-Note that re2's regular expression syntax differs from PCRE and Ruby's
+Note that RE2's regular expression syntax differs from PCRE and Ruby's
 built-in [`Regexp`][Regexp] library, see the [official syntax page][] for more
 details.
 
@@ -192,6 +193,24 @@ end
 # My name is Alice and I am 42 years old
 ```
 
+Encoding
+--------
+
+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).
+
+For backward compatibility: re2 won't automatically convert string inputs to
+the right encoding so this is the responsibility of the caller, e.g.
+
+```ruby
+# By default, RE2 will process patterns and text as UTF-8
+RE2(non_utf8_pattern.encode("UTF-8")).match(non_utf8_text.encode("UTF-8"))
+
+# If the :utf8 option is false, RE2 will process patterns and text as ISO-8859-1
+RE2(non_latin1_pattern.encode("ISO-8859-1"), :utf8 => false).match(non_latin1_text.encode("ISO-8859-1"))
+```
+
 Features
 --------
 
@@ -238,9 +257,9 @@ Contributions
 * Thanks to [Jason Woods](https://github.com/driskell) who contributed the
   original implementations of `RE2::MatchData#begin` and `RE2::MatchData#end`;
 * Thanks to [Stefano Rivera](https://github.com/stefanor) who first contributed C++11 support;
-* Thanks to [Stan Hu](https://github.com/stanhu) for reporting a bug with empty patterns and `RE2::Regexp#scan`, contributing support for libre2.11 (2023-07-01) and for vendoring re2 and abseil and compiling native gems in 2.0;
+* Thanks to [Stan Hu](https://github.com/stanhu) for reporting a bug with empty patterns and `RE2::Regexp#scan`, contributing support for libre2.11 (2023-07-01) and for vendoring RE2 and abseil and compiling native gems in 2.0;
 * Thanks to [Sebastian Reitenbach](https://github.com/buzzdeee) for reporting
-  the deprecation and removal of the `utf8` encoding option in re2;
+  the deprecation and removal of the `utf8` encoding option in RE2;
 * Thanks to [Sergio Medina](https://github.com/serch) for reporting a bug when
   using `RE2::Scanner#scan` with an invalid regular expression;
 * Thanks to [Pritam Baral](https://github.com/pritambaral) for contributed the
@@ -251,7 +270,19 @@ Contact
 
 All issues and suggestions should go to [GitHub Issues](https://github.com/mudge/re2/issues).
 
-  [re2]: https://github.com/google/re2
+License
+-------
+
+This library is licensed under the BSD 3-Clause License, see `LICENSE.txt`.
+
+Dependencies
+------------
+
+The source code of [RE2][] is distributed in the `ruby` platform gem. This code is licensed under the BSD 3-Clause License, see `LICENSE-DEPENDENCIES.txt`.
+
+The source code of [Abseil][] is distributed in the `ruby` platform gem. This code is licensed under the Apache License 2.0, see `LICENSE-DEPENDENCIES.txt`.
+
+  [RE2]: https://github.com/google/re2
   [gcc]: http://gcc.gnu.org/
   [ruby-dev]: http://packages.debian.org/ruby-dev
   [build-essential]: http://packages.debian.org/build-essential
@@ -260,4 +291,4 @@ All issues and suggestions should go to [GitHub Issues](https://github.com/mudge
   [Homebrew]: http://mxcl.github.com/homebrew
   [libre2-dev]: http://packages.debian.org/search?keywords=libre2-dev
   [official syntax page]: https://github.com/google/re2/wiki/Syntax
-
+  [Abseil]: https://abseil.io

data/ext/re2/re2.cc

@@ -39,18 +39,9 @@ using std::vector;
       rb_enc_associate_index(_string, _enc); \
       _string; \
     })
-  #define ENCODED_STR_NEW2(str, length, str2) \
-    ({ \
-      VALUE _string = rb_str_new(str, length); \
-      int _enc = rb_enc_get_index(str2); \
-      rb_enc_associate_index(_string, _enc); \
-      _string; \
-    })
 #else
   #define ENCODED_STR_NEW(str, length, encoding) \
     rb_str_new((const char *)str, (long)length)
-  #define ENCODED_STR_NEW2(str, length, str2) \
-    rb_str_new((const char *)str, (long)length)
 #endif
 
 #ifdef HAVE_RB_STR_SUBLEN
@@ -284,6 +275,10 @@ static VALUE re2_scanner_rewind(VALUE self) {
  * Scan the given text incrementally for matches, returning an array of
  * matches on each subsequent call. Returns nil if no matches are found.
  *
+ * 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>] the matches.
  * @example
  *   s = RE2::Regexp.new('(\w+)').scan("Foo bar baz")
@@ -312,7 +307,6 @@ static VALUE re2_scanner_scan(VALUE self) {
   original_input_size = c->input->size();
 
   for (i = 0; i < c->number_of_capturing_groups; i++) {
-    matches[i] = "";
     argv[i] = &matches[i];
     args[i] = &argv[i];
   }
@@ -504,6 +498,10 @@ static VALUE re2_regexp_allocate(VALUE klass) {
 /*
  * Returns the array of matches.
  *
+ * 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, nil>] the array of matches
  * @example
  *   m = RE2::Regexp.new('(\d+)').match("bob 123")
@@ -579,6 +577,10 @@ static VALUE re2_matchdata_named_match(const char* name, VALUE self) {
 /*
  * Retrieve zero, one or more matches by index or name.
  *
+ * 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, nil>, String, Boolean]
  *
  * @overload [](index)
@@ -646,6 +648,10 @@ static VALUE re2_matchdata_to_s(VALUE self) {
 /*
  * Returns a printable version of 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] a printable version of the match
  * @example
  *   m = RE2::Regexp.new('(\d+)').match("bob 123")
@@ -690,6 +696,10 @@ static VALUE re2_matchdata_inspect(VALUE self) {
 /*
  * Returns the array of submatches for pattern matching.
  *
+ * 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, nil>] the array of submatches
  * @example
  *   m = RE2::Regexp.new('(\d+)').match("bob 123")
@@ -735,6 +745,10 @@ static VALUE re2_matchdata_deconstruct(VALUE self) {
  * more keys than there are capturing groups. Given keys will populate the hash in
  * order but an invalid name will cause the hash to be immediately returned.
  *
+ * 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 [Hash] a hash of capturing group names to submatches
  * @param [Array<Symbol>, nil] keys an array of Symbol capturing group names or nil to return all names
  * @example
@@ -866,6 +880,10 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
 /*
  * Returns a printable version of the regular expression +re2+.
  *
+ * 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] a printable version of the regular expression
  * @example
  *   re2 = RE2::Regexp.new("woo?")
@@ -889,6 +907,10 @@ static VALUE re2_regexp_inspect(VALUE self) {
 /*
  * Returns a string version of the regular expression +re2+.
  *
+ * 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] a string version of the regular expression
  * @example
  *   re2 = RE2::Regexp.new("woo?")
@@ -1116,6 +1138,10 @@ static VALUE re2_regexp_error(VALUE self) {
  * If the RE2 could not be created properly, returns
  * the offending portion of the regexp otherwise returns nil.
  *
+ * 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, nil] the offending portion of the regexp or nil
  */
 static VALUE re2_regexp_error_arg(VALUE self) {
@@ -1212,6 +1238,10 @@ static VALUE re2_regexp_number_of_capturing_groups(VALUE self) {
 /*
  * Returns a hash of names to capturing indices of groups.
  *
+ * 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 [Hash] a hash of names to capturing indices
  */
 static VALUE re2_regexp_named_capturing_groups(VALUE self) {
@@ -1242,16 +1272,23 @@ static VALUE re2_regexp_named_capturing_groups(VALUE self) {
  * @return [Boolean, RE2::MatchData]
  *
  * @overload match(text)
- *   Returns an {RE2::MatchData} containing the matching
- *   pattern and all subpatterns resulting from looking for
- *   the regexp in +text+.
+ *   Returns an {RE2::MatchData} containing the matching pattern and all
+ *   subpatterns resulting from looking for the regexp in +text+ if the pattern
+ *   contains capturing groups.
+ *
+ *   Returns either true or false indicating whether a successful match was
+ *   made if the pattern contains no capturing groups.
  *
  *   @param [String] text the text to search
- *   @return [RE2::MatchData] the matches
+ *   @return [RE2::MatchData] if the pattern contains capturing groups
+ *   @return [Boolean] if the pattern does not contain capturing groups
  *   @raise [NoMemoryError] if there was not enough memory to allocate the matches
- *   @example
+ *   @example Matching with capturing groups
  *     r = RE2::Regexp.new('w(o)(o)')
  *     r.match('woo')    #=> #<RE2::MatchData "woo" 1:"o" 2:"o">
+ *   @example Matching without capturing groups
+ *     r = RE2::Regexp.new('woo')
+ *     r.match('woo')    #=> true
  *
  * @overload match(text, 0)
  *   Returns either true or false indicating whether a
@@ -1390,6 +1427,10 @@ static VALUE re2_regexp_scan(VALUE self, VALUE text) {
  * Returns a copy of +str+ with the first occurrence +pattern+
  * replaced with +rewrite+.
  *
+ * 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] str the string to modify
  * @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
  * @param [String] rewrite the string to replace with
@@ -1404,7 +1445,9 @@ static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
   UNUSED(self);
   re2_pattern *p;
 
-  /* Convert all the inputs to be pumped into RE2::Replace. */
+  /* Take a copy of str so it can be modified in-place by
+   * RE2::Replace.
+   */
   string str_as_string(StringValuePtr(str));
 
   /* Do the replacement. */
@@ -1418,8 +1461,8 @@ static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
     RE2::Replace(&str_as_string, StringValuePtr(pattern),
         StringValuePtr(rewrite));
 
-    return ENCODED_STR_NEW2(str_as_string.data(), str_as_string.size(),
-        pattern);
+    return ENCODED_STR_NEW(str_as_string.data(), str_as_string.size(),
+        "UTF-8");
   }
 
 }
@@ -1427,6 +1470,10 @@ static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
 /*
  * Return a copy of +str+ with +pattern+ replaced by +rewrite+.
  *
+ * 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] str the string to modify
  * @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
  * @param [String] rewrite the string to replace with
@@ -1440,7 +1487,9 @@ static VALUE re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern,
                                VALUE rewrite) {
   UNUSED(self);
 
-  /* Convert all the inputs to be pumped into RE2::GlobalReplace. */
+  /* Take a copy of str so it can be modified in-place by
+   * RE2::GlobalReplace.
+   */
   re2_pattern *p;
   string str_as_string(StringValuePtr(str));
 
@@ -1455,8 +1504,8 @@ static VALUE re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern,
     RE2::GlobalReplace(&str_as_string, StringValuePtr(pattern),
                        StringValuePtr(rewrite));
 
-    return ENCODED_STR_NEW2(str_as_string.data(), str_as_string.size(),
-        pattern);
+    return ENCODED_STR_NEW(str_as_string.data(), str_as_string.size(),
+        "UTF-8");
   }
 }
 
@@ -1579,11 +1628,12 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
  *   set.add("def")    #=> 1
  */
 static VALUE re2_set_add(VALUE self, VALUE pattern) {
-  Check_Type(pattern, T_STRING);
+  StringValue(pattern);
   re2::StringPiece regex(RSTRING_PTR(pattern), RSTRING_LEN(pattern));
   std::string err;
   re2_set *s;
   Data_Get_Struct(self, re2_set, s);
+
   int index = s->set->Add(regex, &err);
   if (index < 0) {
     rb_raise(rb_eArgError, "str rejected by RE2::Set->Add(): %s", err.c_str());
@@ -1669,7 +1719,8 @@ static VALUE re2_set_match(int argc, VALUE *argv, VALUE self) {
   VALUE str, options, exception_option;
   bool raise_exception = true;
   rb_scan_args(argc, argv, "11", &str, &options);
-  Check_Type(str, T_STRING);
+
+  StringValue(str);
   re2::StringPiece data(RSTRING_PTR(str), RSTRING_LEN(str));
   std::vector<int> v;
   re2_set *s;

data/lib/re2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RE2
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end