re2 0.0.2 → 0.0.3

data/ext/re2/re2.cc

@@ -19,16 +19,16 @@ extern "C" {
   #  define RSTRING_LEN(x) (RSTRING(x)->len)
   #endif
 
-  typedef struct _re2p {
+  struct re2_pattern {
     RE2 *pattern;
-  } re2_pattern;
+  };
 
   VALUE re2_cRE2;
 
   /* Symbols used in RE2 options. */
   static ID id_utf8, id_posix_syntax, id_longest_match, id_log_errors,
-             id_max_mem, id_literal, id_never_nl, id_case_sensitive,
-             id_perl_classes, id_word_boundary, id_one_line;
+            id_max_mem, id_literal, id_never_nl, id_case_sensitive,
+            id_perl_classes, id_word_boundary, id_one_line;
 
   void
   re2_free(re2_pattern* self)
@@ -42,9 +42,8 @@ extern "C" {
   static VALUE
   re2_allocate(VALUE klass)
   {
-    re2_pattern *p = (re2_pattern*)malloc(sizeof(re2_pattern));
-    p->pattern = NULL;
-    return Data_Wrap_Struct(klass, 0, re2_free, p);
+    re2_pattern *p;
+    return Data_Make_Struct(klass, re2_pattern, 0, re2_free, p);
   }
 
   /*
@@ -124,7 +123,11 @@ extern "C" {
         rb_raise(rb_eArgError, "options should be a hash");
       }
 
-      re2_options = new RE2::Options();
+      re2_options = new (std::nothrow) RE2::Options();
+
+      if (re2_options == 0) {
+        rb_raise(rb_eNoMemError, "not enough memory to allocate RE2::Options");
+      }
 
       utf8 = rb_hash_aref(options, ID2SYM(id_utf8));
       if (!NIL_P(utf8)) {
@@ -181,9 +184,13 @@ extern "C" {
         re2_options->set_one_line(RTEST(one_line));
       }
 
-      p->pattern = new RE2(StringValuePtr(pattern), *re2_options);
+      p->pattern = new (std::nothrow) RE2(StringValuePtr(pattern), *re2_options);
     } else {
-      p->pattern = new RE2(StringValuePtr(pattern));
+      p->pattern = new (std::nothrow) RE2(StringValuePtr(pattern));
+    }
+
+    if (p->pattern == 0) {
+      rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
     }
 
     return self;
@@ -202,7 +209,7 @@ extern "C" {
   static VALUE
   re2_inspect(VALUE self)
   {
-    VALUE result = rb_str_buf_new(0);
+    VALUE result = rb_str_buf_new(2);
     re2_pattern *p;
 
     rb_str_buf_cat2(result, "/");
@@ -624,19 +631,34 @@ extern "C" {
       n = p->pattern->NumberOfCapturingGroups();
     }
 
-    text_as_string_piece = new re2::StringPiece(StringValuePtr(text));
+    text_as_string_piece = new (std::nothrow) re2::StringPiece(StringValuePtr(text));
+
+    if (text_as_string_piece == 0) {
+      rb_raise(rb_eNoMemError, "not enough memory to allocate StringPiece for text");
+    }
 
     if (n == 0) {
-      return BOOL2RUBY(p->pattern->Match(*text_as_string_piece, 0, RE2::UNANCHORED, 0, 0));
+      matched = p->pattern->Match(*text_as_string_piece, 0, RE2::UNANCHORED, 0, 0);
+
+      delete text_as_string_piece;
+
+      return BOOL2RUBY(matched);
+
     } else {
 
       /* Because match returns the whole match as well. */
       n += 1;
 
-      string_matches = new re2::StringPiece[n];
+      string_matches = new (std::nothrow) re2::StringPiece[n];
+
+      if (string_matches == 0) {
+        rb_raise(rb_eNoMemError, "not enough memory to allocate array of StringPieces for matches");
+      }
 
       matched = p->pattern->Match(*text_as_string_piece, 0, RE2::UNANCHORED, string_matches, n);
 
+      delete text_as_string_piece;
+
       if (matched) {
         matches = rb_ary_new();
 
@@ -648,8 +670,13 @@ extern "C" {
           }
         }
 
+        delete[] string_matches;
+
         return matches;
       } else {
+
+        delete[] string_matches;
+
         return Qnil;
       }
     }
@@ -729,7 +756,7 @@ extern "C" {
   {
     UNUSED(self);
     int n;
-    bool matched;
+    bool matched, re2_given;
     re2_pattern *p;
     VALUE matches;
     RE2 *compiled_pattern;
@@ -737,18 +764,36 @@ extern "C" {
     const RE2::Arg **args;
     std::string *string_matches;
 
-    if (rb_obj_is_kind_of(re, re2_cRE2)) {
+    re2_given = rb_obj_is_kind_of(re, re2_cRE2);
+
+    if (re2_given) {
       Data_Get_Struct(re, re2_pattern, p);
       compiled_pattern = p->pattern;
     } else {
-      compiled_pattern = new RE2(StringValuePtr(re));
+      compiled_pattern = new (std::nothrow) RE2(StringValuePtr(re));
+
+      if (compiled_pattern == 0) {
+        rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object for pattern");
+      }
     }
 
     n = compiled_pattern->NumberOfCapturingGroups();
 
-    argv = new RE2::Arg[n];
-    args = new const RE2::Arg*[n];
-    string_matches = new std::string[n];
+    argv = new (std::nothrow) RE2::Arg[n];
+    args = new (std::nothrow) const RE2::Arg*[n];
+    string_matches = new (std::nothrow) std::string[n];
+
+    if (argv == 0) {
+      rb_raise(rb_eNoMemError, "not enough memory to allocate array of RE2::Args");
+    }
+
+    if (args == 0) {
+      rb_raise(rb_eNoMemError, "not enough memory to allocate array of pointers to RE2::Args");
+    }
+
+    if (string_matches == 0) {
+      rb_raise(rb_eNoMemError, "not enough memory to allocate array of strings for matches");
+    }
 
     for (int i = 0; i < n; i++) {
       args[i] = &argv[i];
@@ -757,6 +802,13 @@ extern "C" {
 
     matched = RE2::FullMatchN(StringValuePtr(text), *compiled_pattern, args, n);
 
+    if (!re2_given) {
+      delete compiled_pattern;
+    }
+
+    delete[] argv;
+    delete[] args;
+
     if (matched) {
       matches = rb_ary_new();
 
@@ -768,8 +820,11 @@ extern "C" {
         }
       }
 
+      delete[] string_matches;
+
       return matches;
     } else {
+      delete[] string_matches;
       return Qnil;
     }
   }
@@ -788,7 +843,7 @@ extern "C" {
   {
     UNUSED(self);
     int n;
-    bool matched;
+    bool matched, re2_given;
     re2_pattern *p;
     VALUE matches;
     RE2 *compiled_pattern;
@@ -796,18 +851,36 @@ extern "C" {
     const RE2::Arg **args;
     std::string *string_matches;
 
-    if (rb_obj_is_kind_of(re, re2_cRE2)) {
+    re2_given = rb_obj_is_kind_of(re, re2_cRE2);
+
+    if (re2_given) {
       Data_Get_Struct(re, re2_pattern, p);
       compiled_pattern = p->pattern;
     } else {
-      compiled_pattern = new RE2(StringValuePtr(re));
+      compiled_pattern = new (std::nothrow) RE2(StringValuePtr(re));
+
+      if (compiled_pattern == 0) {
+        rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object for pattern");
+      }
     }
 
     n = compiled_pattern->NumberOfCapturingGroups();
 
-    argv = new RE2::Arg[n];
-    args = new const RE2::Arg*[n];
-    string_matches = new std::string[n];
+    argv = new (std::nothrow) RE2::Arg[n];
+    args = new (std::nothrow) const RE2::Arg*[n];
+    string_matches = new (std::nothrow) std::string[n];
+
+    if (argv == 0) {
+      rb_raise(rb_eNoMemError, "not enough memory to allocate array of RE2::Args");
+    }
+
+    if (args == 0) {
+      rb_raise(rb_eNoMemError, "not enough memory to allocate array of pointers to RE2::Args");
+    }
+
+    if (string_matches == 0) {
+      rb_raise(rb_eNoMemError, "not enough memory to allocate array of strings for matches");
+    }
 
     for (int i = 0; i < n; i++) {
       args[i] = &argv[i];
@@ -816,6 +889,13 @@ extern "C" {
 
     matched = RE2::PartialMatchN(StringValuePtr(text), *compiled_pattern, args, n);
 
+    if (!re2_given) {
+      delete compiled_pattern;
+    }
+
+    delete[] argv;
+    delete[] args;
+
     if (matched) {
       matches = rb_ary_new();
 
@@ -827,8 +907,11 @@ extern "C" {
         }
       }
 
+      delete[] string_matches;
+
       return matches;
     } else {
+      delete[] string_matches;
       return Qnil;
     }
   }

data/test/re2_test.rb

@@ -74,6 +74,18 @@ class RE2Test < Test::Unit::TestCase
     assert !RE2::FullMatch("woo", "wowzer")
   end
 
+  def test_full_match_with_compiled_pattern
+    r = RE2.new("woo")
+    assert RE2::FullMatch("woo", r)
+    assert !RE2::FullMatch("wowzer", r)
+
+    assert RE2::FullMatch("woo", RE2("woo"))
+    assert RE2::FullMatch("woo", RE2("wo+"))
+    assert RE2::FullMatch("woo", RE2("woo?"))
+    assert RE2::FullMatch("woo", RE2("wo{2}"))
+    assert !RE2::FullMatch("woo", RE2("wowzer"))
+  end
+
   def test_full_match_n
     assert_equal ["oo"], RE2::FullMatchN("woo", "w(oo)")
     assert_equal ["12"], RE2::FullMatchN("woo12w", 'woo(\d{2})w')
@@ -95,6 +107,17 @@ class RE2Test < Test::Unit::TestCase
     assert !RE2::PartialMatch("woo", "ha")
   end
 
+  def test_partial_match_with_compiled_pattern
+    r = RE2.new("woo")
+    assert RE2::PartialMatch("woo", r)
+    assert !RE2::PartialMatch("wowzer", r)
+
+    assert RE2::PartialMatch("woo", RE2("oo"))
+    assert RE2::PartialMatch("woo", RE2("oo?"))
+    assert RE2::PartialMatch("woo", RE2("o{2}"))
+    assert !RE2::PartialMatch("woo", RE2("ha"))
+  end
+
   def test_partial_match_n
     assert_equal ["oo"], RE2::PartialMatchN("awooa", "w(oo)")
     assert_equal ["12"], RE2::PartialMatchN("awoo12wa", 'woo(\d{2})w')
@@ -170,6 +193,9 @@ class RE2Test < Test::Unit::TestCase
     assert_equal ["woo", "o"], RE2.new('w(o)(o)').match('woo', 1)
     assert_equal ["woo", "o", "o"], RE2.new('w(o)(o)').match('woo', 2)
     assert_equal ["woo", "o", "o", nil], RE2.new('w(o)(o)').match('woo', 3)
+    assert_equal ["w", nil], RE2.new('w(o)?(o)?').match('w', 1)
+    assert_equal ["w", nil, nil], RE2.new('w(o)?(o)?').match('w', 2)
+    assert_equal ["w", nil, nil, nil], RE2.new('w(o)?(o)?').match('w', 3)
   end
 
   def test_compiling_with_options
@@ -185,26 +211,24 @@ class RE2Test < Test::Unit::TestCase
     assert r.options[:utf8]
   end
 
-  def test_full_match_with_re2
-    r = RE2.new("woo")
-    assert RE2::FullMatch("woo", r)
-    assert !RE2::FullMatch("wowzer", r)
-  end
-
-  def test_partial_match_with_re2
-    r = RE2.new("woo")
-    assert RE2::PartialMatch("woo", r)
-    assert !RE2::PartialMatch("wowzer", r)
-  end
-
   def test_replace_with_re2
     r = RE2.new("wo{2}")
     assert_equal "miaow", RE2::Replace("woo", r, "miaow")
+
+    assert_equal "wao", RE2::Replace("woo", RE2("o"), "a")
+    assert_equal "hoo", RE2::Replace("woo", RE2("w"), "h")
+    assert_equal "we", RE2::Replace("woo", RE2("o+"), "e")
+    assert_equal "Good morning", RE2::Replace("hi", RE2("hih?"), "Good morning")
+    assert_equal "hi", RE2::Replace("Good morning", RE2("gOOD MORNING", :case_sensitive => false), "hi")
   end
 
   def test_global_replace_with_re2
     r = RE2.new("o")
     assert_equal "wii", RE2::GlobalReplace("woo", r, "i")
+
+    assert_equal "waa", RE2::GlobalReplace("woo", RE2("o"), "a")
+    assert_equal "hoo", RE2::GlobalReplace("woo", RE2("w"), "h")
+    assert_equal "we", RE2::GlobalReplace("woo", RE2("o+"), "e")
   end
 
   def test_quote_meta

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: re2
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Paul Mucur
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-28 00:00:00 +01:00
+date: 2010-07-29 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency