re2 0.7.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 32a2347d40362a3014dfd03f948405964468a3c2
-  data.tar.gz: ea15968dae15568249200c6ba91bad66d0e28f6f
+  metadata.gz: 118d0c677843bd7166804670d548504e6a30410b
+  data.tar.gz: 9efe563b54262ad28c5b71c2317b3f18117e2706
 SHA512:
-  metadata.gz: 00588950e6c82fb5720043c04d0f833d819f3107a3c953f2284d9eaede74210c0c803f34b3e9fd89413c886fae1e4b853b5a85b18b3c2d788ff0a7e8b46036cf
-  data.tar.gz: af2d23503d089a15ea6dd32e00bc80622cd7b0b1773ed471edcc982ac6791a6d1bf0bf5332d2440446796b5a4da15a169fd7396e3cf729af8a300e52a5985bad
+  metadata.gz: 07d895cafa392c75483586a37b44f57b5d5979b7473529c52eff05f3c6bccca3b11f8d406363ece9f3ab2ad02df4952031dcdb8104cdc275484666a0ceb7db01
+  data.tar.gz: 8147a0194f92a7850285339d9d81fe74b4865d12f67a1e64fa9db3eeec35c3adaaf4cfd97862f1d954b7b475b4dc4b0d01ef28dd10c3f39cba3338caac6ff51a

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:** 0.7.0  
-**Supported Ruby versions:** 1.8.7, 1.9.2, 1.9.3, 2.0.0, 2.1.0, Rubinius 2.2
+**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
 
 Installation
 ------------
@@ -21,6 +21,8 @@ If you are using Debian, you can install the [libre2-dev][] package like so:
 
     $ sudo apt-get install libre2-dev
 
+Recent versions of re2 require a compiler with C++11 support such as [clang](http://clang.llvm.org/) 3.4 or [gcc](https://gcc.gnu.org/) 4.8.
+
 If you are using a packaged Ruby distribution, make sure you also have the
 Ruby header files installed such as those provided by the [ruby-dev][] package
 on Debian and Ubuntu.
@@ -35,14 +37,17 @@ Documentation
 Full documentation automatically generated from the latest version is
 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.
+Note that re2's regular expression syntax differs from PCRE and Ruby's
+built-in [`Regexp`][Regexp] library, see the [official syntax page][] for more
+details.
 
 Usage
 -----
 
-You can use re2 as a mostly drop-in replacement for Ruby's own [Regexp][] and
-[MatchData][] classes:
+While re2 uses the same naming scheme as Ruby's built-in regular expression
+library (with [`Regexp`](http://mudge.name/re2/RE2/Regexp.html) and
+[`MatchData`](http://mudge.name/re2/RE2/MatchData.html)), its API is slightly
+different:
 
 ```console
 $ irb -rubygems
@@ -67,9 +72,11 @@ $ irb -rubygems
 => 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:
+As
+[`RE2::Regexp.new`](http://mudge.name/re2/RE2/Regexp.html#initialize-instance_method)
+(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+)')
@@ -123,7 +130,7 @@ Features
 --------
 
 * Pre-compiling regular expressions with
-  [`RE2::Regexp.new(re)`](http://code.google.com/p/re2/source/browse/re2/re2.h#96),
+  [`RE2::Regexp.new(re)`](https://github.com/google/re2/blob/2016-02-01/re2/re2.h#L100),
   `RE2::Regexp.compile(re)` or `RE2(re)` (including specifying options, e.g.
   `RE2::Regexp.new("pattern", :case_sensitive => false)`
 
@@ -152,21 +159,22 @@ Features
   `pattern.replace_all(replacement, original)`
 
 * Escaping regular expressions with
-  [`RE2.escape(unquoted)`](http://code.google.com/p/re2/source/browse/re2/re2.h#377) and
+  [`RE2.escape(unquoted)`](https://github.com/google/re2/blob/2016-02-01/re2/re2.h#L418) 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`.
+* 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.
 
 Contact
 -------
 
 All feedback should go to the mailing list: <mailto:ruby.re2@librelist.com>
 
-  [re2]: http://code.google.com/p/re2/
+  [re2]: https://github.com/google/re2
   [gcc]: http://gcc.gnu.org/
   [ruby-dev]: http://packages.debian.org/ruby-dev
   [build-essential]: http://packages.debian.org/build-essential
@@ -174,5 +182,5 @@ All feedback should go to the mailing list: <mailto:ruby.re2@librelist.com>
   [MatchData]: http://ruby-doc.org/core/classes/MatchData.html
   [Homebrew]: http://mxcl.github.com/homebrew
   [libre2-dev]: http://packages.debian.org/search?keywords=libre2-dev
-  [official syntax page]: http://code.google.com/p/re2/wiki/Syntax
+  [official syntax page]: https://github.com/google/re2/wiki/Syntax
 

data/Rakefile

@@ -1,15 +1,10 @@
 require 'rake/extensiontask'
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
 Rake::ExtensionTask.new('re2')
 
-Rake::TestTask.new do |t|
-  t.libs << "spec"
-  t.test_files = FileList["spec/**/*_spec.rb"]
-  t.verbose = true
-end
+RSpec::Core::RakeTask.new(:spec)
 
-task :test    => :compile
-task :spec    => :test
-task :default => :test
+task :spec    => :compile
+task :default => :spec
 

data/ext/re2/extconf.rb

@@ -10,20 +10,46 @@ incl, lib = dir_config("re2", "/usr/local/include", "/usr/local/lib")
 
 $CFLAGS << " -Wall -Wextra -funroll-loops"
 
+# Pass -x c++ to force gcc to compile the test program
+# as C++ (as it will end in .c by default).
+compile_options = "-x c++"
+
 have_library("stdc++")
 have_header("stdint.h")
 have_func("rb_str_sublen")
 
-if have_library("re2")
+unless have_library("re2")
+  abort "You must have re2 installed and specified with --with-re2-dir, please see https://github.com/google/re2/wiki/Install"
+end
 
-  # Determine which version of re2 the user has installed.
-  # Revision d9f8806c004d added an `endpos` argument to the
-  # generic Match() function.
-  #
-  # To test for this, try to compile a simple program that uses
-  # the newer form of Match() and set a flag if it is successful.
-  checking_for("RE2::Match() with endpos argument") do
-    test_re2_match_signature = <<SRC
+# Recent versions of re2 now require a compiler with C++11 support
+checking_for("re2 requires C++11 compiler") do
+  minimal_program = <<SRC
+#include <re2/re2.h>
+int main() { return 0; }
+SRC
+
+  unless try_compile(minimal_program, compile_options)
+    if try_compile(minimal_program, compile_options + " -std=c++11")
+      compile_options << " -std=c++11"
+      $CPPFLAGS << " -std=c++11"
+    elsif try_compile(minimal_program, compile_options + " -std=c++0x")
+      compile_options << " -std=c++0x"
+      $CPPFLAGS << " -std=c++0x"
+    else
+      abort "Cannot compile re2 with your compiler: recent versions require C++11 support."
+    end
+  end
+end
+
+# Determine which version of re2 the user has installed.
+# Revision d9f8806c004d added an `endpos` argument to the
+# generic Match() function.
+#
+# To test for this, try to compile a simple program that uses
+# the newer form of Match() and set a flag if it is successful.
+checking_for("RE2::Match() with endpos argument") do
+  test_re2_match_signature = <<SRC
 #include <re2/re2.h>
 
 int main() {
@@ -35,14 +61,9 @@ int main() {
 }
 SRC
 
-    # Pass -x c++ to force gcc to compile the test program
-    # as C++ (as it will end in .c by default).
-    if try_compile(test_re2_match_signature, "-x c++")
-      $defs.push("-DHAVE_ENDPOS_ARGUMENT")
-    end
+  if try_compile(test_re2_match_signature, compile_options)
+    $defs.push("-DHAVE_ENDPOS_ARGUMENT")
   end
-
-  create_makefile("re2")
-else
-  abort "You must have re2 installed and specified with --with-re2-dir, please see http://code.google.com/p/re2/wiki/Install"
 end
+
+create_makefile("re2")

data/ext/re2/re2.cc

@@ -6,8 +6,8 @@
  * Released under the BSD Licence, please see LICENSE.txt
  */
 
-#include <re2/re2.h>
 #include <ruby.h>
+#include <re2/re2.h>
 #include <stdint.h>
 #include <string>
 #include <sstream>

data/spec/kernel_spec.rb

@@ -1,15 +1,13 @@
-require "spec_helper"
-
-describe Kernel do
+RSpec.describe Kernel do
   describe "#RE2" do
     it "returns an RE2::Regexp instance given a pattern" do
-      RE2('w(o)(o)').must_be_instance_of(RE2::Regexp)
+      expect(RE2('w(o)(o)')).to be_a(RE2::Regexp)
     end
 
     it "returns an RE2::Regexp instance given a pattern and options" do
       re = RE2('w(o)(o)', :case_sensitive => false)
-      re.must_be_instance_of(RE2::Regexp)
-      re.wont_be(:case_sensitive?)
+      expect(re).to be_a(RE2::Regexp)
+      expect(re).to_not be_case_sensitive
     end
   end
 end

data/spec/re2/match_data_spec.rb

@@ -1,94 +1,90 @@
 # encoding: utf-8
-
-require "spec_helper"
-
-describe RE2::MatchData do
-
+RSpec.describe RE2::MatchData do
   describe "#to_a" do
     it "is populated with the match and capturing groups" do
       a = RE2::Regexp.new('w(o)(o)').match('woo').to_a
-      a.must_equal(["woo", "o", "o"])
+      expect(a).to eq(["woo", "o", "o"])
     end
 
     it "populates optional capturing groups with nil if they are missing" do
       a = RE2::Regexp.new('(\d?)(a)(b)').match('ab').to_a
-      a.must_equal(["ab", nil, "a", "b"])
+      expect(a).to eq(["ab", nil, "a", "b"])
     end
   end
 
   describe "#[]" do
     it "accesses capturing groups by numerical index" do
       md = RE2::Regexp.new('(\d)(\d{2})').match("123")
-      md[1].must_equal("1")
-      md[2].must_equal("23")
+      expect(md[1]).to eq("1")
+      expect(md[2]).to eq("23")
     end
 
     it "has the whole match as the 0th item" do
       md = RE2::Regexp.new('(\d)(\d{2})').match("123")
-      md[0].must_equal("123")
+      expect(md[0]).to eq("123")
     end
 
     it "supports access by numerical ranges" do
       md = RE2::Regexp.new('(\d+) (\d+) (\d+)').match("123 456 789")
-      md[1..3].must_equal(["123", "456", "789"])
-      md[1...3].must_equal(["123", "456"])
+      expect(md[1..3]).to eq(["123", "456", "789"])
+      expect(md[1...3]).to eq(["123", "456"])
     end
 
     it "supports slicing" do
       md = RE2::Regexp.new('(\d+) (\d+) (\d+)').match("123 456 789")
-      md[1, 3].must_equal(["123", "456", "789"])
-      md[1, 2].must_equal(["123", "456"])
+      expect(md[1, 3]).to eq(["123", "456", "789"])
+      expect(md[1, 2]).to eq(["123", "456"])
     end
 
     it "returns nil if attempting to access non-existent capturing groups by index" do
       md = RE2::Regexp.new('(\d+)').match('bob 123')
-      md[2].must_be_nil
-      md[3].must_be_nil
+      expect(md[2]).to be_nil
+      expect(md[3]).to be_nil
     end
 
     it "allows access by string names when there are named groups" do
       md = RE2::Regexp.new('(?P<numbers>\d+)').match('bob 123')
-      md["numbers"].must_equal("123")
+      expect(md["numbers"]).to eq("123")
     end
 
     it "allows access by symbol names when there are named groups" do
       md = RE2::Regexp.new('(?P<numbers>\d+)').match('bob 123')
-      md[:numbers].must_equal("123")
+      expect(md[:numbers]).to eq("123")
     end
 
     it "allows access by names and indices with mixed groups" do
       md = RE2::Regexp.new('(?P<name>\w+)(\s*)(?P<numbers>\d+)').match("bob 123")
-      md["name"].must_equal("bob")
-      md[:name].must_equal("bob")
-      md[2].must_equal(" ")
-      md["numbers"].must_equal("123")
-      md[:numbers].must_equal("123")
+      expect(md["name"]).to eq("bob")
+      expect(md[:name]).to eq("bob")
+      expect(md[2]).to eq(" ")
+      expect(md["numbers"]).to eq("123")
+      expect(md[:numbers]).to eq("123")
     end
 
     it "returns nil if no such named group exists" do
       md = RE2::Regexp.new('(\d+)').match("bob 123")
-      md["missing"].must_be_nil
-      md[:missing].must_be_nil
+      expect(md["missing"]).to be_nil
+      expect(md[:missing]).to 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)
+      expect { md[nil] }.to raise_error(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")
-        md[0].encoding.name.must_equal("UTF-8")
-        md["name"].encoding.name.must_equal("UTF-8")
-        md[:name].encoding.name.must_equal("UTF-8")
+        expect(md[0].encoding.name).to eq("UTF-8")
+        expect(md["name"].encoding.name).to eq("UTF-8")
+        expect(md[:name].encoding.name).to eq("UTF-8")
       end
 
       it "returns Latin 1 strings encoding when utf-8 is false" do
         md = RE2::Regexp.new('(?P<name>\S+)', :utf8 => false).match('bob')
-        md[0].encoding.name.must_equal("ISO-8859-1")
-        md["name"].encoding.name.must_equal("ISO-8859-1")
-        md[:name].encoding.name.must_equal("ISO-8859-1")
+        expect(md[0].encoding.name).to eq("ISO-8859-1")
+        expect(md["name"].encoding.name).to eq("ISO-8859-1")
+        expect(md[:name].encoding.name).to eq("ISO-8859-1")
       end
     end
   end
@@ -96,32 +92,32 @@ describe RE2::MatchData do
   describe "#string" do
     it "returns the original string to match against" do
       re = RE2::Regexp.new('(\D+)').match("bob")
-      re.string.must_equal("bob")
+      expect(re.string).to eq("bob")
     end
 
     it "returns a copy, not the actual original" do
       string = "bob"
       re = RE2::Regexp.new('(\D+)').match(string)
-      re.string.wont_be_same_as(string)
+      expect(re.string).to_not equal(string)
     end
 
     it "returns a frozen string" do
       re = RE2::Regexp.new('(\D+)').match("bob")
-      re.string.must_be(:frozen?)
+      expect(re.string).to be_frozen
     end
   end
 
   describe "#size" do
     it "returns the number of capturing groups plus the matching string" do
       md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
-      md.size.must_equal(3)
+      expect(md.size).to eq(3)
     end
   end
 
   describe "#length" do
     it "returns the number of capturing groups plus the matching string" do
       md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
-      md.length.must_equal(3)
+      expect(md.length).to eq(3)
     end
   end
 
@@ -129,26 +125,26 @@ describe RE2::MatchData do
     it "returns the original RE2::Regexp used" do
       re = RE2::Regexp.new('(\d+)')
       md = re.match("123")
-      md.regexp.must_be_same_as(re)
+      expect(md.regexp).to equal(re)
     end
   end
 
   describe "#inspect" do
     it "returns a text representation of the object and indices" do
       md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
-      md.inspect.must_equal('#<RE2::MatchData "1234 56" 1:"1234" 2:"56">')
+      expect(md.inspect).to eq('#<RE2::MatchData "1234 56" 1:"1234" 2:"56">')
     end
 
     it "represents missing matches as nil" do
       md = RE2::Regexp.new('(\d+) (\d+)?').match("1234 ")
-      md.inspect.must_equal('#<RE2::MatchData "1234 " 1:"1234" 2:nil>')
+      expect(md.inspect).to eq('#<RE2::MatchData "1234 " 1:"1234" 2:nil>')
     end
   end
 
   describe "#to_s" do
     it "returns the matching part of the original string" do
       md = RE2::Regexp.new('(\d{2,5})').match("one two 23456")
-      md.to_s.must_equal("23456")
+      expect(md.to_s).to eq("23456")
     end
   end
 
@@ -156,53 +152,93 @@ describe RE2::MatchData do
     it "allows the object to be expanded with an asterisk" do
       md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
       m1, m2, m3 = *md
-      m1.must_equal("1234 56")
-      m2.must_equal("1234")
-      m3.must_equal("56")
+      expect(m1).to eq("1234 56")
+      expect(m2).to eq("1234")
+      expect(m3).to eq("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')
+      expect(md.string[md.begin(0)..-1]).to eq('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')
+      expect(md.string[md.begin('foo')..-1]).to eq('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')
+      expect(md.string[md.begin(:foo)..-1]).to eq('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')
+      expect(md.string[md.begin(0)..-1]).to eq('Ruby')
+    end
+
+    it "returns nil for non-existent numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin(10)).to be_nil
+    end
+
+    it "returns nil for negative numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin(-4)).to be_nil
+    end
+
+    it "returns nil for non-existent named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin('foo')).to be_nil
+    end
+
+    it "returns nil for non-existent symbol named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin(:foo)).to be_nil
     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')
+      expect(md.string[0...md.end(0)]).to eq('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')
+      expect(md.string[0...md.end('foo')]).to eq('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')
+      expect(md.string[0...md.end(:foo)]).to eq('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')
+      expect(md.string[0...md.end(0)]).to eq('I ♥ Ruby')
+    end
+
+    it "returns nil for non-existent numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end(10)).to be_nil
+    end
+
+    it "returns nil for negative numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end(-4)).to be_nil
+    end
+
+    it "returns nil for non-existent named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end('foo')).to be_nil
+    end
+
+    it "returns nil for non-existent symbol named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end(:foo)).to be_nil
     end
   end
 end