[GR-18163] Fix Kernel#sprintf: take into account encoding of %c argument

PullRequest: truffleruby/3451

Author: andrykonchin

CHANGELOG.md

@@ -26,6 +26,8 @@ Compatibility:
 * Always terminate native strings with enough `\0` bytes (#2704, @eregon).
 * Support `#dup` and `#clone` on foreign strings (@eregon).
 * Fix `Regexp.new` to coerce non-String arguments (#2705, @andrykonchin).
+* Fix `Kernel#sprintf` formatting for `%c` when used non-ASCII encoding (#2369, @andrykonchin).
+* Fix `Kernel#sprintf` argument casting for `%c` (@andrykonchin).
 
 Performance:
 

lib/truffle/stringio.rb

@@ -87,11 +87,7 @@ def print(*args)
   def printf(*args)
     check_writable
 
-    if args.size > 1
-      write(args.shift % args)
-    else
-      write(args.first)
-    end
+    write(sprintf(*args))
 
     nil
   end

spec/ruby/core/kernel/shared/sprintf.rb

@@ -292,18 +292,65 @@ def obj.to_i; 10; end
       it "raises ArgumentError if argument is a string of several characters" do
         -> {
           @method.call("%c", "abc")
-        }.should raise_error(ArgumentError)
+        }.should raise_error(ArgumentError, /%c requires a character/)
       end
 
       it "raises ArgumentError if argument is an empty string" do
         -> {
           @method.call("%c", "")
-        }.should raise_error(ArgumentError)
+        }.should raise_error(ArgumentError, /%c requires a character/)
+      end
+
+      it "raises TypeError if argument is not String or Integer and cannot be converted to them" do
+        -> {
+          @method.call("%c", [])
+        }.should raise_error(TypeError, /no implicit conversion of Array into Integer/)
       end
 
-      it "supports Unicode characters" do
-        @method.call("%c", 1286).should == "Ԇ"
-        @method.call("%c", "ش").should == "ش"
+      it "raises TypeError if argument is nil" do
+        -> {
+          @method.call("%c", nil)
+        }.should raise_error(TypeError, /no implicit conversion from nil to integer/)
+      end
+
+      it "tries to convert argument to String with to_str" do
+        obj = BasicObject.new
+        def obj.to_str
+          "a"
+        end
+
+        @method.call("%c", obj).should == "a"
+      end
+
+      it "tries to convert argument to Integer with to_int" do
+        obj = BasicObject.new
+        def obj.to_int
+          90
+        end
+
+        @method.call("%c", obj).should == "Z"
+      end
+
+      it "raises TypeError if converting to String with to_str returns non-String" do
+        obj = BasicObject.new
+        def obj.to_str
+          :foo
+        end
+
+        -> {
+          @method.call("%c", obj)
+        }.should raise_error(TypeError, /can't convert BasicObject to String/)
+      end
+
+      it "raises TypeError if converting to Integer with to_int returns non-Integer" do
+        obj = BasicObject.new
+        def obj.to_str
+          :foo
+        end
+
+        -> {
+          @method.call("%c", obj)
+        }.should raise_error(TypeError, /can't convert BasicObject to String/)
       end
     end
 
@@ -362,11 +409,11 @@ def obj.to_str
         @method.call("%4.6s", "abcdefg").should == "abcdef"
       end
 
-      it "formats nli with width" do
+      it "formats nil with width" do
         @method.call("%6s", nil).should == "      "
       end
 
-      it "formats nli with precision" do
+      it "formats nil with precision" do
         @method.call("%.6s", nil).should == ""
       end
 
@@ -927,4 +974,8 @@ def obj.to_str; end
       }
     end
   end
+
+  it "does not raise error when passed more arguments than needed" do
+    sprintf("%s %d %c", "string", 2, "c", []).should == "string 2 c"
+  end
 end

spec/ruby/core/kernel/shared/sprintf_encoding.rb

@@ -1,3 +1,5 @@
+# Keep encoding-related specs in a separate shared example to be able to skip them in IO/File/StringIO specs.
+# It's difficult to check result's encoding in the test after writing to a file/io buffer.
 describe :kernel_sprintf_encoding, shared: true do
   it "can produce a string with valid encoding" do
     string = @method.call("good day %{valid}", valid: "e")
@@ -25,12 +27,41 @@
     result.encoding.should equal(Encoding::UTF_8)
   end
 
-  it "raises Encoding::CompatibilityError if both encodings are ASCII compatible and there ano not ASCII characters" do
+  it "raises Encoding::CompatibilityError if both encodings are ASCII compatible and there are not ASCII characters" do
     string = "Ä %s".encode('windows-1252')
     argument = "Ђ".encode('windows-1251')
 
     -> {
       @method.call(string, argument)
     }.should raise_error(Encoding::CompatibilityError)
   end
+
+  describe "%c" do
+    it "supports Unicode characters" do
+      result = @method.call("%c", 1286)
+      result.should == "Ԇ"
+      result.bytes.should == [212, 134]
+
+      result = @method.call("%c", "ش")
+      result.should == "ش"
+      result.bytes.should == [216, 180]
+    end
+
+    it "raises error when a codepoint isn't representable in an encoding of a format string" do
+      format = "%c".encode("ASCII")
+
+      -> {
+        @method.call(format, 1286)
+      }.should raise_error(RangeError, /out of char range/)
+    end
+
+    it "uses the encoding of the format string to interpret codepoints" do
+      format = "%c".force_encoding("euc-jp")
+      result = @method.call(format, 9415601)
+
+      result.encoding.should == Encoding::EUC_JP
+      result.should == "é".encode(Encoding::EUC_JP)
+      result.bytes.should == [143, 171, 177]
+    end
+  end
 end

spec/ruby/library/stringio/open_spec.rb

@@ -167,10 +167,14 @@
     io.should equal(ret)
   end
 
-  it "sets the mode to read-write" do
+  it "sets the mode to read-write (r+)" do
     io = StringIO.open("example")
     io.closed_read?.should be_false
     io.closed_write?.should be_false
+
+    io = StringIO.new("example")
+    io.printf("%d", 123)
+    io.string.should == "123mple"
   end
 
   it "tries to convert the passed Object to a String using #to_str" do
@@ -195,10 +199,14 @@
     io.should equal(ret)
   end
 
-  it "sets the mode to read-write" do
+  it "sets the mode to read-write (r+)" do
     io = StringIO.open
     io.closed_read?.should be_false
     io.closed_write?.should be_false
+
+    io = StringIO.new("example")
+    io.printf("%d", 123)
+    io.string.should == "123mple"
   end
 
   it "uses an empty String as the StringIO backend" do

spec/ruby/library/stringio/printf_spec.rb

@@ -4,17 +4,17 @@
 
 describe "StringIO#printf" do
   before :each do
-    @io = StringIO.new('example')
+    @io = StringIO.new()
   end
 
   it "returns nil" do
     @io.printf("%d %04x", 123, 123).should be_nil
   end
 
   it "pads self with \\000 when the current position is after the end" do
-    @io.pos = 10
+    @io.pos = 3
     @io.printf("%d", 123)
-    @io.string.should == "example\000\000\000123"
+    @io.string.should == "\000\000\000123"
   end
 
   it "performs format conversion" do
@@ -39,6 +39,27 @@
   end
 end
 
+describe "StringIO#printf when in read-write mode" do
+  before :each do
+    @io = StringIO.new("example", "r+")
+  end
+
+  it "starts from the beginning" do
+    @io.printf("%s", "abcdefghijk")
+    @io.string.should == "abcdefghijk"
+  end
+
+  it "does not truncate existing string" do
+    @io.printf("%s", "abc")
+    @io.string.should == "abcmple"
+  end
+
+  it "correctly updates self's position" do
+    @io.printf("%s", "abc")
+    @io.pos.should eql(3)
+  end
+end
+
 describe "StringIO#printf when in append mode" do
   before :each do
     @io = StringIO.new("example", "a")

spec/tags/core/kernel/printf_tags.txt

@@ -1,28 +1,6 @@
-fails:Kernel.printf formatting io is specified other formats c raises ArgumentError if argument is an empty string
-fails:Kernel.printf formatting io is specified other formats c supports Unicode characters
 fails:Kernel.printf formatting io is specified other formats s does not try to convert with to_str
 fails:Kernel.printf formatting io is specified flags # applies to format o does nothing for negative argument
 fails:Kernel.printf formatting io is specified flags # applies to formats bBxX does nothing for zero argument
-fails:Kernel.printf formatting io is specified flags # applies to formats aAeEfgG forces a decimal point to be added, even if no digits follow
-fails:Kernel.printf formatting io is specified flags # applies to gG does not remove trailing zeros
-fails:Kernel.printf formatting io is specified flags - left-justifies the result of conversion if width is specified
-fails:Kernel.printf formatting io is specified flags 0 (zero) applies to numeric formats bBdiouxXaAeEfgG and width is specified uses radix-1 when displays negative argument as a two's complement
-fails:Kernel.printf formatting io is specified flags * left-justifies the result if width is negative
-fails:Kernel.printf formatting io is specified flags * left-justifies the result if specified with $ argument is negative
-fails:Kernel.printf formatting io is specified precision string formats determines the maximum number of characters to be copied from the string
-fails:Kernel.printf formatting io is specified reference by name %{name} style supports flags, width and precision
-fails:Kernel.printf formatting io is not specified other formats c raises ArgumentError if argument is an empty string
-fails:Kernel.printf formatting io is not specified other formats c supports Unicode characters
 fails:Kernel.printf formatting io is not specified other formats s does not try to convert with to_str
 fails:Kernel.printf formatting io is not specified flags # applies to format o does nothing for negative argument
-fails:Kernel.printf formatting io is not specified flags # applies to formats bBxX does nothing for zero argument
-fails:Kernel.printf formatting io is not specified flags # applies to formats aAeEfgG forces a decimal point to be added, even if no digits follow
-fails:Kernel.printf formatting io is not specified flags # applies to gG does not remove trailing zeros
-fails:Kernel.printf formatting io is not specified flags - left-justifies the result of conversion if width is specified
-fails:Kernel.printf formatting io is not specified flags 0 (zero) applies to numeric formats bBdiouxXaAeEfgG and width is specified uses radix-1 when displays negative argument as a two's complement
-fails:Kernel.printf formatting io is not specified flags * left-justifies the result if width is negative
-fails:Kernel.printf formatting io is not specified flags * left-justifies the result if specified with $ argument is negative
-fails:Kernel.printf formatting io is not specified precision string formats determines the maximum number of characters to be copied from the string
-fails:Kernel.printf formatting io is not specified reference by name %{name} style supports flags, width and precision
-fails:Kernel.printf formatting io is specified other formats % alone raises an ArgumentError
-fails:Kernel.printf formatting io is not specified other formats % alone raises an ArgumentError
+fails:Kernel.printf formatting io is not specified flags # applies to formats bBxX does nothing for zero argument

spec/tags/core/kernel/sprintf_tags.txt

@@ -1,16 +1,10 @@
-fails:Kernel#sprintf returns a String in the same encoding as the format String if compatible
 fails:Kernel#sprintf returns a String in the argument's encoding if format encoding is more restrictive
-fails:Kernel#sprintf raises Encoding::CompatibilityError if both encodings are ASCII compatible and there ano not ASCII characters
-fails:Kernel#sprintf other formats c raises ArgumentError if argument is an empty string
-fails:Kernel#sprintf other formats c supports Unicode characters
+fails:Kernel#sprintf raises Encoding::CompatibilityError if both encodings are ASCII compatible and there are not ASCII characters
 fails:Kernel#sprintf other formats s does not try to convert with to_str
 fails:Kernel#sprintf flags # applies to format o does nothing for negative argument
 fails:Kernel#sprintf flags # applies to formats bBxX does nothing for zero argument
-fails:Kernel.sprintf returns a String in the same encoding as the format String if compatible
 fails:Kernel.sprintf returns a String in the argument's encoding if format encoding is more restrictive
-fails:Kernel.sprintf raises Encoding::CompatibilityError if both encodings are ASCII compatible and there ano not ASCII characters
-fails:Kernel.sprintf other formats c raises ArgumentError if argument is an empty string
-fails:Kernel.sprintf other formats c supports Unicode characters
+fails:Kernel.sprintf raises Encoding::CompatibilityError if both encodings are ASCII compatible and there are not ASCII characters
 fails:Kernel.sprintf other formats s does not try to convert with to_str
 fails:Kernel.sprintf flags # applies to format o does nothing for negative argument
 fails:Kernel.sprintf flags # applies to formats bBxX does nothing for zero argument

spec/tags/core/string/modulo_tags.txt

@@ -1,21 +1,7 @@
-fails:String#% output's encoding is the same as the format string if passed value is encoding-compatible
 fails:String#% output's encoding negotiates a compatible encoding if necessary
 fails:String#% output's encoding raises if a compatible encoding can't be found
-fails:String#% raises an error if single % appears at the end
-fails:String#% returns a String in the same encoding as the format String if compatible
 fails:String#% returns a String in the argument's encoding if format encoding is more restrictive
-fails:String#% raises Encoding::CompatibilityError if both encodings are ASCII compatible and there ano not ASCII characters
-fails:String#% other formats c raises ArgumentError if argument is an empty string
-fails:String#% other formats c supports Unicode characters
+fails:String#% raises Encoding::CompatibilityError if both encodings are ASCII compatible and there are not ASCII characters
 fails:String#% other formats s does not try to convert with to_str
-fails:String#% other formats % alone raises an ArgumentError
 fails:String#% flags # applies to format o does nothing for negative argument
-fails:String#% flags # applies to formats bBxX does nothing for zero argument
-fails:String#% flags # applies to formats aAeEfgG forces a decimal point to be added, even if no digits follow
-fails:String#% flags # applies to gG does not remove trailing zeros
-fails:String#% flags - left-justifies the result of conversion if width is specified
-fails:String#% flags 0 (zero) applies to numeric formats bBdiouxXaAeEfgG and width is specified uses radix-1 when displays negative argument as a two's complement
-fails:String#% flags * left-justifies the result if width is negative
-fails:String#% flags * left-justifies the result if specified with $ argument is negative
-fails:String#% precision string formats determines the maximum number of characters to be copied from the string
-fails:String#% reference by name %{name} style supports flags, width and precision
+fails:String#% flags # applies to formats bBxX does nothing for zero argument

spec/tags/library/stringio/printf_tags.txt

@@ -1,15 +1,3 @@
-fails:StringIO#printf formatting other formats c raises ArgumentError if argument is an empty string
-fails:StringIO#printf formatting other formats c supports Unicode characters
 fails:StringIO#printf formatting other formats s does not try to convert with to_str
-fails:StringIO#printf formatting other formats % is escaped by %
 fails:StringIO#printf formatting flags # applies to format o does nothing for negative argument
 fails:StringIO#printf formatting flags # applies to formats bBxX does nothing for zero argument
-fails:StringIO#printf formatting flags # applies to formats aAeEfgG forces a decimal point to be added, even if no digits follow
-fails:StringIO#printf formatting flags # applies to gG does not remove trailing zeros
-fails:StringIO#printf formatting flags - left-justifies the result of conversion if width is specified
-fails:StringIO#printf formatting flags 0 (zero) applies to numeric formats bBdiouxXaAeEfgG and width is specified uses radix-1 when displays negative argument as a two's complement
-fails:StringIO#printf formatting flags * left-justifies the result if width is negative
-fails:StringIO#printf formatting flags * left-justifies the result if specified with $ argument is negative
-fails:StringIO#printf formatting precision string formats determines the maximum number of characters to be copied from the string
-fails:StringIO#printf formatting reference by name %{name} style supports flags, width and precision
-fails:StringIO#printf formatting other formats % alone raises an ArgumentError