Kernel#sprintf: fix %c - take into account argument encoding

Author: andrykonchin

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

@@ -292,18 +292,28 @@ 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 "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
     end
 
@@ -927,4 +937,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")
@@ -33,4 +35,33 @@
       @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/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 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 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#% 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,5 @@
-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

src/main/java/org/truffleruby/core/exception/CoreExceptions.java

@@ -27,7 +27,6 @@
 import org.truffleruby.core.module.ModuleOperations;
 import org.truffleruby.core.module.RubyModule;
 import org.truffleruby.core.proc.RubyProc;
-import org.truffleruby.core.range.RubyIntRange;
 import org.truffleruby.core.string.CoreStrings;
 import org.truffleruby.core.string.RubyString;
 import org.truffleruby.core.string.StringOperations;
@@ -1099,12 +1098,8 @@ public RubyException rangeError(long code, RubyEncoding encoding, Node currentNo
     }
 
     @TruffleBoundary
-    public RubyException rangeError(RubyIntRange range, Node currentNode) {
-        return rangeError(StringUtils.format(
-                "%d..%s%d out of range",
-                range.begin,
-                range.excludedEnd ? "." : "",
-                range.end), currentNode);
+    public RubyException charRangeError(int codepoint, Node currentNode) {
+        return rangeError(StringUtils.format("%d out of char range", codepoint), currentNode);
     }
 
     @TruffleBoundary

src/main/java/org/truffleruby/core/format/FormatEncoding.java

@@ -17,16 +17,16 @@
 import org.truffleruby.core.encoding.RubyEncoding;
 import org.truffleruby.language.control.RaiseException;
 
-public enum FormatEncoding {
+public class FormatEncoding {
 
-    DEFAULT(Encodings.BINARY),
-    ASCII_8BIT(Encodings.BINARY),
-    US_ASCII(Encodings.US_ASCII),
-    UTF_8(Encodings.UTF_8);
+    public static final FormatEncoding DEFAULT = new FormatEncoding(Encodings.BINARY);
+    public static final FormatEncoding ASCII_8BIT = new FormatEncoding(Encodings.BINARY);
+    public static final FormatEncoding US_ASCII = new FormatEncoding(Encodings.US_ASCII);
+    public static final FormatEncoding UTF_8 = new FormatEncoding(Encodings.UTF_8);
 
     private final RubyEncoding encoding;
 
-    FormatEncoding(RubyEncoding encoding) {
+    public FormatEncoding(RubyEncoding encoding) {
         this.encoding = encoding;
     }
 
@@ -73,22 +73,18 @@ public FormatEncoding unifyWith(FormatEncoding other) {
             return this;
         }
 
-        switch (other) {
-            case ASCII_8BIT:
-            case US_ASCII:
+        if (other == ASCII_8BIT || other == US_ASCII) {
+            return ASCII_8BIT;
+        } else if (other == UTF_8) {
+            if (this == ASCII_8BIT || this == US_ASCII) {
                 return ASCII_8BIT;
-            case UTF_8:
-                switch (this) {
-                    case ASCII_8BIT:
-                    case US_ASCII:
-                        return ASCII_8BIT;
-                    case UTF_8:
-                        return UTF_8;
-                    default:
-                        throw CompilerDirectives.shouldNotReachHere();
-                }
-            default:
+            } else if (this == UTF_8) {
+                return UTF_8;
+            } else {
                 throw CompilerDirectives.shouldNotReachHere();
+            }
+        } else {
+            throw CompilerDirectives.shouldNotReachHere();
         }
     }