re2 2.4.0-x64-mingw-ucrt → 2.4.2-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f82759e0a40ad8d542bdea52b27997aef1f763750c796d7e82fbaebd4537784
-  data.tar.gz: 11593a4a9ae6b95682d2d19ac2f6424de8d21ee06a7b0a33f7e416e43dd4e25a
+  metadata.gz: c0f0ea10edaa6865dc09105438dba89970dcb401bf49d561d8e8ebfe7b194bd6
+  data.tar.gz: 93519d374b2f07d6ee4ba80c62e76ba8155275801965e67c7e96001ea421ddbf
 SHA512:
-  metadata.gz: 21616990d088253524c9ac2b9be755f287f3d4ddff0df2319e5bd64c1cbf4128a5fe8b20fd55871e48fe5af71ede5f49d99cc286f38dd1ed19be04797d528f5e
-  data.tar.gz: 53622a8442e6f24ef31b9f79aad4f47bcf2d6e34f691963b8497d9fe59bfb20ae3e80c20954e1f0faa672a6358731affb9200d670d2925505b82c75ace191850
+  metadata.gz: 4538c379a616eea0db1cd0bd91d6e6688e1f6752c9c551045fabd4e84c89857062002f2004dec3c229a6ab5a63d00481f7025562c78d2ac242ecb7264f48e155
+  data.tar.gz: d82ea9f337365512b248947637c1b1a37d6ea260ba76011ce6a3c52b6606e1240ac8a0addfc31a632a24039990584830581ed618b4aeb0999cd1b914ebd44b38

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.4.0  
+**Current version:** 2.4.2  
 **Supported Ruby versions:** 2.6, 2.7, 3.0, 3.1, 3.2  
 **Bundled RE2 version:** libre2.11 (2023-11-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)
@@ -256,13 +256,17 @@ 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;
+  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 [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;
+  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

data/ext/re2/re2.cc

@@ -130,33 +130,33 @@ static void parse_re2_options(RE2::Options* re2_options, const VALUE options) {
 #define re2_compact_callback(x)
 #endif
 
-static void re2_matchdata_mark(void *data) {
-  re2_matchdata *self = (re2_matchdata *)data;
-  rb_gc_mark_movable(self->regexp);
-  rb_gc_mark_movable(self->text);
+static void re2_matchdata_mark(void *ptr) {
+  re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
+  rb_gc_mark_movable(m->regexp);
+  rb_gc_mark_movable(m->text);
 }
 
 #ifdef HAVE_RB_GC_MARK_MOVABLE
-static void re2_matchdata_update_references(void *data) {
-  re2_matchdata *self = (re2_matchdata *)data;
-  self->regexp = rb_gc_location(self->regexp);
-  self->text = rb_gc_location(self->text);
+static void re2_matchdata_compact(void *ptr) {
+  re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
+  m->regexp = rb_gc_location(m->regexp);
+  m->text = rb_gc_location(m->text);
 }
 #endif
 
-static void re2_matchdata_free(void *data) {
-  re2_matchdata *self = (re2_matchdata *)data;
-  if (self->matches) {
-    delete[] self->matches;
+static void re2_matchdata_free(void *ptr) {
+  re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
+  if (m->matches) {
+    delete[] m->matches;
   }
-  xfree(self);
+  xfree(m);
 }
 
-static size_t re2_matchdata_memsize(const void *data) {
-  const re2_matchdata *self = (const re2_matchdata *)data;
-  size_t size = sizeof(re2_matchdata);
-  if (self->matches) {
-    size += sizeof(self->matches) * self->number_of_matches;
+static size_t re2_matchdata_memsize(const void *ptr) {
+  const re2_matchdata *m = reinterpret_cast<const re2_matchdata *>(ptr);
+  size_t size = sizeof(*m);
+  if (m->matches) {
+    size += sizeof(*m->matches) * m->number_of_matches;
   }
 
   return size;
@@ -168,40 +168,40 @@ static const rb_data_type_t re2_matchdata_data_type = {
     .dmark = re2_matchdata_mark,
     .dfree = re2_matchdata_free,
     .dsize = re2_matchdata_memsize,
-    re2_compact_callback(re2_matchdata_update_references)
+    re2_compact_callback(re2_matchdata_compact)
   },
   // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
   // macro to update VALUE references, as to trigger write barriers.
   .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
-static void re2_scanner_mark(void *data) {
-  re2_scanner *self = (re2_scanner *)data;
-  rb_gc_mark_movable(self->regexp);
-  rb_gc_mark_movable(self->text);
+static void re2_scanner_mark(void *ptr) {
+  re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
+  rb_gc_mark_movable(s->regexp);
+  rb_gc_mark_movable(s->text);
 }
 
 #ifdef HAVE_RB_GC_MARK_MOVABLE
-static void re2_scanner_update_references(void *data) {
-  re2_scanner *self = (re2_scanner *)data;
-  self->regexp = rb_gc_location(self->regexp);
-  self->text = rb_gc_location(self->text);
+static void re2_scanner_compact(void *ptr) {
+  re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
+  s->regexp = rb_gc_location(s->regexp);
+  s->text = rb_gc_location(s->text);
 }
 #endif
 
-static void re2_scanner_free(void *data) {
-  re2_scanner *self = (re2_scanner *)data;
-  if (self->input) {
-    delete self->input;
+static void re2_scanner_free(void *ptr) {
+  re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
+  if (s->input) {
+    delete s->input;
   }
-  xfree(self);
+  xfree(s);
 }
 
-static size_t re2_scanner_memsize(const void *data) {
-  const re2_scanner *self = (const re2_scanner *)data;
-  size_t size = sizeof(re2_scanner);
-  if (self->input) {
-    size += sizeof(self->input);
+static size_t re2_scanner_memsize(const void *ptr) {
+  const re2_scanner *s = reinterpret_cast<const re2_scanner *>(ptr);
+  size_t size = sizeof(*s);
+  if (s->input) {
+    size += sizeof(*s->input);
   }
 
   return size;
@@ -213,26 +213,26 @@ static const rb_data_type_t re2_scanner_data_type = {
     .dmark = re2_scanner_mark,
     .dfree = re2_scanner_free,
     .dsize = re2_scanner_memsize,
-    re2_compact_callback(re2_scanner_update_references)
+    re2_compact_callback(re2_scanner_compact)
   },
   // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
   // macro to update VALUE references, as to trigger write barriers.
   .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
-static void re2_regexp_free(void *data) {
-  re2_pattern *self = (re2_pattern *)data;
-  if (self->pattern) {
-    delete self->pattern;
+static void re2_regexp_free(void *ptr) {
+  re2_pattern *p = reinterpret_cast<re2_pattern *>(ptr);
+  if (p->pattern) {
+    delete p->pattern;
   }
-  xfree(self);
+  xfree(p);
 }
 
-static size_t re2_regexp_memsize(const void *data) {
-  const re2_pattern *self = (const re2_pattern *)data;
-  size_t size = sizeof(re2_pattern);
-  if (self->pattern) {
-    size += sizeof(self->pattern);
+static size_t re2_regexp_memsize(const void *ptr) {
+  const re2_pattern *p = reinterpret_cast<const re2_pattern *>(ptr);
+  size_t size = sizeof(*p);
+  if (p->pattern) {
+    size += sizeof(*p->pattern);
   }
 
   return size;
@@ -1579,19 +1579,19 @@ static VALUE re2_QuoteMeta(VALUE, VALUE unquoted) {
   return rb_str_new(quoted_string.data(), quoted_string.size());
 }
 
-static void re2_set_free(void *data) {
-  re2_set *self = (re2_set *)data;
-  if (self->set) {
-    delete self->set;
+static void re2_set_free(void *ptr) {
+  re2_set *s = reinterpret_cast<re2_set *>(ptr);
+  if (s->set) {
+    delete s->set;
   }
-  xfree(self);
+  xfree(s);
 }
 
-static size_t re2_set_memsize(const void *data) {
-  const re2_set *self = (const re2_set *)data;
-  size_t size = sizeof(re2_set);
-  if (self->set) {
-    size += sizeof(self->set);
+static size_t re2_set_memsize(const void *ptr) {
+  const re2_set *s = reinterpret_cast<const re2_set *>(ptr);
+  size_t size = sizeof(*s);
+  if (s->set) {
+    size += sizeof(*s->set);
   }
 
   return size;
@@ -1877,12 +1877,14 @@ extern "C" void Init_re2(void) {
   re2_eSetUnsupportedError = rb_define_class_under(re2_cSet, "UnsupportedError",
       rb_const_get(rb_cObject, rb_intern("StandardError")));
 
-  rb_define_alloc_func(re2_cRegexp, (VALUE (*)(VALUE))re2_regexp_allocate);
+  rb_define_alloc_func(re2_cRegexp,
+      reinterpret_cast<VALUE (*)(VALUE)>(re2_regexp_allocate));
   rb_define_alloc_func(re2_cMatchData,
-      (VALUE (*)(VALUE))re2_matchdata_allocate);
+      reinterpret_cast<VALUE (*)(VALUE)>(re2_matchdata_allocate));
   rb_define_alloc_func(re2_cScanner,
-      (VALUE (*)(VALUE))re2_scanner_allocate);
-  rb_define_alloc_func(re2_cSet, (VALUE (*)(VALUE))re2_set_allocate);
+      reinterpret_cast<VALUE (*)(VALUE)>(re2_scanner_allocate));
+  rb_define_alloc_func(re2_cSet,
+      reinterpret_cast<VALUE (*)(VALUE)>(re2_set_allocate));
 
   rb_define_method(re2_cMatchData, "string",
       RUBY_METHOD_FUNC(re2_matchdata_string), 0);

data/lib/re2/version.rb

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

data/re2.gemspec

@@ -11,7 +11,6 @@ Gem::Specification.new do |s|
   s.license = "BSD-3-Clause"
   s.required_ruby_version = ">= 2.6.0"
   s.files = [
-    ".rspec",
     "dependencies.yml",
     "ext/re2/extconf.rb",
     "ext/re2/re2.cc",
@@ -28,6 +27,7 @@ Gem::Specification.new do |s|
     "re2.gemspec"
   ]
   s.test_files = [
+    ".rspec",
     "spec/spec_helper.rb",
     "spec/re2_spec.rb",
     "spec/kernel_spec.rb",

data/spec/re2/match_data_spec.rb

@@ -1,5 +1,14 @@
 # encoding: utf-8
+require 'objspace'
+
 RSpec.describe RE2::MatchData do
+  it "reports a larger consuming memory size when it has more matches" do
+    matches1 = RE2::Regexp.new('w(o)').match('woo')
+    matches2 = RE2::Regexp.new('w(o)(o)').match('woo')
+
+    expect(ObjectSpace.memsize_of(matches1)).to be < ObjectSpace.memsize_of(matches2)
+  end
+
   describe "#to_a" do
     it "is populated with the match and capturing groups" do
       a = RE2::Regexp.new('w(o)(o)').match('woo').to_a

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.4.2
 platform: x64-mingw-ucrt
 authors:
 - Paul Mucur
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-11-11 00:00:00.000000000 Z
+date: 2023-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -112,6 +112,7 @@ signing_key:
 specification_version: 4
 summary: Ruby bindings to RE2.
 test_files:
+- ".rspec"
 - spec/spec_helper.rb
 - spec/re2_spec.rb
 - spec/kernel_spec.rb