mruby-regexp: accept a Regexp in String#index, #partition, #start_with? and their siblings - #7075

Seven String methods take a Regexp in CRuby and reach a C implementation here
that converts the argument to a String, so a Regexp is a TypeError. Four are
core (index, rindex, byteindex and byterindex, in src/string.c); the
other three come from mruby-string-ext (partition, rpartition and
start_with?), which mruby-regexp already depends on, so an override in the
gem's mrblib reaches both sets.

"abc".index(/b/)        # CRuby: 1,    mruby: TypeError
"abc".rindex(/b/)       # CRuby: 1,    mruby: TypeError
"abc".byteindex(/b/)    # CRuby: 1,    mruby: TypeError
"abc".byterindex(/b/)   # CRuby: 1,    mruby: TypeError
"abc".partition(/b/)    # CRuby: ["a", "b", "c"], mruby: TypeError
"abc".rpartition(/b/)   # CRuby: ["a", "b", "c"], mruby: TypeError
"abc".start_with?(/a/)  # CRuby: true, mruby: TypeError

Nothing is unreachable today, since =~ and String#[] cover the same ground.
What is missing is the spelling CRuby code uses, which means code carried over
raises instead of running.

This finishes the family. String#[] and #slice arrived in 46d88a8,
#sub! and #gsub! in #7061, #[]= and #slice! in #7063; none of the three
touched any of these seven. String#end_with? is deliberately not in the list:
CRuby rejects a Regexp there too, and so does this build, so the two already
agree.

Shape of the change

mrbgems/mruby-regexp/mrblib/string_regexp.rb already had the pattern to copy.
Each C method is captured under a private alias before the override replaces
it, and the override tests the argument with Regexp === arg rather than
is_a?, which is redefinable: anything that is not a Regexp goes back to the
captured C method untouched, so it keeps the C arity check and the C error
messages. The note at the top of that file sets out how far that guard goes and
where it stops.

One commit per pair, in the order the methods depend on each other, and a
last one for the README: the seven join the list of String methods that take
a Regexp here, and the walk described below joins the limitations.

index hands its position argument to Regexp#match unexamined: the two
normalize a position the same way and read it with the same mrb_get_args()
conversion.

rindex wants the last match that starts at or before its position, and the
match may run past that position, so "abcabc".rindex(/bca/, 1) is 1. The
engine has no backward search, so __regexp_rsearch walks the subject from the
start and keeps the last match that qualifies. That is linear in the number of
positions a match starts at, where the backward search CRuby hands to Onig is
not, which is the one cost worth naming here. Each step resumes one character
past the match start rather than at the match end, without which overlapping
matches stay invisible and "aaa".rindex(/aa/) answers 0 instead of 1.

byteindex and byterindex are the same two searches read in byte space.
MatchData#begin reports character offsets, which is the convention the rest of
the gem follows, so these two read __byte_begin instead. On a build without
MRB_UTF8_STRING the two spaces coincide and each pair answers the same number.

partition and rpartition build their three pieces from the match, so the row
worth naming is the one with no match, where the subject stays whole and the two
put it at opposite ends. The copy is a plain String even for a String subclass
receiver, as mrb_str_dup() and CRuby's str_duplicate(rb_cString, str) both
hand back. rpartition shares __regexp_rsearch with rindex.

start_with? reads its arguments left to right and hands each non-regexp one to
the C method one at a time, so a String keeps the C comparison and its error. A
regexp is anchored at the start rather than searched for, so the override checks
begin(0) == 0; the engine matches leftmost, so a pattern that can match at 0
does, which makes that check the anchored answer rather than an approximation of
it. "abc".start_with?(/b/) and "abc\ndef".start_with?(/^d/) are both false.

Two details the existing overrides settle already, and these follow:

• The match globals. Each search goes through match and not match?, so $~
  and the names derived from it are published, including the clearing a failed
  match does. CRuby sets them for all seven and clears them after a miss. That
  extends to the misses that are not a failed search: a position outside the
  subject, a match that starts past what rindex asked for, and a match
  start_with? refuses for starting later than 0 all leave the globals cleared.
  A non-regexp argument does not touch them, which falls out of leaving it to C.
• Character offsets against byte offsets, as above.

Tests

mrbgems/mruby-regexp/test/regexp.rb, after the String#[], #[]= and
#slice! regexp groups at the end of the file, in the same three groups per
method pair: the search itself, the match globals, and the delegation of every
non-regexp argument. The multibyte rows sit behind __ENCODING__ == "UTF-8",
which is what the file already uses for the character-offset cases.

Checked

Every row above, and every row in the new tests, was run against CRuby 4.0.6 and
compared: a table of 93 calls covering all seven methods, their positions at
both ends of the subject, their globals after a hit and after each kind of miss,
and the errors raised, is identical between the two, on the default build and on
one with MRB_UTF8_STRING. A second table of 37 multibyte calls is identical
too. rake test passes on both builds.

Summary by CodeRabbit

• New Features

  • Added regular-expression support to string search, partition, and prefix-checking methods.
  • Added forward and reverse searches with character- and byte-based position handling.
  • Added support for multiple patterns, anchored prefix checks, and match result tracking.

• Bug Fixes

  • Improved validation and handling of positions, empty matches, multibyte text, and invalid arguments.
  • Preserved existing behavior for non-regular-expression arguments.

• Documentation

  • Documented regular-expression support and reverse-search behavior.