re2 2.4.3 → 2.10.0

data/ext/re2/recipes.rb

@@ -1,25 +1,15 @@
-PACKAGE_ROOT_DIR = File.expand_path('../..', __dir__)
-REQUIRED_MINI_PORTILE_VERSION = '~> 2.8.5' # keep this version in sync with the one in the gemspec
-
-def build_recipe(name, version)
-  require 'rubygems'
-  gem('mini_portile2', REQUIRED_MINI_PORTILE_VERSION) # gemspec is not respected at install time
-  require 'mini_portile2'
+# frozen_string_literal: true
 
-  MiniPortileCMake.new(name, version).tap do |recipe|
-    recipe.target = File.join(PACKAGE_ROOT_DIR, 'ports')
-    recipe.configure_options += [
-      # abseil needs a C++14 compiler
-      '-DCMAKE_CXX_STANDARD=14',
-      # needed for building the C extension shared library with -fPIC
-      '-DCMAKE_POSITION_INDEPENDENT_CODE=ON',
-      # ensures pkg-config and installed libraries will be in lib, not lib64
-      '-DCMAKE_INSTALL_LIBDIR=lib'
-    ]
+# re2 (https://github.com/mudge/re2)
+# Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
+# backtracking regular expression engines like those used in PCRE, Perl, and
+# Python".
+#
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
 
-    yield recipe
-  end
-end
+PACKAGE_ROOT_DIR = File.expand_path('../..', __dir__)
+REQUIRED_MINI_PORTILE_VERSION = '~> 2.8.5' # keep this version in sync with the one in the gemspec
 
 def load_recipes
   require 'yaml'
@@ -41,3 +31,24 @@ def load_recipes
 
   [abseil_recipe, re2_recipe]
 end
+
+def build_recipe(name, version)
+  require 'rubygems'
+  gem('mini_portile2', REQUIRED_MINI_PORTILE_VERSION) # gemspec is not respected at install time
+  require 'mini_portile2'
+
+  MiniPortileCMake.new(name, version).tap do |recipe|
+    recipe.target = File.join(PACKAGE_ROOT_DIR, 'ports')
+    recipe.configure_options += [
+      # abseil needs a C++14 compiler
+      '-DCMAKE_CXX_STANDARD=14',
+      # needed for building the C extension shared library with -fPIC
+      '-DCMAKE_POSITION_INDEPENDENT_CODE=ON',
+      # ensures pkg-config and installed libraries will be in lib, not lib64
+      '-DCMAKE_INSTALL_LIBDIR=lib',
+      '-DCMAKE_CXX_VISIBILITY_PRESET=hidden'
+    ]
+
+    yield recipe
+  end
+end

data/lib/re2/regexp.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# re2 (https://github.com/mudge/re2)
+# Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
+# backtracking regular expression engines like those used in PCRE, Perl, and
+# Python".
+#
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
+
+
+module RE2
+  class Regexp
+    # Match the pattern against any substring of the given `text` and return a
+    # {RE2::MatchData} instance with the specified number of submatches
+    # (defaults to the total number of capturing groups) or a boolean (if no
+    # submatches are required).
+    #
+    # The number of submatches has a significant impact on performance: requesting
+    # one submatch is much faster than requesting more than one and requesting
+    # zero submatches is faster still.
+    #
+    # @param [String] text the text to search
+    # @param [Hash] options the options with which to perform the match
+    # @option options [Integer] :submatches how many submatches to extract (0
+    #   is fastest), defaults to the total number of capturing groups
+    # @return [RE2::MatchData, nil] if extracting any submatches
+    # @return [Boolean] if not extracting any submatches
+    # @raise [ArgumentError] if given a negative number of submatches
+    # @raise [NoMemoryError] if there was not enough memory to allocate the
+    #   matches
+    # @raise [TypeError] if given non-numeric submatches or non-hash options
+    # @example
+    #   r = RE2::Regexp.new('w(o)(o)')
+    #   r.partial_match('woot')                #=> #<RE2::MatchData "woo" 1:"o" 2:"o">
+    #   r.partial_match('nope')                #=> nil
+    #   r.partial_match('woot', submatches: 1) #=> #<RE2::MatchData "woo" 1:"o">
+    #   r.partial_match('woot', submatches: 0) #=> true
+    def partial_match(text, options = {})
+      match(text, Hash(options).merge(anchor: :unanchored))
+    end
+
+    # Match the pattern against the given `text` exactly and return a
+    # {RE2::MatchData} instance with the specified number of submatches
+    # (defaults to the total number of capturing groups) or a boolean (if no
+    # submatches are required).
+    #
+    # The number of submatches has a significant impact on performance: requesting
+    # one submatch is much faster than requesting more than one and requesting
+    # zero submatches is faster still.
+    #
+    # @param [String] text the text to search
+    # @param [Hash] options the options with which to perform the match
+    # @option options [Integer] :submatches how many submatches to extract (0
+    #   is fastest), defaults to the total number of capturing groups
+    # @return [RE2::MatchData, nil] if extracting any submatches
+    # @return [Boolean] if not extracting any submatches
+    # @raise [ArgumentError] if given a negative number of submatches
+    # @raise [NoMemoryError] if there was not enough memory to allocate the
+    #   matches
+    # @raise [TypeError] if given non-numeric submatches or non-hash options
+    # @example
+    #   r = RE2::Regexp.new('w(o)(o)')
+    #   r.full_match('woo')                #=> #<RE2::MatchData "woo" 1:"o" 2:"o">
+    #   r.full_match('woot')               #=> nil
+    #   r.full_match('woo', submatches: 1) #=> #<RE2::MatchData "woo" 1:"o">
+    #   r.full_match('woo', submatches: 0) #=> true
+    def full_match(text, options = {})
+      match(text, Hash(options).merge(anchor: :anchor_both))
+    end
+  end
+end

data/lib/re2/scanner.rb

@@ -1,3 +1,14 @@
+# frozen_string_literal: true
+
+# re2 (https://github.com/mudge/re2)
+# Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
+# backtracking regular expression engines like those used in PCRE, Perl, and
+# Python".
+#
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
+
+
 module RE2
   class Scanner
     include Enumerable

data/lib/re2/string.rb

@@ -1,81 +1,34 @@
-# re2 (http://github.com/mudge/re2)
-# Ruby bindings to re2, an "efficient, principled regular expression library"
+# frozen_string_literal: true
+
+# re2 (https://github.com/mudge/re2)
+# Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
+# backtracking regular expression engines like those used in PCRE, Perl, and
+# Python".
 #
-# Copyright (c) 2010-2014, Paul Mucur (http://mudge.name)
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
 # Released under the BSD Licence, please see LICENSE.txt
 
 require "re2"
 
 module RE2
+  # @deprecated Use methods on {RE2} and {RE2::Regexp} instead.
   module String
-
-    # Replaces the first occurrence +pattern+ with +rewrite+ and returns a new
-    # string.
-    #
-    # @see RE2.Replace
+    # @deprecated Use {RE2.Replace} instead.
     def re2_sub(*args)
       RE2.Replace(self, *args)
     end
 
-    # Replaces every occurrence of +pattern+ with +rewrite+ and return a new string.
-    #
-    # @see RE2.GlobalReplace
+    # @deprecated Use {RE2.GlobalReplace} instead.
     def re2_gsub(*args)
       RE2.GlobalReplace(self, *args)
     end
 
-    # Match the pattern and return either a boolean (if no submatches are required)
-    # or a {RE2::MatchData} instance.
-    #
-    # @return [Boolean, RE2::MatchData]
-    #
-    # @overload match(pattern)
-    #   Returns an {RE2::MatchData} containing the matching
-    #   pattern and all subpatterns resulting from looking for
-    #   +pattern+.
-    #
-    #   @param [String, RE2::Regexp] pattern the regular expression to match
-    #   @return [RE2::MatchData] the matches
-    #   @raise [NoMemoryError] if there was not enough memory to allocate the matches
-    #   @example
-    #     r = RE2::Regexp.new('w(o)(o)')
-    #     "woo".re2_match(r)             #=> #<RE2::MatchData "woo" 1:"o" 2:"o">
-    #
-    # @overload match(pattern, 0)
-    #   Returns either true or false indicating whether a
-    #   successful match was made.
-    #
-    #   @param [String, RE2::Regexp] pattern the regular expression to match
-    #   @return [Boolean] whether the match was successful
-    #   @raise [NoMemoryError] if there was not enough memory to allocate the matches
-    #   @example
-    #     r = RE2::Regexp.new('w(o)(o)')
-    #     "woo".re2_match(0) #=> true
-    #     "bob".re2_match(0) #=> false
-    #
-    # @overload match(pattern, number_of_matches)
-    #   See +match(pattern)+ but with a specific number of
-    #   matches returned (padded with nils if necessary).
-    #
-    #   @param [String, RE2::Regexp] pattern the regular expression to match
-    #   @param [Integer] number_of_matches the number of matches to return
-    #   @return [RE2::MatchData] the matches
-    #   @raise [NoMemoryError] if there was not enough memory to allocate the matches
-    #   @example
-    #     r = RE2::Regexp.new('w(o)(o)')
-    #     "woo".re2_match(r, 1) #=> #<RE2::MatchData "woo" 1:"o">
-    #     "woo".re2_match(r, 3) #=> #<RE2::MatchData "woo" 1:"o" 2:"o" 3:nil>
+    # @deprecated Use {RE2::Regexp#match} instead.
     def re2_match(pattern, *args)
       RE2::Regexp.new(pattern).match(self, *args)
     end
 
-    # Escapes all potentially meaningful regexp characters.
-    # The returned string, used as a regular expression, will exactly match the
-    # original string.
-    #
-    # @return [String] the escaped string
-    # @example
-    #   "1.5-2.0?".escape    #=> "1\.5\-2\.0\?"
+    # @deprecated Use {RE2.QuoteMeta} instead.
     def re2_escape
       RE2.QuoteMeta(self)
     end

data/lib/re2/version.rb

@@ -1,5 +1,14 @@
 # frozen_string_literal: true
 
+# re2 (https://github.com/mudge/re2)
+# Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
+# backtracking regular expression engines like those used in PCRE, Perl, and
+# Python".
+#
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
+
+
 module RE2
-  VERSION = "2.4.3"
+  VERSION = "2.10.0"
 end

data/lib/re2.rb

@@ -1,8 +1,13 @@
-# re2 (http://github.com/mudge/re2)
-# Ruby bindings to re2, an "efficient, principled regular expression library"
+# frozen_string_literal: true
+
+# re2 (https://github.com/mudge/re2)
+# Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
+# backtracking regular expression engines like those used in PCRE, Perl, and
+# Python".
 #
-# Copyright (c) 2010-2014, Paul Mucur (http://mudge.name)
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
 # Released under the BSD Licence, please see LICENSE.txt
+
 begin
   ::RUBY_VERSION =~ /(\d+\.\d+)/
   require_relative "#{Regexp.last_match(1)}/re2.so"
@@ -10,5 +15,6 @@ rescue LoadError
   require 're2.so'
 end
 
+require "re2/regexp"
 require "re2/scanner"
 require "re2/version"

data/re2.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'lib/re2/version'
 
 Gem::Specification.new do |s|
@@ -17,6 +19,7 @@ Gem::Specification.new do |s|
     "ext/re2/recipes.rb",
     "Gemfile",
     "lib/re2.rb",
+    "lib/re2/regexp.rb",
     "lib/re2/scanner.rb",
     "lib/re2/string.rb",
     "lib/re2/version.rb",
@@ -37,8 +40,8 @@ Gem::Specification.new do |s|
     "spec/re2/set_spec.rb",
     "spec/re2/scanner_spec.rb"
   ]
-  s.add_development_dependency("rake-compiler", "~> 1.2.1")
-  s.add_development_dependency("rake-compiler-dock", "~> 1.3.0")
+  s.add_development_dependency("rake-compiler", "~> 1.2.5")
+  s.add_development_dependency("rake-compiler-dock", "~> 1.4.0")
   s.add_development_dependency("rspec", "~> 3.2")
   s.add_runtime_dependency("mini_portile2", "~> 2.8.5") # keep version in sync with extconf.rb
 end

data/spec/kernel_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe Kernel do
   describe ".RE2" do
     it "returns an RE2::Regexp instance given a pattern" do
@@ -5,17 +7,23 @@ RSpec.describe Kernel do
     end
 
     it "returns an RE2::Regexp instance given a pattern and options" do
-      re = RE2('w(o)(o)', :case_sensitive => false)
+      re = RE2('w(o)(o)', case_sensitive: false)
 
       expect(re).not_to be_case_sensitive
     end
 
+    it "accepts patterns containing null bytes" do
+      re = RE2("a\0b")
+
+      expect(re.pattern).to eq("a\0b")
+    end
+
     it "raises an error if given an inappropriate type" do
       expect { RE2(nil) }.to raise_error(TypeError)
     end
 
     it "allows invalid patterns to be created" do
-      re = RE2('???', :log_errors => false)
+      re = RE2('???', log_errors: false)
 
       expect(re).to be_a(RE2::Regexp)
     end