re2 2.1.2-x86-mingw32 → 2.1.3-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab599000dfb33c1200683b60fb45333a9d785acda13225540d41af61e6c310cf
-  data.tar.gz: 968de19db8cf58c43999e4e8b27c6995d7b41926e032c111a732d6bca809dfed
+  metadata.gz: 7a0557a520ec493402a6b3ebf158e0a7463144d08948cb3746aab5c70e96e948
+  data.tar.gz: 0a4c6ce16e51a1acd2d2c7a425abcd59b3b5cf61da0ef14fa7e58641813e7d4b
 SHA512:
-  metadata.gz: 14b1fcbdabf269acaa435bc1becb5b83e88a339d1fc01c74e311dbeb43779f26d1461fa091fbafa55306a37cef020bae478b386d92360b5485894bd63a8b645e
-  data.tar.gz: 45c89c83591a1eb4b6610df6828268056f414ddf94cf2d3cb25c8749bf62b99a323befdf1909fe5b359be633f073439a7b34f2432ef5985b45b61f6aaf776ea7
+  metadata.gz: 0d9316a0159328eac49841e938ef5d548efa57c1d23a1481faef14bf27da13b86cbba0d1acef2dd04b4db174e128508aa4d8f008a5a89c3c42efa57c285eba5c
+  data.tar.gz: 35993c2e282308d076a2ed85ec0ec410b3539110c9e35469484d4d167462808a263da2816496a1e7a7b70a18a1f660a2fc5f43c4aa8f672749861f223a9655e8

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.1.3  
 **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/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/lib/re2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RE2
-  VERSION = "2.1.2"
+  VERSION = "2.1.3"
 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

metadata

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