Read what sprintf builds the way its bytes were read - #7143

Follow-up to #7137, which named this seam among the ones it deliberately left out.

sprintf builds its result in a raw buffer and never looks at what the strings going into it were read as, so a byte-read argument loses that reading on the way through, and so does a byte-read format string:

171.chr                #=> ASCII-8BIT, valid
"%s" % [171.chr]       #=> UTF-8, invalid   (CRuby: ASCII-8BIT)
"%c" % [171.chr]       #=> UTF-8, invalid   (CRuby: ASCII-8BIT)
"%<x>s" % {x: 171.chr} #=> UTF-8, invalid   (CRuby: ASCII-8BIT)
"%s".b % ["ab"]        #=> UTF-8            (CRuby: ASCII-8BIT)

Since 80c781b refuses a subject whose bytes do not read as UTF-8, this is no longer a mis-indexing but a refusal: 171.chr matches against a pattern, while "%s" % [171.chr], the same single byte, raises ArgumentError.

The rule

The one #7137 settled, applied to the two places sprintf writes bytes it did not make itself.

• The format string is the receiver. What sprintf builds is the format string's own bytes with the arguments written between them, so the result is read the way the format string was read, ASCII bytes and all. That is the reading a receiver holds through an append, which nothing written into it lifts.
• An argument is what is written in. An argument read as bytes and going above ASCII spells no character where it lands, so it hands the result the byte reading along with itself. ASCII bytes read the same under any reading and move nothing.

Three sites: the result takes MRB_STR_BINARY from the format string where it is created, %s/%p marks from the string its argument converts to, and %c marks from a String argument. An Integer argument to %c is a code point rather than a byte, and the string %p builds for itself is one of its own, so neither marks anything.

What an argument is read as is a property of the argument, not of the part that reaches the buffer, so a precision cutting the byte above ASCII off the written part moves nothing: "%.1s" % ["a\xABb".b] is byte-read, as in CRuby.

This reproduces CRuby's answer for every pair it accepts. The pairs CRuby refuses with Encoding::CompatibilityError come out byte-read here rather than raising, the same choice #7137 made.

Tests

The first commit pins where every answer stands before any of it moves; the second flips exactly the pins it changes.

Whether a string is read as bytes or as UTF-8 is only visible through mruby-encoding, which this gem does not depend on, so such a test skips itself in the state mrbtest builds for this gem, in every configuration. The first commit takes that dependency in the test state when the build already carries the gem, the way mruby-regexp does since #7136. A build without mruby-encoding is unchanged, and no build gains a gem it did not already have. The test asks __ENCODING__ as well, since a build that reads every string as bytes has nothing for the marking to tell apart.

Still left out

Array#pack and String#unpack mark nothing ([171].pack("C") reports UTF-8, invalid), and a Symbol has nowhere to keep the marking (171.chr.to_sym.to_s reports UTF-8). Each is its own change.

Alongside #7142

#7142 leaves MRB_UTF8_STRING to the build, so carrying mruby-encoding stops meaning the build reads UTF-8, and a full-core build that indexes by byte runs in CI. That is what the __ENCODING__ guard is for: redundant while the gem still sets the define, load-bearing once it does not. The two series share no file. MRB_STR_BINARY and RSTR_COPY_BINARY_FLAG do not wait on MRB_UTF8_STRING, so what this one adds to sprintf.c compiles and runs the same on either side; what changes is only whether String#encoding shows the marking.

Verification

Full suite green at every commit, on full-core with MRB_UTF8_STRING (2279 tests), the same with the C++ ABI (2279), and the default gembox, where mruby-encoding is absent and the new test skips (2066). 0 failures, 0 crashes, no new compiler warnings.

Merged with #7142, full-core without MRB_UTF8_STRING is green as well (2239), the new test among the skips. That series turns the C++ ABI build into one of those, so its count above moves there once it lands.

Summary by CodeRabbit

• Bug Fixes
  • Improved sprintf and String#% handling of binary and UTF-8 strings.
  • Preserved binary encoding when formatting non-ASCII character and string values.
  • Ensured formatted output remains valid across precision limits and conversion types.
• Tests
  • Added coverage for encoding propagation, binary format strings, truncation, and UTF-8 output.