re2 2.15.0.rc1-x86-linux-musl

data/spec/re2/scanner_spec.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+RSpec.describe RE2::Scanner do
+  describe "#regexp" do
+    it "returns the original pattern for the scanner" do
+      re = RE2::Regexp.new('(\w+)')
+      scanner = re.scan("It is a truth")
+
+      expect(scanner.regexp).to equal(re)
+    end
+  end
+
+  describe "#string" do
+    it "returns the original text for the scanner" do
+      re = RE2::Regexp.new('(\w+)')
+      text = "It is a truth"
+      scanner = re.scan(text)
+
+      expect(scanner.string).to equal(text)
+    end
+  end
+
+  describe "#scan" do
+    it "returns the next array of matches", :aggregate_failures do
+      r = RE2::Regexp.new('(\w+)')
+      scanner = r.scan("It is a truth universally acknowledged")
+
+      expect(scanner.scan).to eq(["It"])
+      expect(scanner.scan).to eq(["is"])
+      expect(scanner.scan).to eq(["a"])
+      expect(scanner.scan).to eq(["truth"])
+      expect(scanner.scan).to eq(["universally"])
+      expect(scanner.scan).to eq(["acknowledged"])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "supports scanning inputs with null bytes", :aggregate_failures do
+      r = RE2::Regexp.new("(\\w\0\\w)")
+      scanner = r.scan("a\0b c\0d e\0f")
+
+      expect(scanner.scan).to eq(["a\0b"])
+      expect(scanner.scan).to eq(["c\0d"])
+      expect(scanner.scan).to eq(["e\0f"])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "returns UTF-8 matches if the pattern is UTF-8" do
+      r = RE2::Regexp.new('(\w+)')
+      scanner = r.scan("It")
+      matches = scanner.scan
+
+      expect(matches.first.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "returns ISO-8859-1 matches if the pattern is not UTF-8" do
+      r = RE2::Regexp.new('(\w+)', utf8: false)
+      scanner = r.scan("It")
+      matches = scanner.scan
+
+      expect(matches.first.encoding).to eq(Encoding::ISO_8859_1)
+    end
+
+    it "returns multiple capturing groups at a time", :aggregate_failures do
+      r = RE2::Regexp.new('(\w+) (\w+)')
+      scanner = r.scan("It is a truth universally acknowledged")
+
+      expect(scanner.scan).to eq(["It", "is"])
+      expect(scanner.scan).to eq(["a", "truth"])
+      expect(scanner.scan).to eq(["universally", "acknowledged"])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "returns an empty array if there are no capturing groups" do
+      r = RE2::Regexp.new('\w+')
+      scanner = r.scan("Foo bar")
+
+      expect(scanner.scan).to eq([])
+    end
+
+    it "returns nil if there is no match" do
+      r = RE2::Regexp.new('\d+')
+      scanner = r.scan("Foo bar")
+
+      expect(scanner.scan).to be_nil
+    end
+
+    it "returns nil if the regexp is invalid" do
+      r = RE2::Regexp.new('???', log_errors: false)
+      scanner = r.scan("Foo bar")
+
+      expect(scanner.scan).to be_nil
+    end
+
+    it "returns an empty array if the input is empty", :aggregate_failures 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", :aggregate_failures 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", :aggregate_failures 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", :aggregate_failures 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", :aggregate_failures 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", :aggregate_failures do
+      r = RE2::Regexp.new("()€")
+      scanner = r.scan("€")
+
+      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "raises a Type Error if given input that can't be coerced to a String" do
+      r = RE2::Regexp.new('(\w+)')
+
+      expect { r.scan(0) }.to raise_error(TypeError)
+    end
+
+    it "accepts input that can be coerced to a String", :aggregate_failures do
+      r = RE2::Regexp.new('(\w+)')
+      scanner = r.scan(StringLike.new("Hello world"))
+
+      expect(scanner.scan).to eq(["Hello"])
+      expect(scanner.scan).to eq(["world"])
+      expect(scanner.scan).to be_nil
+    end
+  end
+
+  it "is enumerable" do
+    r = RE2::Regexp.new('(\d)')
+    scanner = r.scan("There are 1 some 2 numbers 3")
+
+    expect(scanner).to be_a(Enumerable)
+  end
+
+  describe "#each" do
+    it "yields each match" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("There are 1 some 2 numbers 3")
+
+      expect { |b| scanner.each(&b) }.to yield_successive_args(["1"], ["2"], ["3"])
+    end
+
+    it "returns an enumerator when not given a block" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("There are 1 some 2 numbers 3")
+
+      expect(scanner.each).to be_a(Enumerator)
+    end
+  end
+
+  describe "#rewind" do
+    it "resets any consumption", :aggregate_failures do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("There are 1 some 2 numbers 3")
+
+      expect(scanner.to_enum.first).to eq(["1"])
+      expect(scanner.to_enum.first).to eq(["2"])
+
+      scanner.rewind
+
+      expect(scanner.to_enum.first).to eq(["1"])
+    end
+
+    it "supports inputs with null bytes", :aggregate_failures do
+      r = RE2::Regexp.new("(\\w\0\\w)")
+      scanner = r.scan("a\0b c\0d")
+
+      expect(scanner.to_enum.first).to eq(["a\0b"])
+      expect(scanner.to_enum.first).to eq(["c\0d"])
+
+      scanner.rewind
+
+      expect(scanner.to_enum.first).to eq(["a\0b"])
+    end
+
+    it "resets the eof? check", :aggregate_failures do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("1")
+      scanner.scan
+
+      expect(scanner).to be_eof
+
+      scanner.rewind
+
+      expect(scanner).not_to be_eof
+    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).not_to be_eof
+    end
+
+    it "returns true if the input has been consumed" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("1")
+      scanner.scan
+
+      expect(scanner).to be_eof
+    end
+
+    it "returns false if no match is made" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("a")
+      scanner.scan
+
+      expect(scanner).not_to be_eof
+    end
+
+    it "returns false with an empty input that has not been scanned" do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("")
+
+      expect(scanner).not_to be_eof
+    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).not_to be_eof
+    end
+
+    it "returns true with an empty input that has been matched" do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("")
+      scanner.scan
+
+      expect(scanner).to be_eof
+    end
+  end
+end

data/spec/re2/set_spec.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+RSpec.describe RE2::Set do
+  describe "#initialize" do
+    it "returns an instance given no args" do
+      set = RE2::Set.new
+
+      expect(set).to be_a(RE2::Set)
+    end
+
+    it "returns an instance given only an anchor of :unanchored" do
+      set = RE2::Set.new(:unanchored)
+
+      expect(set).to be_a(RE2::Set)
+    end
+
+    it "returns an instance given only an anchor of :anchor_start" do
+      set = RE2::Set.new(:anchor_start)
+
+      expect(set).to be_a(RE2::Set)
+    end
+
+    it "returns an instance given only an anchor of :anchor_both" do
+      set = RE2::Set.new(:anchor_both)
+
+      expect(set).to be_a(RE2::Set)
+    end
+
+    it "returns an instance given an anchor and options" do
+      set = RE2::Set.new(:unanchored, case_sensitive: false)
+
+      expect(set).to be_a(RE2::Set)
+    end
+
+    it "raises an error if given an inappropriate type" do
+      expect { RE2::Set.new(0) }.to raise_error(TypeError)
+    end
+
+    it "raises an error if given an invalid anchor" do
+      expect { RE2::Set.new(:not_a_valid_anchor) }.to raise_error(
+        ArgumentError,
+        "anchor should be one of: :unanchored, :anchor_start, :anchor_both"
+      )
+    end
+
+    it "raises an error if given an invalid anchor and options" do
+      expect { RE2::Set.new(:not_a_valid_anchor, case_sensitive: false) }.to raise_error(
+        ArgumentError,
+        "anchor should be one of: :unanchored, :anchor_start, :anchor_both"
+      )
+    end
+  end
+
+  describe "#add" do
+    it "allows multiple patterns to be added", :aggregate_failures do
+      set = RE2::Set.new
+
+      expect(set.add("abc")).to eq(0)
+      expect(set.add("def")).to eq(1)
+      expect(set.add("ghi")).to eq(2)
+    end
+
+    it "rejects invalid patterns when added" do
+      set = RE2::Set.new(:unanchored, log_errors: false)
+
+      expect { set.add("???") }.to raise_error(ArgumentError, /str rejected by RE2::Set->Add\(\)/)
+    end
+
+    it "truncates error messages to 100 characters" do
+      set = RE2::Set.new(:unanchored, log_errors: false)
+
+      expect { set.add("(?P<#{'o' * 200}") }.to raise_error(ArgumentError, "str rejected by RE2::Set->Add(): invalid named capture group: (?P<oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo")
+    end
+
+    it "raises an error if called after #compile" do
+      set = RE2::Set.new(:unanchored, log_errors: false)
+      set.add("abc")
+      set.compile
+
+      silence_stderr do
+        expect { set.add("def") }.to raise_error(ArgumentError)
+      end
+    end
+
+    it "raises an error if given a pattern that can't be coerced to a String" do
+      set = RE2::Set.new(:unanchored, log_errors: false)
+
+      expect { set.add(0) }.to raise_error(TypeError)
+    end
+
+    it "accepts a pattern that can be coerced to a String" do
+      set = RE2::Set.new
+
+      expect(set.add(StringLike.new("abc"))).to eq(0)
+    end
+  end
+
+  describe "#compile" do
+    it "compiles the set without error" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.add("def")
+      set.add("ghi")
+
+      expect(set.compile).to be_truthy
+    end
+  end
+
+  describe "#match" do
+    it "matches against multiple patterns" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.add("def")
+      set.add("ghi")
+      set.compile
+
+      expect(set.match("abcdefghi", exception: false)).to eq([0, 1, 2])
+    end
+
+    it "returns an empty array if there is no match" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect(set.match("def", exception: false)).to be_empty
+    end
+
+    it "supports matching null bytes", :aggregate_failures do
+      set = RE2::Set.new
+      set.add("a\0b")
+      set.compile
+
+      expect(set.match("a\0b", exception: false)).to eq([0])
+    end
+
+    it "returns an empty array if there is no match when :exception is true" do
+      skip "Underlying RE2::Set::Match does not output error information" unless RE2::Set.match_raises_errors?
+
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect(set.match("def")).to be_empty
+    end
+
+    it "raises an error if called before #compile by default" do
+      skip "Underlying RE2::Set::Match does not output error information" unless RE2::Set.match_raises_errors?
+
+      set = RE2::Set.new(:unanchored, log_errors: false)
+
+      silence_stderr do
+        expect { set.match("") }.to raise_error(RE2::Set::MatchError)
+      end
+    end
+
+    it "raises an error if called before #compile when :exception is true" do
+      skip "Underlying RE2::Set::Match does not output error information" unless RE2::Set.match_raises_errors?
+
+      set = RE2::Set.new(:unanchored, log_errors: false)
+
+      silence_stderr do
+        expect { set.match("", exception: true) }.to raise_error(RE2::Set::MatchError)
+      end
+    end
+
+    it "returns an empty array if called before #compile when :exception is false" do
+      set = RE2::Set.new(:unanchored, log_errors: false)
+
+      silence_stderr do
+        expect(set.match("", exception: false)).to be_empty
+      end
+    end
+
+    it "raises an error if :exception is true and RE2 does not support it" do
+      skip "Underlying RE2::Set::Match outputs error information" if RE2::Set.match_raises_errors?
+
+      set = RE2::Set.new(:unanchored, log_errors: false)
+
+      silence_stderr do
+        expect { set.match("", exception: true) }.to raise_error(RE2::Set::UnsupportedError)
+      end
+    end
+
+    it "raises an error if given non-hash options" do
+      set = RE2::Set.new
+
+      expect { set.match("", 0) }.to raise_error(TypeError)
+    end
+
+    it "raises a Type Error if given input that can't be coerced to a String" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect { set.match(0, exception: false) }.to raise_error(TypeError)
+    end
+
+    it "accepts input if it can be coerced to a String" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect(set.match(StringLike.new("abcdef"), exception: false)).to contain_exactly(0)
+    end
+  end
+
+  def silence_stderr
+    original_stream = STDERR
+
+    if File.const_defined?(:NULL)
+      STDERR.reopen(File::NULL)
+    else
+      platform = RUBY_PLATFORM == 'java' ? RbConfig::CONFIG['host_os'] : RUBY_PLATFORM
+
+      case platform
+      when /mswin|mingw/i
+        STDERR.reopen('NUL')
+      when /amiga/i
+        STDERR.reopen('NIL')
+      when /openvms/i
+        STDERR.reopen('NL:')
+      else
+        STDERR.reopen('/dev/null')
+      end
+    end
+
+    yield
+  ensure
+    STDERR.reopen(original_stream)
+  end
+end

data/spec/re2/string_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "re2/string"
+
+class String
+  include RE2::String
+end
+
+RSpec.describe RE2::String do
+  describe "#re2_sub" do
+    it "delegates to RE2.Replace to perform replacement" do
+      expect("My name is Robert Paulson".re2_sub('Robert', 'Crobert')).to eq("My name is Crobert Paulson")
+    end
+
+    it "doesn't perform an in-place replacement" do
+      string = "My name is Robert Paulson"
+
+      expect(string.re2_sub('Robert', 'Crobert')).not_to equal(string)
+    end
+  end
+
+  describe "#re2_gsub" do
+    it "delegates to RE2.GlobalReplace to perform replacement" do
+      expect("My name is Robert Paulson".re2_gsub('a', 'e')).to eq("My neme is Robert Peulson")
+    end
+
+    it "doesn't perform an in-place replacement" do
+      string = "My name is Robert Paulson"
+
+      expect(string.re2_gsub('a', 'e')).not_to equal(string)
+    end
+  end
+
+  describe "#re2_match" do
+    it "delegates to RE2::Regexp#match to perform matches", :aggregate_failures do
+      md = "My name is Robert Paulson".re2_match('My name is (\S+) (\S+)')
+
+      expect(md).to be_a(RE2::MatchData)
+      expect(md[0]).to eq("My name is Robert Paulson")
+      expect(md[1]).to eq("Robert")
+      expect(md[2]).to eq("Paulson")
+    end
+
+    it "supports limiting the number of matches" do
+      md = "My name is Robert Paulson".re2_match('My name is (\S+) (\S+)', 0)
+
+      expect(md).to eq(true)
+    end
+  end
+
+  describe "#re2_escape" do
+    it "escapes the string for use in regular expressions" do
+      expect("1.5-2.0?".re2_escape).to eq('1\.5\-2\.0\?')
+    end
+  end
+
+  describe "#re2_quote" do
+    it "escapes the string for use in regular expressions" do
+      expect("1.5-2.0?".re2_quote).to eq('1\.5\-2\.0\?')
+    end
+  end
+end