re2 0.3.0 → 0.4.0

data/README.md

@@ -30,33 +30,77 @@ Usage
 
 You can use re2 as a mostly drop-in replacement for Ruby's own [Regexp][] and [MatchData][] classes:
 
-    $ irb -rubygems
-    > require 're2'
-    > r = RE2::Regexp.compile('w(\d)(\d+)')
-     => #<RE2::Regexp /w(\d)(\d+)/>
-    > m = r.match("w1234")
-     => #<RE2::MatchData "w1234" 1:"1" 2:"234">
-    > m[1]
-     => "1"
-    > m.string
-     => "w1234"
-    > r =~ "w1234"
-     => true
-    > r !~ "bob"
-     => true
-    > r.match("bob")
-     => nil
+```console
+$ irb -rubygems
+> require 're2'
+> r = RE2::Regexp.new('w(\d)(\d+)')
+=> #<RE2::Regexp /w(\d)(\d+)/>
+> m = r.match("w1234")
+=> #<RE2::MatchData "w1234" 1:"1" 2:"234">
+> m[1]
+=> "1"
+> m.string
+=> "w1234"
+> r =~ "w1234"
+=> true
+> r !~ "bob"
+=> true
+> r.match("bob")
+=> nil
+```
+
+As `RE2::Regexp.new` (or `RE2::Regexp.compile`) can be quite verbose, a helper method has been defined against `Kernel` so you can use a shorter version to create regular expressions:
+
+```console
+> RE2('(\d+)')
+=> #<RE2::Regexp /(\d+)/>
+```
+
+Note the use of *single quotes* as double quotes will interpret `\d` as `d` as in the following example:
+
+```console
+> RE2("(\d+)")
+=> #<RE2::Regexp /(d+)/>
+```
 
 As of 0.3.0, you can use named groups:
 
-    > r = RE2::Regexp.compile('(?P<name>\w+) (?P<age>\d+)')
-     => #<RE2::Regexp /(?P<name>\w+) (?P<age>\d+)/>
-    > m = r.match("Bob 40")
-     => #<RE2::MatchData "Bob 40" 1:"Bob" 2:"40">
-    > m[:name]
-     => "Bob"
-    > m["age"]
-     => "40"
+```console
+> r = RE2::Regexp.new('(?P<name>\w+) (?P<age>\d+)')
+=> #<RE2::Regexp /(?P<name>\w+) (?P<age>\d+)/>
+> m = r.match("Bob 40")
+=> #<RE2::MatchData "Bob 40" 1:"Bob" 2:"40">
+> m[:name]
+=> "Bob"
+> m["age"]
+=> "40"
+```
+
+As of 0.4.0, you can mix `RE2::String` into strings to provide helpers from the opposite direction:
+
+```console
+> require "re2/string"
+> string = "My name is Robert Paulson"
+=> "My name is Robert Paulson"
+> string.extend(RE2::String)
+=> "My name is Robert Paulson"
+> string.re2_sub("Robert", "Dave")
+=> "My name is Dave Paulson"
+> string.re2_gsub("a", "e")
+=> "My neme is Deve Peulson"
+> string.re2_match('D(\S+)')
+=> #<RE2::MatchData "Deve" 1:"eve">
+> string.re2_escape
+=> "My\\ neme\\ is\\ Deve\\ Peulson"
+```
+
+If you want these available to all strings, you can reopen `String` like so:
+
+```ruby
+class String
+  include RE2::String
+end
+```
 
 Features
 --------
@@ -75,11 +119,11 @@ Features
 
 * Checking the options for an expression with `re2.options` or individually with `re2.case_sensitive?`
 
-* Performing in-place replacement with [`RE2::Replace(str, pattern, replace)`](http://code.google.com/p/re2/source/browse/re2/re2.h#335)
+* Performing in-place replacement with [`RE2.Replace(str, pattern, replace)`](http://code.google.com/p/re2/source/browse/re2/re2.h#335)
 
-* Performing in-place global replacement with [`RE2::GlobalReplace(str, pattern, replace)`](http://code.google.com/p/re2/source/browse/re2/re2.h#352)
+* Performing in-place global replacement with [`RE2.GlobalReplace(str, pattern, replace)`](http://code.google.com/p/re2/source/browse/re2/re2.h#352)
 
-* Escaping regular expressions with [`RE2::Regexp.escape(unquoted)`](http://code.google.com/p/re2/source/browse/re2/re2.h#377), `RE2::Regexp.quote(unquoted)` or `RE2::QuoteMeta(unquoted)`
+* Escaping regular expressions with [`RE2::Regexp.escape(unquoted)`](http://code.google.com/p/re2/source/browse/re2/re2.h#377), `RE2::Regexp.quote(unquoted)` or `RE2.QuoteMeta(unquoted)`
 
 Contact
 -------

data/Rakefile

@@ -1,25 +1,17 @@
-begin
-  require 'rake/extensiontask'
-  require 'rake/testtask'
-rescue LoadError
-  require 'rubygems'
-  require 'rake/extensiontask'
-  require 'rake/testtask'
-end
+require 'rake/extensiontask'
+require 'rake/testtask'
 
 Rake::ExtensionTask.new('re2') do |e|
   # e.config_options << "--with-re2-dir=/opt/local/re2"
 end
 
 Rake::TestTask.new do |t|
-  t.test_files = FileList["test/*_test.rb"]
+  t.libs << "spec"
+  t.test_files = FileList["spec/**/*_spec.rb"]
   t.verbose = true
 end
 
-task :valgrind do
-  system "valgrind  --tool=memcheck --leak-check=full --show-reachable=no --num-callers=15 --track-fds=yes --workaround-gcc296-bugs=yes --max-stackframe=7304328 --dsymutil=yes --track-origins=yes --log-file=report.txt ruby test/leak.rb"
-end
-
-task :test => :compile
+task :test    => :compile
+task :spec    => :test
 task :default => :test
 

data/ext/re2/extconf.rb

@@ -1,7 +1,7 @@
 # re2 (http://github.com/mudge/re2)
 # Ruby bindings to re2, an "efficient, principled regular expression library"
 #
-# Copyright (c) 2010, Paul Mucur (http://mucur.name)
+# Copyright (c) 2010-2012, Paul Mucur (http://mudge.name)
 # Released under the BSD Licence, please see LICENSE.txt
 
 require 'mkmf'

data/ext/re2/re2.cc

@@ -2,12 +2,13 @@
  * re2 (http://github.com/mudge/re2)
  * Ruby bindings to re2, an "efficient, principled regular expression library"
  *
- * Copyright (c) 2010, Paul Mucur (http://mucur.name)
+ * Copyright (c) 2010-2012, Paul Mucur (http://mudge.name)
  * Released under the BSD Licence, please see LICENSE.txt
  */
 
 #include <re2/re2.h>
 #include <string>
+#include <sstream>
 using namespace std;
 
 extern "C" {
@@ -17,12 +18,20 @@ extern "C" {
   #define BOOL2RUBY(v) (v ? Qtrue : Qfalse)
   #define UNUSED(x) ((void)x)
 
-  #if !defined(RSTRING_LEN)
-  #  define RSTRING_LEN(x) (RSTRING(x)->len)
+  #ifndef RSTRING_LEN
+    #define RSTRING_LEN(x) (RSTRING(x)->len)
   #endif
 
-  #if !defined(RSTRING_PTR)
-  #  define RSTRING_PTR(x) (RSTRING(x)->ptr)
+  #ifndef RSTRING_PTR
+    #define RSTRING_PTR(x) (RSTRING(x)->ptr)
+  #endif
+
+  #ifdef HAVE_ENDPOS_ARGUMENT
+    #define match(pattern, text, startpos, endpos, anchor, match, nmatch) \
+            (pattern->Match(text, startpos, endpos, anchor, match, nmatch))
+  #else
+    #define match(pattern, text, startpos, endpos, anchor, match, nmatch) \
+            (pattern->Match(text, startpos, anchor, match, nmatch))
   #endif
 
   typedef struct {
@@ -77,7 +86,7 @@ extern "C" {
    *
    * @return [String] a frozen copy of the passed string.
    * @example
-   *   m = RE2('(\d+)').match("bob 123")
+   *   m = RE2::Regexp.new('(\d+)').match("bob 123")
    *   m.string  #=> "bob 123"
    */
   static VALUE
@@ -94,7 +103,7 @@ extern "C" {
    *
    * @return [Fixnum] the number of elements
    * @example
-   *   m = RE2('(\d+)').match("bob 123")
+   *   m = RE2::Regexp.new('(\d+)').match("bob 123")
    *   m.size      #=> 2
    *   m.length    #=> 2
    */
@@ -112,7 +121,7 @@ extern "C" {
    *
    * @return [RE2::Regexp] the regexp used in the match
    * @example
-   *   m = RE2('(\d+)').match("bob 123")
+   *   m = RE2::Regexp.new('(\d+)').match("bob 123")
    *   m.regexp    #=> #<RE2::Regexp /(\d+)/>
    */
   static VALUE
@@ -135,7 +144,7 @@ extern "C" {
    *
    * @return [Array<String, nil>] the array of matches
    * @example
-   *   m = RE2('(\d+)').match("bob 123")
+   *   m = RE2::Regexp.new('(\d+)').match("bob 123")
    *   m.to_a    #=> ["123", "123"]
    */
   static VALUE
@@ -144,9 +153,11 @@ extern "C" {
     int i;
     re2_matchdata *m;
     re2::StringPiece match;
+    VALUE array;
 
     Data_Get_Struct(self, re2_matchdata, m);
-    VALUE array = rb_ary_new2(m->number_of_matches);
+
+    array = rb_ary_new2(m->number_of_matches);
     for (i = 0; i < m->number_of_matches; i++) {
       if (m->matches[i].empty()) {
         rb_ary_push(array, Qnil);
@@ -155,6 +166,7 @@ extern "C" {
         rb_ary_push(array, rb_str_new(match.data(), match.size()));
       }
     }
+
     return array;
   }
 
@@ -207,7 +219,7 @@ extern "C" {
    *   @param [Fixnum] index the index of the match to fetch
    *   @return [String, nil] the specified match
    *   @example
-   *     m = RE2('(\d+)').match("bob 123")
+   *     m = RE2::Regexp.new('(\d+)').match("bob 123")
    *     m[0]    #=> "123"
    *
    * @overload [](start, length)
@@ -217,7 +229,7 @@ extern "C" {
    *   @param [Fixnum] length the number of elements to fetch
    *   @return [Array<String, nil>] the specified matches
    *   @example
-   *     m = RE2('(\d+)').match("bob 123")
+   *     m = RE2::Regexp.new('(\d+)').match("bob 123")
    *     m[0, 1]    #=> ["123"]
    *
    * @overload [](range)
@@ -226,7 +238,7 @@ extern "C" {
    *   @param [Range] range the range of match indexes to fetch
    *   @return [Array<String, nil>] the specified matches
    *   @example
-   *     m = RE2('(\d+)').match("bob 123")
+   *     m = RE2::Regexp.new('(\d+)').match("bob 123")
    *     m[0..1]    #=> "[123", "123"]
    *
    * @overload [](name)
@@ -235,7 +247,7 @@ extern "C" {
    *   @param [String, Symbol] name the name of the match to fetch
    *   @return [String, nil] the specific match
    *   @example
-   *     m = RE2('(?P<number>\d+)').match("bob 123")
+   *     m = RE2::Regexp.new('(?P<number>\d+)').match("bob 123")
    *     m["number"] #=> "123"
    *     m[:number]  #=> "123"
    */
@@ -272,7 +284,7 @@ extern "C" {
    *
    * @return [String] a printable version of the match
    * @example
-   *   m = RE2('(\d+)').match("bob 123")
+   *   m = RE2::Regexp.new('(\d+)').match("bob 123")
    *   m.inspect    #=> "#<RE2::MatchData \"123\" 1:\"123\">"
    */
   static VALUE
@@ -281,32 +293,33 @@ extern "C" {
     int i;
     re2_matchdata *m;
     VALUE match, result;
+    ostringstream output;
 
     Data_Get_Struct(self, re2_matchdata, m);
 
     result = rb_str_new("#<RE2::MatchData", 16);
 
+    output << "#<RE2::MatchData";
+
     for (i = 0; i < m->number_of_matches; i++) {
-      rb_str_cat(result, " ", 1);
+      output << " ";
 
       if (i > 0) {
-        char buf[sizeof(i)*3+1];
-        snprintf(buf, sizeof(buf), "%d", i);
-        rb_str_cat2(result, buf);
-        rb_str_cat(result, ":", 1);
+        output << i << ":";
       }
 
       match = re2_matchdata_nth_match(i, self);
 
       if (match == Qnil) {
-        rb_str_cat(result, "nil", 3);
+        output << "nil";
       } else {
-        rb_str_cat(result, "\"", 1);
-        rb_str_cat(result, RSTRING_PTR(match), RSTRING_LEN(match));
-        rb_str_cat(result, "\"", 1);
+        output << "\"" << StringValuePtr(match) << "\"";
       }
     }
-    rb_str_cat(result, ">", 1);
+
+    output << ">";
+
+    result = rb_str_new(output.str().data(), output.str().length());
 
     return result;
   }
@@ -459,11 +472,14 @@ extern "C" {
   re2_regexp_inspect(VALUE self)
   {
     re2_pattern *p;
-    VALUE result = rb_str_new("#<RE2::Regexp /", 15);
+    VALUE result;
+    ostringstream output;
 
     Data_Get_Struct(self, re2_pattern, p);
-    rb_str_cat(result, p->pattern->pattern().data(), p->pattern->pattern().size());
-    rb_str_cat(result, "/>", 2);
+
+    output << "#<RE2::Regexp /" << p->pattern->pattern() << "/>";
+
+    result = rb_str_new(output.str().data(), output.str().length());
 
     return result;
   }
@@ -706,30 +722,38 @@ extern "C" {
 
   /*
    * If the RE2 could not be created properly, returns an
-   * error string.
+   * error string otherwise returns nil.
    *
-   * @return [String] the error string
+   * @return [String, nil] the error string or nil
    */
   static VALUE
   re2_regexp_error(VALUE self)
   {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
-    return rb_str_new(p->pattern->error().data(), p->pattern->error().size());
+    if (p->pattern->ok()) {
+      return Qnil;
+    } else {
+      return rb_str_new(p->pattern->error().data(), p->pattern->error().size());
+    }
   }
 
   /*
    * If the RE2 could not be created properly, returns
-   * the offending portion of the regexp.
+   * the offending portion of the regexp otherwise returns nil.
    *
-   * @return [String] the offending portion of the regexp
+   * @return [String, nil] the offending portion of the regexp or nil
    */
   static VALUE
   re2_regexp_error_arg(VALUE self)
   {
     re2_pattern *p;
     Data_Get_Struct(self, re2_pattern, p);
-    return rb_str_new(p->pattern->error_arg().data(), p->pattern->error_arg().size());
+    if (p->pattern->ok()) {
+      return Qnil;
+    } else {
+      return rb_str_new(p->pattern->error_arg().data(), p->pattern->error_arg().size());
+    }
   }
 
   /*
@@ -860,7 +884,7 @@ extern "C" {
    *   @raise [NoMemoryError] if there was not enough memory to allocate the matches
    *   @example
    *     r = RE2::Regexp.new('w(o)(o)')
-   *     r.match('woo)    #=> #<RE2::MatchData "woo" 1:"o" 2:"o">
+   *     r.match('woo')    #=> #<RE2::MatchData "woo" 1:"o" 2:"o">
    *
    * @overload match(text, 0)
    *   Returns either true or false indicating whether a
@@ -907,11 +931,7 @@ extern "C" {
     }
 
     if (n == 0) {
-#if defined(HAVE_ENDPOS_ARGUMENT)
-      matched = p->pattern->Match(StringValuePtr(text), 0, (int)RSTRING_LEN(text), RE2::UNANCHORED, 0, 0);
-#else
-      matched = p->pattern->Match(StringValuePtr(text), 0, RE2::UNANCHORED, 0, 0);
-#endif
+      matched = match(p->pattern, StringValuePtr(text), 0, (int)RSTRING_LEN(text), RE2::UNANCHORED, 0, 0);
       return BOOL2RUBY(matched);
     } else {
 
@@ -931,11 +951,7 @@ extern "C" {
 
       m->number_of_matches = n;
 
-#if defined(HAVE_ENDPOS_ARGUMENT)
-      matched = p->pattern->Match(StringValuePtr(text), 0, (int)RSTRING_LEN(text), RE2::UNANCHORED, m->matches, n);
-#else
-      matched = p->pattern->Match(StringValuePtr(text), 0, RE2::UNANCHORED, m->matches, n);
-#endif
+      matched = match(p->pattern, StringValuePtr(text), 0, (int)RSTRING_LEN(text), RE2::UNANCHORED, m->matches, n);
 
       if (matched) {
         return matchdata;
@@ -968,12 +984,13 @@ extern "C" {
    * @param [String] str the string to modify
    * @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
    * @param [String] rewrite the string to replace with
+   * @return [String] the resulting string
    * @example
-   *   RE2::Replace("hello there", "hello", "howdy") #=> "howdy there"
+   *   RE2.Replace("hello there", "hello", "howdy") #=> "howdy there"
    *   re2 = RE2.new("hel+o")
-   *   RE2::Replace("hello there", re2, "yo")        #=> "yo there"
+   *   RE2.Replace("hello there", re2, "yo")        #=> "yo there"
    *   text = "Good morning"
-   *   RE2::Replace(text, "morn", "even")            #=> "Good evening"
+   *   RE2.Replace(text, "morn", "even")            #=> "Good evening"
    *   text                                          #=> "Good evening"
    */
   static VALUE
@@ -1017,12 +1034,13 @@ extern "C" {
    * @param [String] str the string to modify
    * @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
    * @param [String] rewrite the string to replace with
+   * @return [String] the resulting string
    * @example
-   *   RE2::GlobalReplace("hello there", "e", "i")   #=> "hillo thiri"
+   *   RE2.GlobalReplace("hello there", "e", "i")   #=> "hillo thiri"
    *   re2 = RE2.new("oo?")
-   *   RE2::GlobalReplace("whoops-doops", re2, "e")  #=> "wheps-deps"
+   *   RE2.GlobalReplace("whoops-doops", re2, "e")  #=> "wheps-deps"
    *   text = "Good morning"
-   *   RE2::GlobalReplace(text, "o", "ee")           #=> "Geeeed meerning"
+   *   RE2.GlobalReplace(text, "o", "ee")           #=> "Geeeed meerning"
    *   text                                          #=> "Geeeed meerning"
    */
   static VALUE