re2 2.0.0.beta1-arm-linux → 2.1.0-arm-linux

data/ext/re2/re2.cc

@@ -39,18 +39,9 @@ using std::vector;
       rb_enc_associate_index(_string, _enc); \
       _string; \
     })
-  #define ENCODED_STR_NEW2(str, length, str2) \
-    ({ \
-      VALUE _string = rb_str_new(str, length); \
-      int _enc = rb_enc_get_index(str2); \
-      rb_enc_associate_index(_string, _enc); \
-      _string; \
-    })
 #else
   #define ENCODED_STR_NEW(str, length, encoding) \
     rb_str_new((const char *)str, (long)length)
-  #define ENCODED_STR_NEW2(str, length, str2) \
-    rb_str_new((const char *)str, (long)length)
 #endif
 
 #ifdef HAVE_RB_STR_SUBLEN
@@ -284,6 +275,10 @@ static VALUE re2_scanner_rewind(VALUE self) {
  * Scan the given text incrementally for matches, returning an array of
  * matches on each subsequent call. Returns nil if no matches are found.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Array<String>] the matches.
  * @example
  *   s = RE2::Regexp.new('(\w+)').scan("Foo bar baz")
@@ -312,7 +307,6 @@ static VALUE re2_scanner_scan(VALUE self) {
   original_input_size = c->input->size();
 
   for (i = 0; i < c->number_of_capturing_groups; i++) {
-    matches[i] = "";
     argv[i] = &matches[i];
     args[i] = &argv[i];
   }
@@ -504,6 +498,10 @@ static VALUE re2_regexp_allocate(VALUE klass) {
 /*
  * Returns the array of matches.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Array<String, nil>] the array of matches
  * @example
  *   m = RE2::Regexp.new('(\d+)').match("bob 123")
@@ -579,6 +577,10 @@ static VALUE re2_matchdata_named_match(const char* name, VALUE self) {
 /*
  * Retrieve zero, one or more matches by index or name.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Array<String, nil>, String, Boolean]
  *
  * @overload [](index)
@@ -646,6 +648,10 @@ static VALUE re2_matchdata_to_s(VALUE self) {
 /*
  * Returns a printable version of the match.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [String] a printable version of the match
  * @example
  *   m = RE2::Regexp.new('(\d+)').match("bob 123")
@@ -690,6 +696,10 @@ static VALUE re2_matchdata_inspect(VALUE self) {
 /*
  * Returns the array of submatches for pattern matching.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Array<String, nil>] the array of submatches
  * @example
  *   m = RE2::Regexp.new('(\d+)').match("bob 123")
@@ -735,6 +745,10 @@ static VALUE re2_matchdata_deconstruct(VALUE self) {
  * more keys than there are capturing groups. Given keys will populate the hash in
  * order but an invalid name will cause the hash to be immediately returned.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Hash] a hash of capturing group names to submatches
  * @param [Array<Symbol>, nil] keys an array of Symbol capturing group names or nil to return all names
  * @example
@@ -866,6 +880,10 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
 /*
  * Returns a printable version of the regular expression +re2+.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [String] a printable version of the regular expression
  * @example
  *   re2 = RE2::Regexp.new("woo?")
@@ -889,6 +907,10 @@ static VALUE re2_regexp_inspect(VALUE self) {
 /*
  * Returns a string version of the regular expression +re2+.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [String] a string version of the regular expression
  * @example
  *   re2 = RE2::Regexp.new("woo?")
@@ -1116,6 +1138,10 @@ static VALUE re2_regexp_error(VALUE self) {
  * If the RE2 could not be created properly, returns
  * the offending portion of the regexp otherwise returns nil.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [String, nil] the offending portion of the regexp or nil
  */
 static VALUE re2_regexp_error_arg(VALUE self) {
@@ -1212,6 +1238,10 @@ static VALUE re2_regexp_number_of_capturing_groups(VALUE self) {
 /*
  * Returns a hash of names to capturing indices of groups.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Hash] a hash of names to capturing indices
  */
 static VALUE re2_regexp_named_capturing_groups(VALUE self) {
@@ -1242,16 +1272,23 @@ static VALUE re2_regexp_named_capturing_groups(VALUE self) {
  * @return [Boolean, RE2::MatchData]
  *
  * @overload match(text)
- *   Returns an {RE2::MatchData} containing the matching
- *   pattern and all subpatterns resulting from looking for
- *   the regexp in +text+.
+ *   Returns an {RE2::MatchData} containing the matching pattern and all
+ *   subpatterns resulting from looking for the regexp in +text+ if the pattern
+ *   contains capturing groups.
+ *
+ *   Returns either true or false indicating whether a successful match was
+ *   made if the pattern contains no capturing groups.
  *
  *   @param [String] text the text to search
- *   @return [RE2::MatchData] the matches
+ *   @return [RE2::MatchData] if the pattern contains capturing groups
+ *   @return [Boolean] if the pattern does not contain capturing groups
  *   @raise [NoMemoryError] if there was not enough memory to allocate the matches
- *   @example
+ *   @example Matching with capturing groups
  *     r = RE2::Regexp.new('w(o)(o)')
  *     r.match('woo')    #=> #<RE2::MatchData "woo" 1:"o" 2:"o">
+ *   @example Matching without capturing groups
+ *     r = RE2::Regexp.new('woo')
+ *     r.match('woo')    #=> true
  *
  * @overload match(text, 0)
  *   Returns either true or false indicating whether a
@@ -1390,6 +1427,10 @@ static VALUE re2_regexp_scan(VALUE self, VALUE text) {
  * Returns a copy of +str+ with the first occurrence +pattern+
  * replaced with +rewrite+.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @param [String] str the string to modify
  * @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
  * @param [String] rewrite the string to replace with
@@ -1404,7 +1445,9 @@ static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
   UNUSED(self);
   re2_pattern *p;
 
-  /* Convert all the inputs to be pumped into RE2::Replace. */
+  /* Take a copy of str so it can be modified in-place by
+   * RE2::Replace.
+   */
   string str_as_string(StringValuePtr(str));
 
   /* Do the replacement. */
@@ -1418,8 +1461,8 @@ static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
     RE2::Replace(&str_as_string, StringValuePtr(pattern),
         StringValuePtr(rewrite));
 
-    return ENCODED_STR_NEW2(str_as_string.data(), str_as_string.size(),
-        pattern);
+    return ENCODED_STR_NEW(str_as_string.data(), str_as_string.size(),
+        "UTF-8");
   }
 
 }
@@ -1427,6 +1470,10 @@ static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
 /*
  * Return a copy of +str+ with +pattern+ replaced by +rewrite+.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @param [String] str the string to modify
  * @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
  * @param [String] rewrite the string to replace with
@@ -1440,7 +1487,9 @@ static VALUE re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern,
                                VALUE rewrite) {
   UNUSED(self);
 
-  /* Convert all the inputs to be pumped into RE2::GlobalReplace. */
+  /* Take a copy of str so it can be modified in-place by
+   * RE2::GlobalReplace.
+   */
   re2_pattern *p;
   string str_as_string(StringValuePtr(str));
 
@@ -1455,8 +1504,8 @@ static VALUE re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern,
     RE2::GlobalReplace(&str_as_string, StringValuePtr(pattern),
                        StringValuePtr(rewrite));
 
-    return ENCODED_STR_NEW2(str_as_string.data(), str_as_string.size(),
-        pattern);
+    return ENCODED_STR_NEW(str_as_string.data(), str_as_string.size(),
+        "UTF-8");
   }
 }
 
@@ -1579,11 +1628,12 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
  *   set.add("def")    #=> 1
  */
 static VALUE re2_set_add(VALUE self, VALUE pattern) {
-  Check_Type(pattern, T_STRING);
+  StringValue(pattern);
   re2::StringPiece regex(RSTRING_PTR(pattern), RSTRING_LEN(pattern));
   std::string err;
   re2_set *s;
   Data_Get_Struct(self, re2_set, s);
+
   int index = s->set->Add(regex, &err);
   if (index < 0) {
     rb_raise(rb_eArgError, "str rejected by RE2::Set->Add(): %s", err.c_str());
@@ -1669,7 +1719,8 @@ static VALUE re2_set_match(int argc, VALUE *argv, VALUE self) {
   VALUE str, options, exception_option;
   bool raise_exception = true;
   rb_scan_args(argc, argv, "11", &str, &options);
-  Check_Type(str, T_STRING);
+
+  StringValue(str);
   re2::StringPiece data(RSTRING_PTR(str), RSTRING_LEN(str));
   std::vector<int> v;
   re2_set *s;

data/lib/re2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RE2
-  VERSION = "2.0.0.beta1"
+  VERSION = "2.1.0"
 end

data/re2.gemspec

@@ -2,14 +2,14 @@ require_relative 'lib/re2/version'
 
 Gem::Specification.new do |s|
   s.name = "re2"
-  s.summary = "Ruby bindings to re2."
-  s.description = 'Ruby bindings to re2, "an efficient, principled regular expression library".'
+  s.summary = "Ruby bindings to RE2."
+  s.description = 'Ruby bindings to RE2, "a fast, safe, thread-friendly alternative to backtracking regular expression engines like those used in PCRE, Perl, and Python".'
   s.version = RE2::VERSION
-  s.authors = ["Paul Mucur"]
+  s.authors = ["Paul Mucur", "Stan Hu"]
   s.homepage = "https://github.com/mudge/re2"
   s.extensions = ["ext/re2/extconf.rb"]
   s.license = "BSD-3-Clause"
-  s.required_ruby_version = ">= 2.7.0"
+  s.required_ruby_version = ">= 2.6.0"
   s.files = [
     ".rspec",
     "dependencies.yml",
@@ -22,6 +22,7 @@ Gem::Specification.new do |s|
     "lib/re2/string.rb",
     "lib/re2/version.rb",
     "LICENSE.txt",
+    "LICENSE-DEPENDENCIES.txt",
     "README.md",
     "Rakefile",
     "re2.gemspec"
@@ -36,8 +37,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.1")
+  s.add_development_dependency("rake-compiler-dock", "~> 1.3.0")
   s.add_development_dependency("rspec", "~> 3.2")
   s.add_runtime_dependency("mini_portile2", "~> 2.8.4") # keep version in sync with extconf.rb
 end

data/spec/kernel_spec.rb

@@ -1,13 +1,13 @@
 RSpec.describe Kernel do
-  describe "#RE2" do
+  describe ".RE2" do
     it "returns an RE2::Regexp instance given a pattern" do
       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)
-      expect(re).to be_a(RE2::Regexp)
-      expect(re).to_not be_case_sensitive
+
+      expect(re).not_to be_case_sensitive
     end
   end
 end

data/spec/re2/match_data_spec.rb

@@ -10,6 +10,18 @@ RSpec.describe RE2::MatchData do
       a = RE2::Regexp.new('(\d?)(a)(b)').match('ab').to_a
       expect(a).to eq(["ab", nil, "a", "b"])
     end
+
+    it "returns UTF-8 strings if the pattern is UTF-8" do
+      a = RE2::Regexp.new('w(o)(o)').match('woo').to_a
+
+      expect(a.map(&:encoding)).to all eq(Encoding::UTF_8)
+    end
+
+    it "returns ISO-8859-1 strings if the pattern is not UTF-8" do
+      a = RE2::Regexp.new('w(o)(o)', :utf8 => false).match('woo').to_a
+
+      expect(a.map(&:encoding)).to all eq(Encoding::ISO_8859_1)
+    end
   end
 
   describe "#[]" do
@@ -19,6 +31,18 @@ RSpec.describe RE2::MatchData do
       expect(md[2]).to eq("23")
     end
 
+    it "returns a UTF-8 string by numerical index if the pattern is UTF-8" do
+      md = RE2::Regexp.new('(\d)(\d{2})').match("123")
+
+      expect(md[1].encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "returns a ISO-8859-1 string by numerical index if the pattern is not UTF-8" do
+      md = RE2::Regexp.new('(\d)(\d{2})', :utf8 => false).match("123")
+
+      expect(md[1].encoding).to eq(Encoding::ISO_8859_1)
+    end
+
     it "has the whole match as the 0th item" do
       md = RE2::Regexp.new('(\d)(\d{2})').match("123")
       expect(md[0]).to eq("123")

data/spec/re2/regexp_spec.rb

@@ -287,6 +287,12 @@ RSpec.describe RE2::Regexp do
       expect(re.match("My age is 99", 0)).to eq(false)
     end
 
+    it "returns only true or false if the pattern has no capturing groups" do
+      re = RE2::Regexp.new('My name is')
+
+      expect(re.match('My name is Robert Paulson')).to eq(true)
+    end
+
     it "raises an exception when given nil" do
       expect { re.match(nil) }.to raise_error(TypeError)
     end

data/spec/re2/scanner_spec.rb

@@ -21,9 +21,10 @@ RSpec.describe RE2::Scanner do
   end
 
   describe "#scan" do
-    it "returns the next array of matches" 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"])
@@ -33,41 +34,73 @@ RSpec.describe RE2::Scanner do
       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" do
+    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" do
+    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" do
+    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([])
@@ -75,9 +108,10 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
-    it "returns an array of nil if the pattern is an empty capturing group" do
+    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])
@@ -85,9 +119,10 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
-    it "returns array of nils with multiple empty capturing groups" do
+    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])
@@ -95,17 +130,34 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
-    it "supports empty groups with multibyte characters" do
+    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
 
@@ -113,12 +165,8 @@ RSpec.describe RE2::Scanner do
     it "yields each match" do
       r = RE2::Regexp.new('(\d)')
       scanner = r.scan("There are 1 some 2 numbers 3")
-      matches = []
-      scanner.each do |match|
-        matches << match
-      end
 
-      expect(matches).to eq([["1"], ["2"], ["3"]])
+      expect { |b| scanner.each(&b) }.to yield_successive_args(["1"], ["2"], ["3"])
     end
 
     it "returns an enumerator when not given a block" do
@@ -135,22 +183,28 @@ RSpec.describe RE2::Scanner do
   end
 
   describe "#rewind" do
-    it "resets any consumption" 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 "resets the eof? check" do
+    it "resets the eof? check", :aggregate_failures do
       r = RE2::Regexp.new('(\d)')
       scanner = r.scan("1")
       scanner.scan
-      expect(scanner.eof?).to be_truthy
+
+      expect(scanner).to be_eof
+
       scanner.rewind
-      expect(scanner.eof?).to be_falsey
+
+      expect(scanner).not_to be_eof
     end
   end
 
@@ -159,7 +213,7 @@ RSpec.describe RE2::Scanner do
       r = RE2::Regexp.new('(\d)')
       scanner = r.scan("1 2 3")
 
-      expect(scanner.eof?).to be_falsey
+      expect(scanner).not_to be_eof
     end
 
     it "returns true if the input has been consumed" do
@@ -167,7 +221,7 @@ RSpec.describe RE2::Scanner do
       scanner = r.scan("1")
       scanner.scan
 
-      expect(scanner.eof?).to be_truthy
+      expect(scanner).to be_eof
     end
 
     it "returns false if no match is made" do
@@ -175,14 +229,14 @@ RSpec.describe RE2::Scanner do
       scanner = r.scan("a")
       scanner.scan
 
-      expect(scanner.eof?).to be_falsey
+      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.eof?).to be_falsey
+      expect(scanner).not_to be_eof
     end
 
     it "returns false with an empty input that has not been matched" do
@@ -190,7 +244,7 @@ RSpec.describe RE2::Scanner do
       scanner = r.scan("")
       scanner.scan
 
-      expect(scanner.eof?).to be_falsey
+      expect(scanner).not_to be_eof
     end
 
     it "returns true with an empty input that has been matched" do
@@ -198,7 +252,7 @@ RSpec.describe RE2::Scanner do
       scanner = r.scan("")
       scanner.scan
 
-      expect(scanner.eof?).to be_truthy
+      expect(scanner).to be_eof
     end
   end
 end