re2 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 118d0c677843bd7166804670d548504e6a30410b
-  data.tar.gz: 9efe563b54262ad28c5b71c2317b3f18117e2706
+  metadata.gz: cfd64dee3272c8a58e0c930a40b2e00be07cbc63
+  data.tar.gz: a8f226f7e6d0ba8bab49110ce8e932880d0895c3
 SHA512:
-  metadata.gz: 07d895cafa392c75483586a37b44f57b5d5979b7473529c52eff05f3c6bccca3b11f8d406363ece9f3ab2ad02df4952031dcdb8104cdc275484666a0ceb7db01
-  data.tar.gz: 8147a0194f92a7850285339d9d81fe74b4865d12f67a1e64fa9db3eeec35c3adaaf4cfd97862f1d954b7b475b4dc4b0d01ef28dd10c3f39cba3338caac6ff51a
+  metadata.gz: e8b1a351577da23b21d137ea2df06932ec338be3647bbb28ea81b39fe5dfb8181049545084338a59aa22a92a1cb366b2b925eef54a3151c132333493ea2105f8
+  data.tar.gz: d611759608d9755d751c41ed446bf32eecb6ae653200ee44f78dce1d23d969c53b1a9db1ede456343121a22f98928adaea13d07d242d571e78db8a84fca1348a

data/README.md

@@ -4,8 +4,8 @@ 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:** 1.0.0  
-**Supported Ruby versions:** 1.8.7, 1.9.2, 1.9.3, 2.0.0, 2.1.0, 2.2, 2.3, Rubinius 2.2
+**Current version:** 1.1.0  
+**Supported Ruby versions:** 1.8.7, 1.9.2, 1.9.3, 2.0.0, 2.1.0, 2.2, 2.3, Rubinius 3.8
 
 Installation
 ------------
@@ -167,7 +167,8 @@ 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 [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`.
 
 Contact
 -------

data/ext/re2/extconf.rb

@@ -6,6 +6,9 @@
 
 require 'mkmf'
 
+RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"] if ENV["CC"]
+RbConfig::MAKEFILE_CONFIG["CXX"] = ENV["CXX"] if ENV["CXX"]
+
 incl, lib = dir_config("re2", "/usr/local/include", "/usr/local/lib")
 
 $CFLAGS << " -Wall -Wextra -funroll-loops"

data/ext/re2/re2.cc

@@ -89,6 +89,7 @@ typedef struct {
 typedef struct {
   re2::StringPiece *input;
   int number_of_capturing_groups;
+  bool eof;
   VALUE regexp, text;
 } re2_scanner;
 
@@ -172,6 +173,21 @@ static VALUE re2_scanner_string(VALUE self) {
   return c->text;
 }
 
+/*
+ * Returns whether the scanner has consumed all input or not.
+ *
+ * @return [Boolean] whether the scanner has consumed all input or not
+ * @example
+ *   c = RE2::Regexp.new('(\d+)').scan("foo")
+ *   c.eof? #=> true
+ */
+static VALUE re2_scanner_eof(VALUE self) {
+  re2_scanner *c;
+  Data_Get_Struct(self, re2_scanner, c);
+
+  return BOOL2RUBY(c->eof);
+}
+
 /*
  * Rewind the scanner to the start of the string.
  *
@@ -188,6 +204,7 @@ static VALUE re2_scanner_rewind(VALUE self) {
   Data_Get_Struct(self, re2_scanner, c);
 
   c->input = new(nothrow) re2::StringPiece(StringValuePtr(c->text));
+  c->eof = false;
 
   return self;
 }
@@ -204,6 +221,8 @@ static VALUE re2_scanner_rewind(VALUE self) {
  */
 static VALUE re2_scanner_scan(VALUE self) {
   int i;
+  size_t original_input_size, new_input_size;
+  bool input_advanced;
   re2_pattern *p;
   re2_scanner *c;
   VALUE result;
@@ -215,6 +234,12 @@ static VALUE re2_scanner_scan(VALUE self) {
   vector<RE2::Arg*> args(c->number_of_capturing_groups);
   vector<string> matches(c->number_of_capturing_groups);
 
+  if (c->eof) {
+    return Qnil;
+  }
+
+  original_input_size = c->input->size();
+
   for (i = 0; i < c->number_of_capturing_groups; i++) {
     matches[i] = "";
     argv[i] = &matches[i];
@@ -224,6 +249,9 @@ static VALUE re2_scanner_scan(VALUE self) {
   if (RE2::FindAndConsumeN(c->input, *p->pattern, &args[0],
         c->number_of_capturing_groups)) {
     result = rb_ary_new2(c->number_of_capturing_groups);
+    new_input_size = c->input->size();
+    input_advanced = new_input_size < original_input_size;
+
     for (i = 0; i < c->number_of_capturing_groups; i++) {
       if (matches[i].empty()) {
         rb_ary_push(result, Qnil);
@@ -233,6 +261,14 @@ static VALUE re2_scanner_scan(VALUE self) {
               p->pattern->options().utf8() ? "UTF-8" : "ISO-8859-1"));
       }
     }
+
+    /* Check whether we've exhausted the input yet. */
+    c->eof = new_input_size == 0;
+
+    /* If the match didn't advance the input, we need to do this ourselves. */
+    if (!input_advanced && new_input_size > 0) {
+      c->input->remove_prefix(1);
+    }
   } else {
     result = Qnil;
   }
@@ -1216,6 +1252,7 @@ static VALUE re2_regexp_scan(VALUE self, VALUE text) {
   c->regexp = self;
   c->text = text;
   c->number_of_capturing_groups = p->pattern->NumberOfCapturingGroups();
+  c->eof = false;
 
   return scanner;
 }
@@ -1349,6 +1386,8 @@ void Init_re2(void) {
 
   rb_define_method(re2_cScanner, "string",
       RUBY_METHOD_FUNC(re2_scanner_string), 0);
+  rb_define_method(re2_cScanner, "eof?",
+      RUBY_METHOD_FUNC(re2_scanner_eof), 0);
   rb_define_method(re2_cScanner, "regexp",
       RUBY_METHOD_FUNC(re2_scanner_regexp), 0);
   rb_define_method(re2_cScanner, "scan",

data/spec/re2/scanner_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 RSpec.describe RE2::Scanner do
   describe "#regexp" do
     it "returns the original pattern for the scanner" do
@@ -42,6 +44,57 @@ RSpec.describe RE2::Scanner do
       scanner = r.scan("Foo bar")
       expect(scanner.scan).to be_nil
     end
+
+    it "returns an empty array if the input is empty" do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("")
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "returns an array of nil with an empty input and capture" do
+      r = RE2::Regexp.new("()")
+      scanner = r.scan("")
+      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "returns an empty array for every match if the pattern is empty" do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("Foo")
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "returns an array of nil if the pattern is an empty capturing group" do
+      r = RE2::Regexp.new("()")
+      scanner = r.scan("Foo")
+      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "returns array of nils with multiple empty capturing groups" do
+      r = RE2::Regexp.new("()()()")
+      scanner = r.scan("Foo")
+      expect(scanner.scan).to eq([nil, nil, nil])
+      expect(scanner.scan).to eq([nil, nil, nil])
+      expect(scanner.scan).to eq([nil, nil, nil])
+      expect(scanner.scan).to eq([nil, nil, nil])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "supports empty groups with multibyte characters" do
+      r = RE2::Regexp.new("()€")
+      scanner = r.scan("€")
+      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to be_nil
+    end
   end
 
   it "is enumerable" do
@@ -84,5 +137,62 @@ RSpec.describe RE2::Scanner do
       scanner.rewind
       expect(scanner.to_enum.first).to eq(["1"])
     end
+
+    it "resets the eof? check" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("1")
+      scanner.scan
+      expect(scanner.eof?).to be_truthy
+      scanner.rewind
+      expect(scanner.eof?).to be_falsey
+    end
+  end
+
+  describe "#eof?" do
+    it "returns false if the input has not been consumed" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("1 2 3")
+
+      expect(scanner.eof?).to be_falsey
+    end
+
+    it "returns true if the input has been consumed" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("1")
+      scanner.scan
+
+      expect(scanner.eof?).to be_truthy
+    end
+
+    it "returns false if no match is made" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("a")
+      scanner.scan
+
+      expect(scanner.eof?).to be_falsey
+    end
+
+    it "returns false with an empty input that has not been scanned" do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("")
+
+      expect(scanner.eof?).to be_falsey
+    end
+
+    it "returns false with an empty input that has not been matched" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("")
+      scanner.scan
+
+      expect(scanner.eof?).to be_falsey
+    end
+
+    it "returns true with an empty input that has been matched" do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("")
+      scanner.scan
+
+      expect(scanner.eof?).to be_truthy
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Paul Mucur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-11 00:00:00.000000000 Z
+date: 2017-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -80,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Ruby bindings to re2.
@@ -92,4 +92,3 @@ test_files:
 - spec/re2/match_data_spec.rb
 - spec/re2/string_spec.rb
 - spec/re2/scanner_spec.rb
-has_rdoc: