re2 2.6.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3a48d6f5934da3afa8da05d7ed2dc3aae1aa69cb9b7507c91053a8fec672b9e
-  data.tar.gz: 9853896f0458f03ac39ea7a636211d423b16b33438b20c3eeae9780ce45f76d7
+  metadata.gz: a8d6ed54b0c51625b38158c82813c6b38f0151a637c224e6b6450ea2ebc9e00c
+  data.tar.gz: 9550936b7959af3654b58efdc07be5f5c38c3a41a4a657382878f06020f9081e
 SHA512:
-  metadata.gz: 59c5a3a9b16992364c3f17c6a546d45546620cb81add16eaeb584b98068cdc2aac3959a88bc87c1aa00fa18b909716d32eda04d0727695ef486fe2bacee9a899
-  data.tar.gz: 80f1f96454bb07d1495b02a378dfb04eacc64a9cd014386429bda129924d1043af800e31c26bc07710320aa786d7e51240640fc24bd232556649defeadc24a24
+  metadata.gz: f9b91c79e3efea56df671b887740c25e09e1d09e12383b6a3071c6bfcfccc01da3ea26431b34c6794fcf710bce17a71459f389911770ea06601048cc038c508f
+  data.tar.gz: a0f0d0971fa7074d5eccfca90bcdf058fcc02584f87c59531105cf04f1be872b97b213a4e17a5637e560b723f061ca95b2b7f4c782ce13a34234dfd134c3793e

data/.rspec

@@ -1,2 +1,3 @@
 --color
 --require spec_helper
+--format documentation

data/README.md

@@ -6,7 +6,7 @@ Python".
 
 [![Build Status](https://github.com/mudge/re2/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/mudge/re2/actions)
 
-**Current version:** 2.6.0  
+**Current version:** 2.7.0  
 **Bundled RE2 version:** libre2.11 (2023-11-01)  
 
 ```ruby
@@ -279,18 +279,18 @@ Where possible, a pre-compiled native gem will be provided for the following pla
 SHA256 checksums are included in the [release notes](https://github.com/mudge/re2/releases) for each version and can be checked with `sha256sum`, e.g.
 
 ```console
-$ gem fetch re2 -v 2.5.0
-Fetching re2-2.5.0-arm64-darwin.gem
-Downloaded re2-2.5.0-arm64-darwin
-$ sha256sum re2-2.5.0-arm64-darwin.gem
-4b20c4539a12787102b22012e678968af23f87e35f88843744835bd13ac9f6bc  re2-2.5.0-arm64-darwin.gem
+$ gem fetch re2 -v 2.6.0
+Fetching re2-2.6.0-arm64-darwin.gem
+Downloaded re2-2.6.0-arm64-darwin
+$ sha256sum re2-2.6.0-arm64-darwin.gem
+ba6fda7a29cd16179d5401c1b4917ba204c92e5ca9d25df80d840ed76fca439f  re2-2.6.0-arm64-darwin.gem
 ```
 
 [GPG](https://www.gnupg.org/) signatures are attached to each release (the assets ending in `.sig`) and can be verified if you import [our signing key `0x39AC3530070E0F75`](https://mudge.name/39AC3530070E0F75.asc) (or fetch it from a public keyserver, e.g. `gpg --keyserver keyserver.ubuntu.com --recv-key 0x39AC3530070E0F75`):
 
 ```console
-$ gpg --verify re2-2.5.0-arm64-darwin.gem.sig re2-2.5.0-arm64-darwin.gem
-gpg: Signature made Fri 15 Dec 2023 12:58:58 GMT
+$ gpg --verify re2-2.6.0-arm64-darwin.gem.sig re2-2.6.0-arm64-darwin.gem
+gpg: Signature made Wed 27 Dec 19:26:53 2023 GMT
 gpg:                using RSA key 702609D9C790F45B577D7BEC39AC3530070E0F75
 gpg: Good signature from "Paul Mucur <mudge@mudge.name>" [unknown]
 gpg:                 aka "Paul Mucur <paul@ghostcassette.com>" [unknown]
@@ -373,6 +373,8 @@ Alternatively, you can set the `RE2_USE_SYSTEM_LIBRARIES` environment variable i
 * Thanks to [Jean Boussier](https://github.com/byroot) for contributing the
   switch to Ruby's `TypedData` API and the resulting garbage collection
   improvements in 2.4.0.
+* Thanks to [Manuel Jacob](https://github.com/manueljacob) for reporting a bug
+  when passing strings with null bytes.
 
 ## Contact
 

data/ext/re2/re2.cc

@@ -336,7 +336,8 @@ static VALUE re2_scanner_rewind(VALUE self) {
   TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
 
   delete c->input;
-  c->input = new(std::nothrow) re2::StringPiece(RSTRING_PTR(c->text));
+  c->input = new(std::nothrow) re2::StringPiece(
+      RSTRING_PTR(c->text), RSTRING_LEN(c->text));
   c->eof = false;
 
   return self;
@@ -425,10 +426,20 @@ static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
 
   if (FIXNUM_P(idx)) {
     id = FIX2INT(idx);
+  } else if (SYMBOL_P(idx)) {
+    const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
+    std::map<std::string, int>::const_iterator search = groups.find(rb_id2name(SYM2ID(idx)));
+
+    if (search != groups.end()) {
+      id = search->second;
+    } else {
+      return NULL;
+    }
   } else {
-    const char *name = SYMBOL_P(idx) ? rb_id2name(SYM2ID(idx)) : StringValuePtr(idx);
+    StringValue(idx);
+
     const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
-    std::map<std::string, int>::const_iterator search = groups.find(name);
+    std::map<std::string, int>::const_iterator search = groups.find(std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)));
 
     if (search != groups.end()) {
       id = search->second;
@@ -611,7 +622,7 @@ static VALUE re2_matchdata_nth_match(int nth, const VALUE self) {
   }
 }
 
-static VALUE re2_matchdata_named_match(const char* name, const VALUE self) {
+static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
 
@@ -678,7 +689,8 @@ 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(RSTRING_PTR(idx), self);
+    return re2_matchdata_named_match(
+        std::string(RSTRING_PTR(idx), RSTRING_LEN(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) {
@@ -731,7 +743,8 @@ static VALUE re2_matchdata_inspect(const VALUE self) {
     if (match == Qnil) {
       output << "nil";
     } else {
-      output << "\"" << RSTRING_PTR(match) << "\"";
+      output << "\"" << re2::StringPiece(RSTRING_PTR(match),
+          RSTRING_LEN(match)) << "\"";
     }
   }
 
@@ -910,9 +923,11 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
     RE2::Options re2_options;
     parse_re2_options(&re2_options, options);
 
-    p->pattern = new(std::nothrow) RE2(RSTRING_PTR(pattern), re2_options);
+    p->pattern = new(std::nothrow) RE2(
+        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)), re2_options);
   } else {
-    p->pattern = new(std::nothrow) RE2(RSTRING_PTR(pattern));
+    p->pattern = new(std::nothrow) RE2(
+        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)));
   }
 
   if (p->pattern == 0) {
@@ -1501,11 +1516,13 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
 
   if (n == 0) {
 #ifdef HAVE_ENDPOS_ARGUMENT
-    bool matched = p->pattern->Match(RSTRING_PTR(text), startpos,
-        endpos, anchor, 0, 0);
+    bool matched = p->pattern->Match(
+        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
+        startpos, endpos, anchor, 0, 0);
 #else
-    bool matched = p->pattern->Match(RSTRING_PTR(text), startpos, anchor,
-        0, 0);
+    bool matched = p->pattern->Match(
+        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
+        startpos, anchor, 0, 0);
 #endif
     return BOOL2RUBY(matched);
   } else {
@@ -1529,11 +1546,13 @@ 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(RSTRING_PTR(m->text), startpos,
-        endpos, anchor, m->matches, n);
+    bool matched = p->pattern->Match(
+        re2::StringPiece(RSTRING_PTR(m->text), RSTRING_LEN(m->text)),
+        startpos, endpos, anchor, m->matches, n);
 #else
-    bool matched = p->pattern->Match(RSTRING_PTR(m->text), startpos,
-        anchor, m->matches, n);
+    bool matched = p->pattern->Match(
+        re2::StringPiece(RSTRING_PTR(m->text), RSTRING_LEN(m->text)),
+        startpos, anchor, m->matches, n);
 #endif
     if (matched) {
       return matchdata;
@@ -1559,7 +1578,8 @@ static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
 
   TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
-  return BOOL2RUBY(RE2::PartialMatch(RSTRING_PTR(text), *p->pattern));
+  return BOOL2RUBY(RE2::PartialMatch(
+        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)), *p->pattern));
 }
 
 /*
@@ -1578,7 +1598,8 @@ static VALUE re2_regexp_full_match_p(const VALUE self, VALUE text) {
 
   TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
-  return BOOL2RUBY(RE2::FullMatch(RSTRING_PTR(text), *p->pattern));
+  return BOOL2RUBY(RE2::FullMatch(
+        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)), *p->pattern));
 }
 
 /*
@@ -1604,7 +1625,8 @@ static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
   VALUE scanner = rb_class_new_instance(0, 0, re2_cScanner);
   TypedData_Get_Struct(scanner, re2_scanner, &re2_scanner_data_type, c);
 
-  c->input = new(std::nothrow) re2::StringPiece(RSTRING_PTR(text));
+  c->input = new(std::nothrow) re2::StringPiece(
+      RSTRING_PTR(text), RSTRING_LEN(text));
   RB_OBJ_WRITE(scanner, &c->regexp, self);
   RB_OBJ_WRITE(scanner, &c->text, text);
 
@@ -1669,12 +1691,14 @@ static VALUE re2_Replace(VALUE, VALUE str, VALUE pattern,
   /* Take a copy of str so it can be modified in-place by
    * RE2::Replace.
    */
-  std::string str_as_string(StringValuePtr(str));
+  StringValue(str);
+  std::string str_as_string(RSTRING_PTR(str), RSTRING_LEN(str));
 
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
     TypedData_Get_Struct(pattern, re2_pattern, &re2_regexp_data_type, p);
-    RE2::Replace(&str_as_string, *p->pattern, RSTRING_PTR(rewrite));
+    RE2::Replace(&str_as_string, *p->pattern,
+        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(),
         p->pattern->options().encoding());
@@ -1682,7 +1706,9 @@ static VALUE re2_Replace(VALUE, VALUE str, VALUE pattern,
     /* Ensure pattern is a string. */
     StringValue(pattern);
 
-    RE2::Replace(&str_as_string, RSTRING_PTR(pattern), RSTRING_PTR(rewrite));
+    RE2::Replace(&str_as_string,
+        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)),
+        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(), RE2::Options::EncodingUTF8);
   }
@@ -1717,12 +1743,14 @@ static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
    * RE2::GlobalReplace.
    */
   re2_pattern *p;
-  std::string str_as_string(StringValuePtr(str));
+  StringValue(str);
+  std::string str_as_string(RSTRING_PTR(str), RSTRING_LEN(str));
 
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
     TypedData_Get_Struct(pattern, re2_pattern, &re2_regexp_data_type, p);
-    RE2::GlobalReplace(&str_as_string, *p->pattern, RSTRING_PTR(rewrite));
+    RE2::GlobalReplace(&str_as_string, *p->pattern,
+        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(),
         p->pattern->options().encoding());
@@ -1730,8 +1758,9 @@ static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
     /* Ensure pattern is a string. */
     StringValue(pattern);
 
-    RE2::GlobalReplace(&str_as_string, RSTRING_PTR(pattern),
-        RSTRING_PTR(rewrite));
+    RE2::GlobalReplace(&str_as_string,
+        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)),
+        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(), RE2::Options::EncodingUTF8);
   }
@@ -1753,7 +1782,8 @@ static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
 static VALUE re2_QuoteMeta(VALUE, VALUE unquoted) {
   StringValue(unquoted);
 
-  std::string quoted_string = RE2::QuoteMeta(RSTRING_PTR(unquoted));
+  std::string quoted_string = RE2::QuoteMeta(
+      re2::StringPiece(RSTRING_PTR(unquoted), RSTRING_LEN(unquoted)));
 
   return rb_str_new(quoted_string.data(), quoted_string.size());
 }
@@ -1902,7 +1932,8 @@ static VALUE re2_set_add(VALUE self, VALUE pattern) {
 
   {
     std::string err;
-    index = s->set->Add(RSTRING_PTR(pattern), &err);
+    index = s->set->Add(
+        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)), &err);
     strlcpy(msg, err.c_str(), sizeof(msg));
   }
 
@@ -2009,7 +2040,8 @@ 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(RSTRING_PTR(str), &v, &e);
+    bool match_failed = !s->set->Match(
+        re2::StringPiece(RSTRING_PTR(str), RSTRING_LEN(str)), &v, &e);
     VALUE result = rb_ary_new2(v.size());
 
     if (match_failed) {
@@ -2036,7 +2068,8 @@ 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(RSTRING_PTR(str), &v);
+    bool matched = s->set->Match(
+        re2::StringPiece(RSTRING_PTR(str), RSTRING_LEN(str)), &v);
     VALUE result = rb_ary_new2(v.size());
 
     if (matched) {

data/lib/re2/version.rb

@@ -10,5 +10,5 @@
 
 
 module RE2
-  VERSION = "2.6.0"
+  VERSION = "2.7.0"
 end

data/spec/kernel_spec.rb

@@ -10,6 +10,12 @@ RSpec.describe Kernel do
       expect(re).not_to be_case_sensitive
     end
 
+    it "accepts patterns containing null bytes" do
+      re = RE2("a\0b")
+
+      expect(re.pattern).to eq("a\0b")
+    end
+
     it "raises an error if given an inappropriate type" do
       expect { RE2(nil) }.to raise_error(TypeError)
     end

data/spec/re2/match_data_spec.rb

@@ -190,7 +190,7 @@ RSpec.describe RE2::MatchData do
   describe "#inspect" do
     it "returns a text representation of the object and indices" do
       md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
- 
+
       expect(md.inspect).to eq('#<RE2::MatchData "1234 56" 1:"1234" 2:"56">')
     end
 
@@ -199,6 +199,12 @@ RSpec.describe RE2::MatchData do
 
       expect(md.inspect).to eq('#<RE2::MatchData "1234 " 1:"1234" 2:nil>')
     end
+
+    it "supports matches with null bytes" do
+      md = RE2::Regexp.new("(\\w\0\\w) (\\w\0\\w)").match("a\0b c\0d")
+
+      expect(md.inspect).to eq("#<RE2::MatchData \"a\0b c\0d\" 1:\"a\0b\" 2:\"c\0d\">")
+    end
   end
 
   describe "#to_s" do
@@ -239,6 +245,12 @@ RSpec.describe RE2::MatchData do
       expect(md.string[md.begin(:foo)..-1]).to eq('foobar')
     end
 
+    it "returns the offset of the start of a match by something that can be coerced to a String" do
+      md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
+
+      expect(md.string[md.begin(StringLike.new("foo"))..-1]).to eq('foobar')
+    end
+
     it "returns the offset despite multibyte characters" do
       md = RE2::Regexp.new('(Ruby)').match('I ♥ Ruby')
 
@@ -268,6 +280,12 @@ RSpec.describe RE2::MatchData do
 
       expect(md.begin(:foo)).to be_nil
     end
+
+    it "raises a type error if given an invalid name or number" do
+      md = RE2::Regexp.new('(\d)').match('123')
+
+      expect { md.begin(nil) }.to raise_error(TypeError)
+    end
   end
 
   describe "#end" do
@@ -289,6 +307,12 @@ RSpec.describe RE2::MatchData do
       expect(md.string[0...md.end(:foo)]).to eq('a foo')
     end
 
+    it "returns the offset of a match by something that can be coerced to a String" do
+      md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
+
+      expect(md.string[0...md.end(StringLike.new("foo"))]).to eq('a foo')
+    end
+
     it "returns the offset despite multibyte characters" do
       md = RE2::Regexp.new('(Ruby)').match('I ♥ Ruby')
 
@@ -318,6 +342,12 @@ RSpec.describe RE2::MatchData do
 
       expect(md.end(:foo)).to be_nil
     end
+
+    it "raises a type error if given an invalid name or number" do
+      md = RE2::Regexp.new('(\d)').match('123')
+
+      expect { md.end(nil) }.to raise_error(TypeError)
+    end
   end
 
   describe "#deconstruct" do

data/spec/re2/regexp_spec.rb

@@ -12,6 +12,12 @@ RSpec.describe RE2::Regexp do
       expect(re).to be_a(RE2::Regexp)
     end
 
+    it "accepts patterns containing null bytes" do
+      re = RE2::Regexp.new("a\0b")
+
+      expect(re.pattern).to eq("a\0b")
+    end
+
     it "raises an error if given an inappropriate type" do
       expect { RE2::Regexp.new(nil) }.to raise_error(TypeError)
     end
@@ -41,6 +47,12 @@ RSpec.describe RE2::Regexp do
       expect(re).to be_a(RE2::Regexp)
     end
 
+    it "accepts patterns containing null bytes" do
+      re = RE2::Regexp.compile("a\0b")
+
+      expect(re.pattern).to eq("a\0b")
+    end
+
     it "raises an error if given an inappropriate type" do
       expect { RE2::Regexp.compile(nil) }.to raise_error(TypeError)
     end
@@ -339,6 +351,12 @@ RSpec.describe RE2::Regexp do
       expect(re.match("My name is Alice Bloggs")).to eq(true)
     end
 
+    it "supports matching against text containing null bytes" do
+      re = RE2::Regexp.new("a\0b")
+
+      expect(re.match("a\0b")).to eq(true)
+    end
+
     it "returns nil if the text does not match the pattern" do
       re = RE2::Regexp.new('My name is (\w+) (\w+)')
 
@@ -511,6 +529,13 @@ RSpec.describe RE2::Regexp do
       expect(md[3]).to eq("three")
     end
 
+    it "supports extracting submatches containing null bytes" do
+      re = RE2::Regexp.new("(a\0b)")
+      md = re.match("a\0bc")
+
+      expect(md[1]).to eq("a\0b")
+    end
+
     it "extracts a specific number of submatches", :aggregate_failures do
       re = RE2::Regexp.new('(\w+) (\w+) (\w+)')
       md = re.match("one two three", submatches: 2)
@@ -599,6 +624,13 @@ RSpec.describe RE2::Regexp do
       expect(re.partial_match?("My age is 99")).to eq(false)
     end
 
+    it "supports matching against text containing null bytes", :aggregate_failures do
+      re = RE2::Regexp.new("a\0b")
+
+      expect(re.partial_match?("a\0b")).to eq(true)
+      expect(re.partial_match?("ab")).to eq(false)
+    end
+
     it "returns false if the pattern is invalid" do
       re = RE2::Regexp.new('???', log_errors: false)
 
@@ -620,6 +652,13 @@ RSpec.describe RE2::Regexp do
       expect(re =~ "My age is 99").to eq(false)
     end
 
+    it "supports matching against text containing null bytes", :aggregate_failures do
+      re = RE2::Regexp.new("a\0b")
+
+      expect(re =~ "a\0b").to eq(true)
+      expect(re =~ "ab").to eq(false)
+    end
+
     it "returns false if the pattern is invalid" do
       re = RE2::Regexp.new('???', log_errors: false)
 
@@ -662,6 +701,13 @@ RSpec.describe RE2::Regexp do
       expect(re.full_match?("My name is Alice Bloggs and I am 99")).to eq(false)
     end
 
+    it "supports matching against text containing null bytes", :aggregate_failures do
+      re = RE2::Regexp.new("a\0b")
+
+      expect(re.full_match?("a\0b")).to eq(true)
+      expect(re.full_match?("a\0bc")).to eq(false)
+    end
+
     it "returns false if the pattern is invalid" do
       re = RE2::Regexp.new('???', log_errors: false)
 
@@ -742,6 +788,12 @@ RSpec.describe RE2::Regexp do
 
       expect(scanner).to be_a(RE2::Scanner)
     end
+
+    it "raises a type error if given invalid input" do
+      r = RE2::Regexp.new('(\w+)')
+
+      expect { r.scan(nil) }.to raise_error(TypeError)
+    end
   end
 
   describe "#partial_match" do

data/spec/re2/scanner_spec.rb

@@ -34,6 +34,16 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
+    it "supports scanning inputs with null bytes", :aggregate_failures do
+      r = RE2::Regexp.new("(\\w\0\\w)")
+      scanner = r.scan("a\0b c\0d e\0f")
+
+      expect(scanner.scan).to eq(["a\0b"])
+      expect(scanner.scan).to eq(["c\0d"])
+      expect(scanner.scan).to eq(["e\0f"])
+      expect(scanner.scan).to be_nil
+    end
+
     it "returns UTF-8 matches if the pattern is UTF-8" do
       r = RE2::Regexp.new('(\w+)')
       scanner = r.scan("It")
@@ -190,6 +200,18 @@ RSpec.describe RE2::Scanner do
       expect(scanner.to_enum.first).to eq(["1"])
     end
 
+    it "supports inputs with null bytes", :aggregate_failures do
+      r = RE2::Regexp.new("(\\w\0\\w)")
+      scanner = r.scan("a\0b c\0d")
+
+      expect(scanner.to_enum.first).to eq(["a\0b"])
+      expect(scanner.to_enum.first).to eq(["c\0d"])
+
+      scanner.rewind
+
+      expect(scanner.to_enum.first).to eq(["a\0b"])
+    end
+
     it "resets the eof? check", :aggregate_failures do
       r = RE2::Regexp.new('(\d)')
       scanner = r.scan("1")

data/spec/re2/set_spec.rb

@@ -123,6 +123,14 @@ RSpec.describe RE2::Set do
       expect(set.match("def", exception: false)).to be_empty
     end
 
+    it "supports matching null bytes", :aggregate_failures do
+      set = RE2::Set.new
+      set.add("a\0b")
+      set.compile
+
+      expect(set.match("a\0b", exception: false)).to eq([0])
+    end
+
     it "returns an empty array if there is no match when :exception is true" do
       skip "Underlying RE2::Set::Match does not output error information" unless RE2::Set.match_raises_errors?
 

data/spec/re2_spec.rb

@@ -4,6 +4,18 @@ RSpec.describe RE2 do
       expect(RE2.Replace("woo", "o", "a")).to eq("wao")
     end
 
+    it "supports inputs with null bytes" do
+      expect(RE2.Replace("w\0oo", "o", "a")).to eq("w\0ao")
+    end
+
+    it "supports patterns with null bytes" do
+      expect(RE2.Replace("w\0oo", "\0", "o")).to eq("wooo")
+    end
+
+    it "supports replacements with null bytes" do
+      expect(RE2.Replace("woo", "o", "\0")).to eq("w\0o")
+    end
+
     it "performs replacement based on regular expressions" do
       expect(RE2.Replace("woo", "o+", "e")).to eq("we")
     end
@@ -82,6 +94,18 @@ RSpec.describe RE2 do
       expect(RE2.GlobalReplace("woo", "o", "a")).to eq("waa")
     end
 
+    it "supports inputs with null bytes" do
+      expect(RE2.GlobalReplace("w\0oo", "o", "a")).to eq("w\0aa")
+    end
+
+    it "supports patterns with null bytes" do
+      expect(RE2.GlobalReplace("w\0\0oo", "\0", "a")).to eq("waaoo")
+    end
+
+    it "supports replacements with null bytes" do
+      expect(RE2.GlobalReplace("woo", "o", "\0")).to eq("w\0\0")
+    end
+
     it "performs replacement based on regular expressions" do
       expect(RE2.GlobalReplace("woohoo", "o+", "e")).to eq("wehe")
     end
@@ -167,5 +191,9 @@ RSpec.describe RE2 do
     it "supports passing something that can be coerced to a String as input" do
       expect(RE2.QuoteMeta(StringLike.new("1.5"))).to eq('1\.5')
     end
+
+    it "supports strings containing null bytes" do
+      expect(RE2.QuoteMeta("abc\0def")).to eq('abc\x00def')
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 2.7.0
 platform: ruby
 authors:
 - Paul Mucur
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-27 00:00:00.000000000 Z
+date: 2024-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -120,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
 summary: Ruby bindings to RE2.