re2 2.4.0-x86_64-darwin → 2.4.1-x86_64-darwin

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: edf1c7e3653b56292efc8e46bb85ab926a458dee95c9a9557f45ae027bef8634
4
- data.tar.gz: 5c768b4d45614caa2caa3e301e4cf672fc97d65986f93bda22677455678d6510
3
+ metadata.gz: bf33390b57a9ac1f50def820182c027a4a4d2a79cf6d120d9a835d701c2df96f
4
+ data.tar.gz: ad0f77f22597ef72d8b593dad32d5c0316d6873a4e77a914db0807c457509fe5
5
5
  SHA512:
6
- metadata.gz: feae473be7b1d2bba5241c9f1e2865853a0a72de488e2cec72a46d60dad1e804e9c2051c5147a561f353a061d4e937cf11f4a3d9cd9fbe0f91377c64375d163e
7
- data.tar.gz: 22a6791f535fd6a32dcd94f1d2b8f01532e2396395b3a566836811c6d28c93b091729081f4b374d0a0d783b7e115911d2d1efb3be933beefeaaababf83ed70ae
6
+ metadata.gz: 40431501e5e3c37b900034d07ed01a0aca8f2098502bd3b8c72cb0ef0d7fe146f0d25d36e2416ef404c8c473f0ad2bcf646bfd9bb587de863b9c9254d11e5b1d
7
+ data.tar.gz: a1ea0a37ea7229945421f0a93e235c9fba3ee998e21fa06e6327bc9b1498d62334782e598dfbd765da01e5411846343cf543bab8a42b5ce450df94ab13a6488a
data/README.md CHANGED
@@ -5,7 +5,7 @@ Ruby bindings to [RE2][], a "fast, safe, thread-friendly alternative to
5
5
  backtracking regular expression engines like those used in PCRE, Perl, and
6
6
  Python".
7
7
 
8
- **Current version:** 2.4.0
8
+ **Current version:** 2.4.1
9
9
  **Supported Ruby versions:** 2.6, 2.7, 3.0, 3.1, 3.2
10
10
  **Bundled RE2 version:** libre2.11 (2023-11-01)
11
11
  **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)
data/ext/re2/re2.cc CHANGED
@@ -130,33 +130,33 @@ static void parse_re2_options(RE2::Options* re2_options, const VALUE options) {
130
130
  #define re2_compact_callback(x)
131
131
  #endif
132
132
 
133
- static void re2_matchdata_mark(void *data) {
134
- re2_matchdata *self = (re2_matchdata *)data;
135
- rb_gc_mark_movable(self->regexp);
136
- rb_gc_mark_movable(self->text);
133
+ static void re2_matchdata_mark(void *ptr) {
134
+ re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
135
+ rb_gc_mark_movable(m->regexp);
136
+ rb_gc_mark_movable(m->text);
137
137
  }
138
138
 
139
139
  #ifdef HAVE_RB_GC_MARK_MOVABLE
140
- static void re2_matchdata_update_references(void *data) {
141
- re2_matchdata *self = (re2_matchdata *)data;
142
- self->regexp = rb_gc_location(self->regexp);
143
- self->text = rb_gc_location(self->text);
140
+ static void re2_matchdata_compact(void *ptr) {
141
+ re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
142
+ m->regexp = rb_gc_location(m->regexp);
143
+ m->text = rb_gc_location(m->text);
144
144
  }
145
145
  #endif
146
146
 
147
- static void re2_matchdata_free(void *data) {
148
- re2_matchdata *self = (re2_matchdata *)data;
149
- if (self->matches) {
150
- delete[] self->matches;
147
+ static void re2_matchdata_free(void *ptr) {
148
+ re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
149
+ if (m->matches) {
150
+ delete[] m->matches;
151
151
  }
152
- xfree(self);
152
+ xfree(m);
153
153
  }
154
154
 
155
- static size_t re2_matchdata_memsize(const void *data) {
156
- const re2_matchdata *self = (const re2_matchdata *)data;
157
- size_t size = sizeof(re2_matchdata);
158
- if (self->matches) {
159
- size += sizeof(self->matches) * self->number_of_matches;
155
+ static size_t re2_matchdata_memsize(const void *ptr) {
156
+ const re2_matchdata *m = reinterpret_cast<const re2_matchdata *>(ptr);
157
+ size_t size = sizeof(*m);
158
+ if (m->matches) {
159
+ size += sizeof(*m->matches) * m->number_of_matches;
160
160
  }
161
161
 
162
162
  return size;
@@ -168,40 +168,40 @@ static const rb_data_type_t re2_matchdata_data_type = {
168
168
  .dmark = re2_matchdata_mark,
169
169
  .dfree = re2_matchdata_free,
170
170
  .dsize = re2_matchdata_memsize,
171
- re2_compact_callback(re2_matchdata_update_references)
171
+ re2_compact_callback(re2_matchdata_compact)
172
172
  },
173
173
  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
174
174
  // macro to update VALUE references, as to trigger write barriers.
175
175
  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
176
176
  };
177
177
 
178
- static void re2_scanner_mark(void *data) {
179
- re2_scanner *self = (re2_scanner *)data;
180
- rb_gc_mark_movable(self->regexp);
181
- rb_gc_mark_movable(self->text);
178
+ static void re2_scanner_mark(void *ptr) {
179
+ re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
180
+ rb_gc_mark_movable(s->regexp);
181
+ rb_gc_mark_movable(s->text);
182
182
  }
183
183
 
184
184
  #ifdef HAVE_RB_GC_MARK_MOVABLE
185
- static void re2_scanner_update_references(void *data) {
186
- re2_scanner *self = (re2_scanner *)data;
187
- self->regexp = rb_gc_location(self->regexp);
188
- self->text = rb_gc_location(self->text);
185
+ static void re2_scanner_compact(void *ptr) {
186
+ re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
187
+ s->regexp = rb_gc_location(s->regexp);
188
+ s->text = rb_gc_location(s->text);
189
189
  }
190
190
  #endif
191
191
 
192
- static void re2_scanner_free(void *data) {
193
- re2_scanner *self = (re2_scanner *)data;
194
- if (self->input) {
195
- delete self->input;
192
+ static void re2_scanner_free(void *ptr) {
193
+ re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
194
+ if (s->input) {
195
+ delete s->input;
196
196
  }
197
- xfree(self);
197
+ xfree(s);
198
198
  }
199
199
 
200
- static size_t re2_scanner_memsize(const void *data) {
201
- const re2_scanner *self = (const re2_scanner *)data;
202
- size_t size = sizeof(re2_scanner);
203
- if (self->input) {
204
- size += sizeof(self->input);
200
+ static size_t re2_scanner_memsize(const void *ptr) {
201
+ const re2_scanner *s = reinterpret_cast<const re2_scanner *>(ptr);
202
+ size_t size = sizeof(*s);
203
+ if (s->input) {
204
+ size += sizeof(s->input);
205
205
  }
206
206
 
207
207
  return size;
@@ -213,26 +213,26 @@ static const rb_data_type_t re2_scanner_data_type = {
213
213
  .dmark = re2_scanner_mark,
214
214
  .dfree = re2_scanner_free,
215
215
  .dsize = re2_scanner_memsize,
216
- re2_compact_callback(re2_scanner_update_references)
216
+ re2_compact_callback(re2_scanner_compact)
217
217
  },
218
218
  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
219
219
  // macro to update VALUE references, as to trigger write barriers.
220
220
  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
221
221
  };
222
222
 
223
- static void re2_regexp_free(void *data) {
224
- re2_pattern *self = (re2_pattern *)data;
225
- if (self->pattern) {
226
- delete self->pattern;
223
+ static void re2_regexp_free(void *ptr) {
224
+ re2_pattern *p = reinterpret_cast<re2_pattern *>(ptr);
225
+ if (p->pattern) {
226
+ delete p->pattern;
227
227
  }
228
- xfree(self);
228
+ xfree(p);
229
229
  }
230
230
 
231
- static size_t re2_regexp_memsize(const void *data) {
232
- const re2_pattern *self = (const re2_pattern *)data;
233
- size_t size = sizeof(re2_pattern);
234
- if (self->pattern) {
235
- size += sizeof(self->pattern);
231
+ static size_t re2_regexp_memsize(const void *ptr) {
232
+ const re2_pattern *p = reinterpret_cast<const re2_pattern *>(ptr);
233
+ size_t size = sizeof(*p);
234
+ if (p->pattern) {
235
+ size += sizeof(p->pattern);
236
236
  }
237
237
 
238
238
  return size;
@@ -1579,19 +1579,19 @@ static VALUE re2_QuoteMeta(VALUE, VALUE unquoted) {
1579
1579
  return rb_str_new(quoted_string.data(), quoted_string.size());
1580
1580
  }
1581
1581
 
1582
- static void re2_set_free(void *data) {
1583
- re2_set *self = (re2_set *)data;
1584
- if (self->set) {
1585
- delete self->set;
1582
+ static void re2_set_free(void *ptr) {
1583
+ re2_set *s = reinterpret_cast<re2_set *>(ptr);
1584
+ if (s->set) {
1585
+ delete s->set;
1586
1586
  }
1587
- xfree(self);
1587
+ xfree(s);
1588
1588
  }
1589
1589
 
1590
- static size_t re2_set_memsize(const void *data) {
1591
- const re2_set *self = (const re2_set *)data;
1592
- size_t size = sizeof(re2_set);
1593
- if (self->set) {
1594
- size += sizeof(self->set);
1590
+ static size_t re2_set_memsize(const void *ptr) {
1591
+ const re2_set *s = reinterpret_cast<const re2_set *>(ptr);
1592
+ size_t size = sizeof(*s);
1593
+ if (s->set) {
1594
+ size += sizeof(s->set);
1595
1595
  }
1596
1596
 
1597
1597
  return size;
@@ -1877,12 +1877,14 @@ extern "C" void Init_re2(void) {
1877
1877
  re2_eSetUnsupportedError = rb_define_class_under(re2_cSet, "UnsupportedError",
1878
1878
  rb_const_get(rb_cObject, rb_intern("StandardError")));
1879
1879
 
1880
- rb_define_alloc_func(re2_cRegexp, (VALUE (*)(VALUE))re2_regexp_allocate);
1880
+ rb_define_alloc_func(re2_cRegexp,
1881
+ reinterpret_cast<VALUE (*)(VALUE)>(re2_regexp_allocate));
1881
1882
  rb_define_alloc_func(re2_cMatchData,
1882
- (VALUE (*)(VALUE))re2_matchdata_allocate);
1883
+ reinterpret_cast<VALUE (*)(VALUE)>(re2_matchdata_allocate));
1883
1884
  rb_define_alloc_func(re2_cScanner,
1884
- (VALUE (*)(VALUE))re2_scanner_allocate);
1885
- rb_define_alloc_func(re2_cSet, (VALUE (*)(VALUE))re2_set_allocate);
1885
+ reinterpret_cast<VALUE (*)(VALUE)>(re2_scanner_allocate));
1886
+ rb_define_alloc_func(re2_cSet,
1887
+ reinterpret_cast<VALUE (*)(VALUE)>(re2_set_allocate));
1886
1888
 
1887
1889
  rb_define_method(re2_cMatchData, "string",
1888
1890
  RUBY_METHOD_FUNC(re2_matchdata_string), 0);
data/lib/2.6/re2.bundle CHANGED
Binary file
data/lib/2.7/re2.bundle CHANGED
Binary file
data/lib/3.0/re2.bundle CHANGED
Binary file
data/lib/3.1/re2.bundle CHANGED
Binary file
data/lib/3.2/re2.bundle CHANGED
Binary file
data/lib/re2/version.rb CHANGED
@@ -1,5 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module RE2
4
- VERSION = "2.4.0"
4
+ VERSION = "2.4.1"
5
5
  end
@@ -1,5 +1,14 @@
1
1
  # encoding: utf-8
2
+ require 'objspace'
3
+
2
4
  RSpec.describe RE2::MatchData do
5
+ it "reports a larger consuming memory size when it has more matches" do
6
+ matches1 = RE2::Regexp.new('w(o)').match('woo')
7
+ matches2 = RE2::Regexp.new('w(o)(o)').match('woo')
8
+
9
+ expect(ObjectSpace.memsize_of(matches1)).to be < ObjectSpace.memsize_of(matches2)
10
+ end
11
+
3
12
  describe "#to_a" do
4
13
  it "is populated with the match and capturing groups" do
5
14
  a = RE2::Regexp.new('w(o)(o)').match('woo').to_a
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: re2
3
3
  version: !ruby/object:Gem::Version
4
- version: 2.4.0
4
+ version: 2.4.1
5
5
  platform: x86_64-darwin
6
6
  authors:
7
7
  - Paul Mucur
@@ -9,7 +9,7 @@ authors:
9
9
  autorequire:
10
10
  bindir: bin
11
11
  cert_chain: []
12
- date: 2023-11-11 00:00:00.000000000 Z
12
+ date: 2023-11-12 00:00:00.000000000 Z
13
13
  dependencies:
14
14
  - !ruby/object:Gem::Dependency
15
15
  name: rake-compiler