re2 2.1.2-x86_64-linux → 2.2.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76feae9ec4f5577a7c36c35a3d1c64759a1819e3f8e92eb178d0fa17e0a3d724
-  data.tar.gz: 6ea75776e67830df6709a6589f023018f2e2d0a285b995ca4d0766d5aa7c0613
+  metadata.gz: e9960963e5a225b22f605c8faae29f1d4cf14500479773e79cd8a16b9dead25f
+  data.tar.gz: 519de12c2db8a7a801b901b1a4b924dd45b727f2303eb0aafb7b1b42043b47a8
 SHA512:
-  metadata.gz: a4b5a6bbf14b798d7155c7d99babd596dd2f572cfd078c70344210b27a61aa17fd78876ba3a9d14cc86a734889dc9ed1514fb1d5631f639ff315039df61f5dea
-  data.tar.gz: 0b2cf44841ff83feef33f9049baf275f9ee36224806dab3c643ddeaf35b15a0afafbde21ced6c788d006da538da871f6a2bec91f7af4407876c66bfd2dc4a307
+  metadata.gz: 205b56ec06da2e759f9e1436552c3cd2ea3fa1d4905052d867b125c7cc7064fb2708b32a2da9aab40b4871a0207d725fb2fbbc0b90cc7fea59a41662dcadd1e8
+  data.tar.gz: 815b6a188aa125712c86e3ccae9bbd4e64e26eafd4d18c276f90d424a5685d26a7e1c675d6ba95bdcc8140869b2ee36751b339a21a5e61e68579f924b2cbe576

data/README.md

@@ -5,7 +5,7 @@ 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.1.2  
+**Current version:** 2.2.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)
@@ -264,6 +264,11 @@ Contributions
   using `RE2::Scanner#scan` with an invalid regular expression;
 * Thanks to [Pritam Baral](https://github.com/pritambaral) for contributing the
   initial support for `RE2::Set`.
+* Thanks to [Mike Dalessio](https://github.com/flavorjones) for reviewing the
+  precompilation of native gems in 2.0.
+* Thanks to [Peter Zhu](https://github.com/peterzhu2118) for
+  [ruby_memcheck](https://github.com/Shopify/ruby_memcheck) and helping find
+  the memory leaks fixed in 2.1.3.
 
 Contact
 -------

data/dependencies.yml

@@ -1,9 +1,7 @@
+---
 libre2:
-  version: "2023-09-01"
-  sha256: "5bb6875ae1cd1e9fedde98018c346db7260655f86fdb8837e3075103acd3649b"
-  # sha-256 hash provided in https://github.com/google/re2/releases/download/2023-09-01/re2-2023-09-01.tar.gz
-
+  version: '2023-09-01'
+  sha256: 5bb6875ae1cd1e9fedde98018c346db7260655f86fdb8837e3075103acd3649b
 abseil:
-  version: "20230125.3"
-  sha256: 5366d7e7fa7ba0d915014d387b66d0d002c03236448e1ba9ef98122c13b35c36
-  # sha-256 hash provided in https://github.com/abseil/abseil-cpp/archive/refs/tags/20230125.3.tar.gz
+  version: '20230802.1'
+  sha256: 987ce98f02eefbaf930d6e38ab16aa05737234d7afbab2d5c4ea7adbe50c28ed

data/ext/re2/extconf.rb

@@ -296,17 +296,18 @@ ABSL_LDFLAGS = %w[
   -labsl_crc32c
   -labsl_crc_internal
   -labsl_crc_cpu_detect
+  -labsl_raw_hash_set
   -labsl_hash
   -labsl_city
   -labsl_bad_variant_access
   -labsl_low_level_hash
-  -labsl_raw_hash_set
   -labsl_hashtablez_sampler
   -labsl_exponential_biased
   -labsl_bad_optional_access
   -labsl_str_format_internal
   -labsl_synchronization
   -labsl_graphcycles_internal
+  -labsl_kernel_timeout_internal
   -labsl_stacktrace
   -labsl_symbolize
   -ldbghelp
@@ -316,9 +317,10 @@ ABSL_LDFLAGS = %w[
   -labsl_time
   -labsl_civil_time
   -labsl_strings
+  -labsl_string_view
   -labsl_strings_internal
-  -ladvapi32
   -labsl_base
+  -ladvapi32
   -labsl_spinlock_wait
   -labsl_int128
   -labsl_throw_delegate
@@ -396,6 +398,8 @@ def build_with_vendored_libraries
 
   process_recipe(abseil_recipe) do |recipe|
     recipe.configure_options += ['-DABSL_PROPAGATE_CXX_STD=ON', '-DCMAKE_CXX_VISIBILITY_PRESET=hidden']
+    # Workaround for https://github.com/abseil/abseil-cpp/issues/1510
+    recipe.configure_options += ['-DCMAKE_CXX_FLAGS=-DABSL_FORCE_WAITER_MODE=4'] if windows?
   end
 
   process_recipe(re2_recipe) do |recipe|

data/ext/re2/re2.cc

@@ -19,7 +19,6 @@
 #include <ruby/encoding.h>
 
 #define BOOL2RUBY(v) (v ? Qtrue : Qfalse)
-#define UNUSED(x) ((void)x)
 
 typedef struct {
   RE2 *pattern;
@@ -228,7 +227,8 @@ static VALUE re2_scanner_rewind(VALUE self) {
   re2_scanner *c;
   Data_Get_Struct(self, re2_scanner, c);
 
-  c->input = new(std::nothrow) re2::StringPiece(StringValuePtr(c->text));
+  delete c->input;
+  c->input = new(std::nothrow) re2::StringPiece(RSTRING_PTR(c->text));
   c->eof = false;
 
   return self;
@@ -270,7 +270,7 @@ static VALUE re2_scanner_scan(VALUE self) {
     args[i] = &argv[i];
   }
 
-  if (RE2::FindAndConsumeN(c->input, *p->pattern, &args[0],
+  if (RE2::FindAndConsumeN(c->input, *p->pattern, args.data(),
         c->number_of_capturing_groups)) {
     re2::StringPiece::size_type new_input_size = c->input->size();
     bool input_advanced = new_input_size < original_input_size;
@@ -373,9 +373,9 @@ static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
   if (match == NULL) {
     return Qnil;
   } else {
-    long offset = match->data() - StringValuePtr(m->text);
+    long offset = match->data() - RSTRING_PTR(m->text);
 
-    return LONG2NUM(rb_str_sublen(StringValue(m->text), offset));
+    return LONG2NUM(rb_str_sublen(m->text, offset));
   }
 }
 
@@ -398,9 +398,9 @@ static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
   if (match == NULL) {
     return Qnil;
   } else {
-    long offset = (match->data() - StringValuePtr(m->text)) + match->size();
+    long offset = (match->data() - RSTRING_PTR(m->text)) + match->size();
 
-    return LONG2NUM(rb_str_sublen(StringValue(m->text), offset));
+    return LONG2NUM(rb_str_sublen(m->text, offset));
   }
 }
 
@@ -564,7 +564,7 @@ static VALUE re2_matchdata_aref(int argc, VALUE *argv, const VALUE self) {
   rb_scan_args(argc, argv, "11", &idx, &rest);
 
   if (TYPE(idx) == T_STRING) {
-    return re2_matchdata_named_match(StringValuePtr(idx), self);
+    return re2_matchdata_named_match(RSTRING_PTR(idx), self);
   } else if (SYMBOL_P(idx)) {
     return re2_matchdata_named_match(rb_id2name(SYM2ID(idx)), self);
   } else if (!NIL_P(rest) || !FIXNUM_P(idx) || FIX2INT(idx) < 0) {
@@ -617,7 +617,7 @@ static VALUE re2_matchdata_inspect(const VALUE self) {
     if (match == Qnil) {
       output << "nil";
     } else {
-      output << "\"" << StringValuePtr(match) << "\"";
+      output << "\"" << RSTRING_PTR(match) << "\"";
     }
   }
 
@@ -742,9 +742,7 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
  * @see RE2::Regexp#initialize
  *
  */
-static VALUE re2_re2(int argc, VALUE *argv, VALUE self) {
-  UNUSED(self);
-
+static VALUE re2_re2(int argc, VALUE *argv, VALUE) {
   return rb_class_new_instance(argc, argv, re2_cRegexp);
 }
 
@@ -788,15 +786,19 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
   re2_pattern *p;
 
   rb_scan_args(argc, argv, "11", &pattern, &options);
+
+  /* Ensure pattern is a string. */
+  StringValue(pattern);
+
   Data_Get_Struct(self, re2_pattern, p);
 
   if (RTEST(options)) {
     RE2::Options re2_options;
     parse_re2_options(&re2_options, options);
 
-    p->pattern = new(std::nothrow) RE2(StringValuePtr(pattern), re2_options);
+    p->pattern = new(std::nothrow) RE2(RSTRING_PTR(pattern), re2_options);
   } else {
-    p->pattern = new(std::nothrow) RE2(StringValuePtr(pattern));
+    p->pattern = new(std::nothrow) RE2(RSTRING_PTR(pattern));
   }
 
   if (p->pattern == 0) {
@@ -1285,10 +1287,10 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
 
   if (n == 0) {
 #ifdef HAVE_ENDPOS_ARGUMENT
-    bool matched = p->pattern->Match(StringValuePtr(text), 0,
+    bool matched = p->pattern->Match(RSTRING_PTR(text), 0,
         RSTRING_LEN(text), RE2::UNANCHORED, 0, 0);
 #else
-    bool matched = p->pattern->Match(StringValuePtr(text), 0, RE2::UNANCHORED,
+    bool matched = p->pattern->Match(RSTRING_PTR(text), 0, RE2::UNANCHORED,
         0, 0);
 #endif
     return BOOL2RUBY(matched);
@@ -1311,10 +1313,10 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
     m->number_of_matches = n;
 
 #ifdef HAVE_ENDPOS_ARGUMENT
-    bool matched = p->pattern->Match(StringValuePtr(m->text), 0,
+    bool matched = p->pattern->Match(RSTRING_PTR(m->text), 0,
         RSTRING_LEN(m->text), RE2::UNANCHORED, m->matches, n);
 #else
-    bool matched = p->pattern->Match(StringValuePtr(m->text), 0,
+    bool matched = p->pattern->Match(RSTRING_PTR(m->text), 0,
         RE2::UNANCHORED, m->matches, n);
 #endif
     if (matched) {
@@ -1344,6 +1346,9 @@ static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
  *   c = RE2::Regexp.new('(\w+)').scan("Foo bar baz")
  */
 static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
+  /* Ensure text is a string. */
+  StringValue(text);
+
   re2_pattern *p;
   re2_scanner *c;
 
@@ -1351,7 +1356,7 @@ static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
   VALUE scanner = rb_class_new_instance(0, 0, re2_cScanner);
   Data_Get_Struct(scanner, re2_scanner, c);
 
-  c->input = new(std::nothrow) re2::StringPiece(StringValuePtr(text));
+  c->input = new(std::nothrow) re2::StringPiece(RSTRING_PTR(text));
   c->regexp = self;
   c->text = text;
 
@@ -1383,9 +1388,11 @@ static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
  *   re2 = RE2::Regexp.new("hel+o")
  *   RE2.Replace("hello there", re2, "yo")        #=> "yo there"
  */
-static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
+static VALUE re2_Replace(VALUE, VALUE str, VALUE pattern,
     VALUE rewrite) {
-  UNUSED(self);
+  /* Ensure rewrite is a string. */
+  StringValue(rewrite);
+
   re2_pattern *p;
 
   /* Take a copy of str so it can be modified in-place by
@@ -1396,13 +1403,15 @@ static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
     Data_Get_Struct(pattern, re2_pattern, p);
-    RE2::Replace(&str_as_string, *p->pattern, StringValuePtr(rewrite));
+    RE2::Replace(&str_as_string, *p->pattern, RSTRING_PTR(rewrite));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(),
         p->pattern->options().encoding());
   } else {
-    RE2::Replace(&str_as_string, StringValuePtr(pattern),
-        StringValuePtr(rewrite));
+    /* Ensure pattern is a string. */
+    StringValue(pattern);
+
+    RE2::Replace(&str_as_string, RSTRING_PTR(pattern), RSTRING_PTR(rewrite));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(), RE2::Options::EncodingUTF8);
   }
@@ -1424,9 +1433,10 @@ static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
  *   RE2.GlobalReplace("whoops-doops", re2, "e")  #=> "wheps-deps"
  *   RE2.GlobalReplace("hello there", "e", "i")   #=> "hillo thiri"
  */
-static VALUE re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern,
+static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
                                VALUE rewrite) {
-  UNUSED(self);
+  /* Ensure rewrite is a string. */
+  StringValue(rewrite);
 
   /* Take a copy of str so it can be modified in-place by
    * RE2::GlobalReplace.
@@ -1437,13 +1447,16 @@ static VALUE re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern,
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
     Data_Get_Struct(pattern, re2_pattern, p);
-    RE2::GlobalReplace(&str_as_string, *p->pattern, StringValuePtr(rewrite));
+    RE2::GlobalReplace(&str_as_string, *p->pattern, RSTRING_PTR(rewrite));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(),
         p->pattern->options().encoding());
   } else {
-    RE2::GlobalReplace(&str_as_string, StringValuePtr(pattern),
-                       StringValuePtr(rewrite));
+    /* Ensure pattern is a string. */
+    StringValue(pattern);
+
+    RE2::GlobalReplace(&str_as_string, RSTRING_PTR(pattern),
+        RSTRING_PTR(rewrite));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(), RE2::Options::EncodingUTF8);
   }
@@ -1459,9 +1472,10 @@ static VALUE re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern,
  * @example
  *   RE2::Regexp.escape("1.5-2.0?")    #=> "1\.5\-2\.0\?"
  */
-static VALUE re2_QuoteMeta(VALUE self, VALUE unquoted) {
-  UNUSED(self);
-  std::string quoted_string = RE2::QuoteMeta(StringValuePtr(unquoted));
+static VALUE re2_QuoteMeta(VALUE, VALUE unquoted) {
+  StringValue(unquoted);
+
+  std::string quoted_string = RE2::QuoteMeta(RSTRING_PTR(unquoted));
 
   return rb_str_new(quoted_string.data(), quoted_string.size());
 }
@@ -1524,15 +1538,12 @@ static VALUE re2_set_allocate(VALUE klass) {
 static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
   VALUE anchor, options;
   re2_set *s;
-  RE2::Anchor re2_anchor = RE2::UNANCHORED;
-  RE2::Options re2_options;
 
   rb_scan_args(argc, argv, "02", &anchor, &options);
   Data_Get_Struct(self, re2_set, s);
 
-  if (RTEST(options)) {
-    parse_re2_options(&re2_options, options);
-  }
+  RE2::Anchor re2_anchor = RE2::UNANCHORED;
+
   if (!NIL_P(anchor)) {
     Check_Type(anchor, T_SYMBOL);
     ID id_anchor = SYM2ID(anchor);
@@ -1547,6 +1558,12 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
     }
   }
 
+  RE2::Options re2_options;
+
+  if (RTEST(options)) {
+    parse_re2_options(&re2_options, options);
+  }
+
   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");
@@ -1569,14 +1586,24 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
  */
 static VALUE re2_set_add(VALUE self, VALUE pattern) {
   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);
+  /* To prevent the memory of the err string leaking when we call rb_raise,
+   * take a copy of it and let it go out of scope.
+   */
+  char msg[100];
+  int index;
+
+  {
+    std::string err;
+    index = s->set->Add(RSTRING_PTR(pattern), &err);
+    strlcpy(msg, err.c_str(), sizeof(msg));
+  }
+
   if (index < 0) {
-    rb_raise(rb_eArgError, "str rejected by RE2::Set->Add(): %s", err.c_str());
+    rb_raise(rb_eArgError, "str rejected by RE2::Set->Add(): %s", msg);
   }
 
   return INT2FIX(index);
@@ -1606,8 +1633,7 @@ static VALUE re2_set_compile(VALUE self) {
  *
  * @return [Bool] whether the underlying re2 outputs error information from Set matches
  */
-static VALUE re2_set_match_raises_errors_p(VALUE self) {
-  UNUSED(self);
+static VALUE re2_set_match_raises_errors_p(VALUE) {
 #ifdef HAVE_ERROR_INFO_ARGUMENT
   return Qtrue;
 #else
@@ -1661,7 +1687,6 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
   rb_scan_args(argc, argv, "11", &str, &options);
 
   StringValue(str);
-  re2::StringPiece data(RSTRING_PTR(str), RSTRING_LEN(str));
   re2_set *s;
   Data_Get_Struct(self, re2_set, s);
 
@@ -1679,7 +1704,7 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
   if (raise_exception) {
 #ifdef HAVE_ERROR_INFO_ARGUMENT
     RE2::Set::ErrorInfo e;
-    bool match_failed = !s->set->Match(data, &v, &e);
+    bool match_failed = !s->set->Match(RSTRING_PTR(str), &v, &e);
     VALUE result = rb_ary_new2(v.size());
 
     if (match_failed) {
@@ -1706,7 +1731,7 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
     rb_raise(re2_eSetUnsupportedError, "current version of RE2::Set::Match() does not output error information, :exception option can only be set to false");
 #endif
   } else {
-    bool matched = s->set->Match(data, &v);
+    bool matched = s->set->Match(RSTRING_PTR(str), &v);
     VALUE result = rb_ary_new2(v.size());
 
     if (matched) {
@@ -1719,12 +1744,7 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
   }
 }
 
-/* Forward declare Init_re2 to be called by C code but define it separately so
- * that YARD can parse it.
- */
-extern "C" void Init_re2(void);
-
-void Init_re2(void) {
+extern "C" void Init_re2(void) {
   re2_mRE2 = rb_define_module("RE2");
   re2_cRegexp = rb_define_class_under(re2_mRE2, "Regexp", rb_cObject);
   re2_cMatchData = rb_define_class_under(re2_mRE2, "MatchData", rb_cObject);

data/ext/re2/recipes.rb

@@ -1,5 +1,5 @@
 PACKAGE_ROOT_DIR = File.expand_path('../..', __dir__)
-REQUIRED_MINI_PORTILE_VERSION = '~> 2.8.4' # keep this version in sync with the one in the gemspec
+REQUIRED_MINI_PORTILE_VERSION = '~> 2.8.5' # keep this version in sync with the one in the gemspec
 
 def build_recipe(name, version)
   require 'rubygems'
@@ -10,7 +10,7 @@ def build_recipe(name, version)
     recipe.target = File.join(PACKAGE_ROOT_DIR, 'ports')
     recipe.configure_options += [
       # abseil needs a C++14 compiler
-      '-DCMAKE_CXX_STANDARD=17',
+      '-DCMAKE_CXX_STANDARD=14',
       # needed for building the C extension shared library with -fPIC
       '-DCMAKE_POSITION_INDEPENDENT_CODE=ON',
       # ensures pkg-config and installed libraries will be in lib, not lib64

data/lib/re2/version.rb

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

data/re2.gemspec

@@ -40,5 +40,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency("rake-compiler", "~> 1.2.1")
   s.add_development_dependency("rake-compiler-dock", "~> 1.3.0")
   s.add_development_dependency("rspec", "~> 3.2")
-  s.add_runtime_dependency("mini_portile2", "~> 2.8.4") # keep version in sync with extconf.rb
+  s.add_runtime_dependency("mini_portile2", "~> 2.8.5") # keep version in sync with extconf.rb
 end

data/spec/kernel_spec.rb

@@ -9,5 +9,21 @@ RSpec.describe Kernel do
 
       expect(re).not_to be_case_sensitive
     end
+
+    it "raises an error if given an inappropriate type" do
+      expect { RE2(nil) }.to raise_error(TypeError)
+    end
+
+    it "allows invalid patterns to be created" do
+      re = RE2('???', :log_errors => false)
+
+      expect(re).to be_a(RE2::Regexp)
+    end
+
+    it "supports passing something that can be coerced to a String as input" do
+      re = RE2(StringLike.new('w(o)(o)'))
+
+      expect(re).to be_a(RE2::Regexp)
+    end
   end
 end

data/spec/re2/regexp_spec.rb

@@ -18,9 +18,15 @@ RSpec.describe RE2::Regexp do
       re = RE2::Regexp.new('???', :log_errors => false)
       expect(re).to be_a(RE2::Regexp)
     end
+
+    it "supports passing something that can be coerced to a String as input" do
+      re = RE2::Regexp.new(StringLike.new('w(o)(o)'))
+
+      expect(re).to be_a(RE2::Regexp)
+    end
   end
 
-  describe "#compile" do
+  describe ".compile" do
     it "returns an instance given only a pattern" do
       re = RE2::Regexp.compile('woo')
       expect(re).to be_a(RE2::Regexp)
@@ -31,10 +37,20 @@ RSpec.describe RE2::Regexp do
       expect(re).to be_a(RE2::Regexp)
     end
 
+    it "raises an error if given an inappropriate type" do
+      expect { RE2::Regexp.compile(nil) }.to raise_error(TypeError)
+    end
+
     it "allows invalid patterns to be created" do
       re = RE2::Regexp.compile('???', :log_errors => false)
       expect(re).to be_a(RE2::Regexp)
     end
+
+    it "supports passing something that can be coerced to a String as input" do
+      re = RE2::Regexp.compile(StringLike.new('w(o)(o)'))
+
+      expect(re).to be_a(RE2::Regexp)
+    end
   end
 
   describe "#options" do
@@ -59,7 +75,7 @@ RSpec.describe RE2::Regexp do
 
     it "is populated with overridden options when specified" do
       options = RE2::Regexp.new('woo', :case_sensitive => false).options
-      expect(options[:case_sensitive]).to eq(false)
+      expect(options).to include(:case_sensitive => false)
     end
   end
 
@@ -82,7 +98,7 @@ RSpec.describe RE2::Regexp do
       expect(error_arg).to be_nil
     end
 
-    it "returns the offending portin of the regexp if there is an error" do
+    it "returns the offending portion of the regexp if there is an error" do
       error_arg = RE2::Regexp.new('wo(o', :log_errors => false).error_arg
       expect(error_arg).to eq("wo(o")
     end

data/spec/re2/set_spec.rb

@@ -40,6 +40,13 @@ RSpec.describe RE2::Set do
         "anchor should be one of: :unanchored, :anchor_start, :anchor_both"
       )
     end
+
+    it "raises an error if given an invalid anchor and options" do
+      expect { RE2::Set.new(:not_a_valid_anchor, :case_sensitive => false) }.to raise_error(
+        ArgumentError,
+        "anchor should be one of: :unanchored, :anchor_start, :anchor_both"
+      )
+    end
   end
 
   describe "#add" do
@@ -54,7 +61,13 @@ RSpec.describe RE2::Set do
     it "rejects invalid patterns when added" do
       set = RE2::Set.new(:unanchored, :log_errors => false)
 
-      expect { set.add("???") }.to raise_error(ArgumentError, /str rejected by RE2::Set->Add()/)
+      expect { set.add("???") }.to raise_error(ArgumentError, /str rejected by RE2::Set->Add\(\)/)
+    end
+
+    it "truncates error messages to 100 characters" do
+      set = RE2::Set.new(:unanchored, :log_errors => false)
+
+      expect { set.add("(?P<#{'o' * 200}") }.to raise_error(ArgumentError, "str rejected by RE2::Set->Add(): invalid named capture group: (?P<oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo")
     end
 
     it "raises an error if called after #compile" do

data/spec/re2_spec.rb

@@ -12,11 +12,12 @@ RSpec.describe RE2 do
       expect(RE2.Replace("Good morning", "(?i)gOOD MORNING", "hi")).to eq("hi")
     end
 
-    it "does not perform replacements in-place" do
+    it "does not perform replacements in-place", :aggregate_failures do
       name = "Robert"
       replacement = RE2.Replace(name, "R", "Cr")
 
-      expect(name).not_to equal(replacement)
+      expect(name).to eq("Robert")
+      expect(replacement).to eq("Crobert")
     end
 
     it "supports passing an RE2::Regexp as the pattern" do
@@ -89,11 +90,12 @@ RSpec.describe RE2 do
       expect(RE2.GlobalReplace("Robert", "(?i)r", "w")).to eq("wobewt")
     end
 
-    it "does not perform replacement in-place" do
+    it "does not perform replacement in-place", :aggregate_failures do
       name = "Robert"
       replacement = RE2.GlobalReplace(name, "(?i)R", "w")
 
-      expect(name).not_to equal(replacement)
+      expect(name).to eq("Robert")
+      expect(replacement).to eq("wobewt")
     end
 
     it "supports passing an RE2::Regexp as the pattern" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 2.2.0
 platform: x86_64-linux
 authors:
 - Paul Mucur
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-20 00:00:00.000000000 Z
+date: 2023-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler