re2 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44eacddc1b64782c61eff633b15f40db1ba3b9d9
-  data.tar.gz: 377ae25429bb8804c03a951d0150097d11cb808e
+  metadata.gz: 32a2347d40362a3014dfd03f948405964468a3c2
+  data.tar.gz: ea15968dae15568249200c6ba91bad66d0e28f6f
 SHA512:
-  metadata.gz: 1f09c136bb17bfabfe739882cc61c7f0bf50dfba140aec66db0a6e2962de0d25e844804812137b5c3e798a61bb2b8002d83fc4d7766bc7fc52ce159535634b4e
-  data.tar.gz: f9742540b13859de929a299ac28a646d305e4a72bcffdd0588dad268f53cb0135f440a1f914cd7504a3b01eb5bf9c569c54c83cfaa4ba0b7f131326ef01a0212
+  metadata.gz: 00588950e6c82fb5720043c04d0f833d819f3107a3c953f2284d9eaede74210c0c803f34b3e9fd89413c886fae1e4b853b5a85b18b3c2d788ff0a7e8b46036cf
+  data.tar.gz: af2d23503d089a15ea6dd32e00bc80622cd7b0b1773ed471edcc982ac6791a6d1bf0bf5332d2440446796b5a4da15a169fd7396e3cf729af8a300e52a5985bad

data/README.md

@@ -4,7 +4,7 @@ re2 [![Build Status](https://travis-ci.org/mudge/re2.svg?branch=master)](http://
 A Ruby binding to [re2][], an "efficient, principled regular expression
 library".
 
-**Current version:** 0.6.1
+**Current version:** 0.7.0  
 **Supported Ruby versions:** 1.8.7, 1.9.2, 1.9.3, 2.0.0, 2.1.0, Rubinius 2.2
 
 Installation
@@ -33,7 +33,7 @@ Documentation
 -------------
 
 Full documentation automatically generated from the latest version is
-available at <http://rubydoc.info/github/mudge/re2>.
+available at <http://mudge.name/re2/>.
 
 Bear in mind that re2's regular expression syntax differs from PCRE, see the
 [official syntax page][] for more details.
@@ -55,6 +55,10 @@ $ irb -rubygems
 => "1"
 > m.string
 => "w1234"
+> m.begin(1)
+=> 1
+> m.end(1)
+=> 2
 > r =~ "w1234"
 => true
 > r !~ "bob"
@@ -151,6 +155,12 @@ Features
   [`RE2.escape(unquoted)`](http://code.google.com/p/re2/source/browse/re2/re2.h#377) and
   `RE2.quote(unquoted)`
 
+Contributions
+-------------
+
+Thanks to [Jason Woods](https://github.com/driskell) who contributed the
+original implementations of `RE2::MatchData#begin` and `RE2::MatchData#end`.
+
 Contact
 -------
 

data/Rakefile

@@ -9,10 +9,6 @@ Rake::TestTask.new do |t|
   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 spec/leak.rb"
-end
-
 task :test    => :compile
 task :spec    => :test
 task :default => :test

data/ext/re2/extconf.rb

@@ -11,6 +11,9 @@ incl, lib = dir_config("re2", "/usr/local/include", "/usr/local/lib")
 $CFLAGS << " -Wall -Wextra -funroll-loops"
 
 have_library("stdc++")
+have_header("stdint.h")
+have_func("rb_str_sublen")
+
 if have_library("re2")
 
   # Determine which version of re2 the user has installed.

data/ext/re2/re2.cc

@@ -8,6 +8,7 @@
 
 #include <re2/re2.h>
 #include <ruby.h>
+#include <stdint.h>
 #include <string>
 #include <sstream>
 #include <vector>
@@ -17,6 +18,17 @@ using std::nothrow;
 using std::map;
 using std::vector;
 
+#define BOOL2RUBY(v) (v ? Qtrue : Qfalse)
+#define UNUSED(x) ((void)x)
+
+#ifndef RSTRING_LEN
+  #define RSTRING_LEN(x) (RSTRING(x)->len)
+#endif
+
+#ifndef RSTRING_PTR
+  #define RSTRING_PTR(x) (RSTRING(x)->ptr)
+#endif
+
 #ifdef HAVE_RUBY_ENCODING_H
   #include <ruby/encoding.h>
   #define ENCODED_STR_NEW(str, length, encoding) \
@@ -40,15 +52,20 @@ using std::vector;
     rb_str_new((const char *)str, (long)length)
 #endif
 
-#define BOOL2RUBY(v) (v ? Qtrue : Qfalse)
-#define UNUSED(x) ((void)x)
-
-#ifndef RSTRING_LEN
-  #define RSTRING_LEN(x) (RSTRING(x)->len)
-#endif
-
-#ifndef RSTRING_PTR
-  #define RSTRING_PTR(x) (RSTRING(x)->ptr)
+#ifdef HAVE_RB_STR_SUBLEN
+  #define ENCODED_STR_SUBLEN(str, offset, encoding) \
+     LONG2NUM(rb_str_sublen(str, offset))
+#else
+  #ifdef HAVE_RUBY_ENCODING_H
+    #define ENCODED_STR_SUBLEN(str, offset, encoding) \
+      ({ \
+        VALUE _string = ENCODED_STR_NEW(RSTRING_PTR(str), offset, encoding); \
+        rb_str_length(_string); \
+      })
+  #else
+    #define ENCODED_STR_SUBLEN(str, offset, encoding) \
+      LONG2NUM(offset)
+  #endif
 #endif
 
 #ifdef HAVE_ENDPOS_ARGUMENT
@@ -223,6 +240,49 @@ static VALUE re2_scanner_scan(VALUE self) {
   return result;
 }
 
+/*
+ * Retrieve a matchdata by index or name.
+ */
+re2::StringPiece *re2_matchdata_find_match(VALUE idx, VALUE self) {
+  int id;
+  re2_matchdata *m;
+  re2_pattern *p;
+  map<string, int> groups;
+  string name;
+  re2::StringPiece *match;
+
+  Data_Get_Struct(self, re2_matchdata, m);
+  Data_Get_Struct(m->regexp, re2_pattern, p);
+
+  if (FIXNUM_P(idx)) {
+    id = FIX2INT(idx);
+  } else {
+    if (SYMBOL_P(idx)) {
+      name = rb_id2name(SYM2ID(idx));
+    } else {
+      name = StringValuePtr(idx);
+    }
+
+    groups = p->pattern->NamedCapturingGroups();
+
+    if (groups.count(name) == 1) {
+      id = groups[name];
+    } else {
+      return NULL;
+    }
+  }
+
+  if (id >= 0 && id < m->number_of_matches) {
+    match = &m->matches[id];
+
+    if (!match->empty()) {
+      return match;
+    }
+  }
+
+  return NULL;
+}
+
 /*
  * Returns the number of elements in the match array (including nils).
  *
@@ -239,6 +299,67 @@ static VALUE re2_matchdata_size(VALUE self) {
   return INT2FIX(m->number_of_matches);
 }
 
+/*
+ * Returns the offset of the start of the nth element of the matchdata.
+ *
+ * @param [Fixnum, String, Symbol] n the name or number of the match
+ * @return [Fixnum] the offset of the start of the match
+ * @example
+ *   m = RE2::Regexp.new('ob (\d+)').match("bob 123")
+ *   m.begin(0)  #=> 1
+ *   m.begin(1)  #=> 4
+ */
+static VALUE re2_matchdata_begin(VALUE self, VALUE n) {
+  re2_matchdata *m;
+  re2_pattern *p;
+  re2::StringPiece *match;
+  long offset;
+
+  Data_Get_Struct(self, re2_matchdata, m);
+  Data_Get_Struct(m->regexp, re2_pattern, p);
+
+  match = re2_matchdata_find_match(n, self);
+  if (match == NULL) {
+    return Qnil;
+  } else {
+    offset = reinterpret_cast<uintptr_t>(match->data()) - reinterpret_cast<uintptr_t>(StringValuePtr(m->text));
+
+    return ENCODED_STR_SUBLEN(StringValue(m->text), offset,
+           p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");
+  }
+}
+
+/*
+ * Returns the offset of the character following the end of the nth element of the matchdata.
+ *
+ * @param [Fixnum, String, Symbol] n the name or number of the match
+ * @return [Fixnum] the offset of the character following the end of the match
+ * @example
+ *   m = RE2::Regexp.new('ob (\d+) b').match("bob 123 bob")
+ *   m.end(0)  #=> 9
+ *   m.end(1)  #=> 7
+ */
+static VALUE re2_matchdata_end(VALUE self, VALUE n) {
+  re2_matchdata *m;
+  re2_pattern *p;
+  re2::StringPiece *match;
+  long offset;
+
+  Data_Get_Struct(self, re2_matchdata, m);
+  Data_Get_Struct(m->regexp, re2_pattern, p);
+
+  match = re2_matchdata_find_match(n, self);
+
+  if (match == NULL) {
+    return Qnil;
+  } else {
+    offset = reinterpret_cast<uintptr_t>(match->data()) - reinterpret_cast<uintptr_t>(StringValuePtr(m->text)) + match->size();
+
+    return ENCODED_STR_SUBLEN(StringValue(m->text), offset,
+           p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1");
+  }
+}
+
 /*
  * Returns the {RE2::Regexp} used in the match.
  *
@@ -1050,8 +1171,8 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, VALUE self) {
 
     m->number_of_matches = n;
 
-    matched = match(p->pattern, StringValuePtr(text), 0,
-                    static_cast<int>(RSTRING_LEN(text)),
+    matched = match(p->pattern, StringValuePtr(m->text), 0,
+                    static_cast<int>(RSTRING_LEN(m->text)),
                     RE2::UNANCHORED, m->matches, n);
 
     if (matched) {
@@ -1216,6 +1337,10 @@ void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_matchdata_size), 0);
   rb_define_method(re2_cMatchData, "length",
       RUBY_METHOD_FUNC(re2_matchdata_size), 0);
+  rb_define_method(re2_cMatchData, "begin",
+      RUBY_METHOD_FUNC(re2_matchdata_begin), 1);
+  rb_define_method(re2_cMatchData, "end",
+      RUBY_METHOD_FUNC(re2_matchdata_end), 1);
   rb_define_method(re2_cMatchData, "[]", RUBY_METHOD_FUNC(re2_matchdata_aref),
       -1); rb_define_method(re2_cMatchData, "to_s",
         RUBY_METHOD_FUNC(re2_matchdata_to_s), 0);

data/spec/re2/match_data_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require "spec_helper"
 
 describe RE2::MatchData do
@@ -69,6 +71,11 @@ describe RE2::MatchData do
       md[:missing].must_be_nil
     end
 
+    it "raises an error if given an inappropriate index" do
+      md = RE2::Regexp.new('(\d+)').match("bob 123")
+      lambda { md[nil] }.must_raise(TypeError)
+    end
+
     if String.method_defined?(:encoding)
       it "returns UTF-8 encoded strings by default" do
         md = RE2::Regexp.new('(?P<name>\S+)').match("bob")
@@ -154,4 +161,48 @@ describe RE2::MatchData do
       m3.must_equal("56")
     end
   end
+
+  describe "#begin" do
+    it "returns the offset of the start of a match by index" do
+      md = RE2::Regexp.new('(wo{2})').match('a woohoo')
+      md.string[md.begin(0)..-1].must_equal('woohoo')
+    end
+
+    it "returns the offset of the start of a match by string name" do
+      md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
+      md.string[md.begin('foo')..-1].must_equal('foobar')
+    end
+
+    it "returns the offset of the start of a match by symbol name" do
+      md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
+      md.string[md.begin(:foo)..-1].must_equal('foobar')
+    end
+
+    it "returns the offset despite multibyte characters" do
+      md = RE2::Regexp.new('(Ruby)').match('I ♥ Ruby')
+      md.string[md.begin(0)..-1].must_equal('Ruby')
+    end
+  end
+
+  describe "#end" do
+    it "returns the offset of the character following the end of a match" do
+      md = RE2::Regexp.new('(wo{2})').match('a woohoo')
+      md.string[0...md.end(0)].must_equal('a woo')
+    end
+
+    it "returns the offset of a match by string name" do
+      md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
+      md.string[0...md.end('foo')].must_equal('a foo')
+    end
+
+    it "returns the offset of a match by symbol name" do
+      md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
+      md.string[0...md.end(:foo)].must_equal('a foo')
+    end
+
+    it "returns the offset despite multibyte characters" do
+      md = RE2::Regexp.new('(Ruby)').match('I ♥ Ruby')
+      md.string[0...md.end(0)].must_equal('I ♥ Ruby')
+    end
+  end
 end

data/spec/re2/regexp_spec.rb

@@ -11,6 +11,10 @@ describe RE2::Regexp do
       re = RE2::Regexp.new('woo', :case_sensitive => false)
       re.must_be_instance_of(RE2::Regexp)
     end
+
+    it "raises an error if given an inappropriate type" do
+      lambda { RE2::Regexp.new(nil) }.must_raise(TypeError)
+    end
   end
 
   describe "#compile" do
@@ -268,6 +272,10 @@ describe RE2::Regexp do
       lambda { re.match(nil) }.must_raise(TypeError)
     end
 
+    it "raises an exception when given an inappropriate number of matches" do
+      lambda { re.match("My name is Robert Paulson", {}) }.must_raise(TypeError)
+    end
+
     describe "with a specific number of matches under the total in the pattern" do
       subject { re.match("My name is Robert Paulson", 1) }
 

data/spec/re2_spec.rb

@@ -77,4 +77,3 @@ describe RE2 do
     end
   end
 end
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Paul Mucur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-25 00:00:00.000000000 Z
+date: 2015-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler