Encoding fixes for JRUBY-6033:

* String#% was not setting base encoding of new string to same as format string, as in MRI
* Array#to_s and Array#inspect did not use encoding-aware methods for building the string
* Hash#inspect ditto

Author: headius

.gitignore

@@ -63,4 +63,5 @@ dev_null
 .idea/workspace.xml
 shared.iml
 build_graph.png
-/.idea/
+/.idea/
+/.rbx/

src/org/jruby/RubyArray.java

@@ -48,6 +48,8 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
+import org.jcodings.Encoding;
+import org.jcodings.specific.USASCIIEncoding;
 
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
@@ -87,6 +89,7 @@
  */
 @JRubyClass(name="Array")
 public class RubyArray extends RubyObject implements List {
+    public static final int DEFAULT_INSPECT_STR_SIZE = 10;
 
     public static RubyClass createArrayClass(Ruby runtime) {
         RubyClass arrayc = runtime.defineClass("Array", runtime.getObject(), ARRAY_ALLOCATOR);
@@ -1466,22 +1469,25 @@ public RubyArray concat19(IRubyObject obj) {
      * 
      */
     private IRubyObject inspectAry(ThreadContext context) {
-        ByteList buffer = new ByteList();
-        buffer.append('[');
+        Encoding encoding = context.runtime.getDefaultInternalEncoding();
+        if (encoding == null) encoding = USASCIIEncoding.INSTANCE;
+        RubyString str = RubyString.newStringLight(context.runtime, DEFAULT_INSPECT_STR_SIZE, encoding);
+        str.cat((byte)'[');
         boolean tainted = isTaint();
         boolean untrust = isUntrusted();
 
         for (int i = 0; i < realLength; i++) {
-            if (i > 0) buffer.append(',').append(' ');
+            if (i > 0) str.cat((byte)',').cat((byte)' ');
 
-            RubyString str = inspect(context, safeArrayRef(values, begin + i));
-            if (str.isTaint()) tainted = true;
-            if (str.isUntrusted()) untrust = true;
-            buffer.append(str.getByteList());
+            RubyString str2 = inspect(context, safeArrayRef(values, begin + i));
+            if (str2.isTaint()) tainted = true;
+            if (str2.isUntrusted()) untrust = true;
+            
+            // safe for both 1.9 and 1.8
+            str.cat19(str2);
         }
-        buffer.append(']');
+        str.cat((byte)']');
 
-        RubyString str = getRuntime().newString(buffer);
         if (tainted) str.setTaint(true);
         if (untrust) str.setUntrusted(true);
 

src/org/jruby/RubyHash.java

@@ -65,7 +65,6 @@
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.marshal.MarshalStream;
 import org.jruby.runtime.marshal.UnmarshalStream;
-import org.jruby.util.ByteList;
 import org.jruby.util.TypeConverter;
 import org.jruby.util.RecursiveComparator;
 
@@ -111,6 +110,7 @@
  */
 @JRubyClass(name = "Hash", include="Enumerable")
 public class RubyHash extends RubyObject implements Map {
+    public static final int DEFAULT_INSPECT_STR_SIZE = 20;
 
     public static RubyClass createHashClass(Ruby runtime) {
         RubyClass hashc = runtime.defineClass("Hash", runtime.getObject(), HASH_ALLOCATOR);
@@ -713,23 +713,23 @@ public void modify() {
      *
      */
     private IRubyObject inspectHash(final ThreadContext context) {
-        final ByteList buffer = new ByteList();
-        buffer.append('{');
+        final RubyString str = RubyString.newStringLight(context.runtime, DEFAULT_INSPECT_STR_SIZE);
+        str.cat((byte)'{');
         final boolean[] firstEntry = new boolean[1];
 
         firstEntry[0] = true;
         visitAll(new Visitor() {
             public void visit(IRubyObject key, IRubyObject value) {
-                if (!firstEntry[0]) buffer.append(',').append(' ');
+                if (!firstEntry[0]) str.cat((byte)',').cat((byte)' ');
 
-                buffer.append(inspect(context, key).getByteList());
-                buffer.append('=').append('>');
-                buffer.append(inspect(context, value).getByteList());
+                str.cat19(inspect(context, key));
+                str.cat((byte)'=').cat((byte)'>');
+                str.cat19(inspect(context, value));
                 firstEntry[0] = false;
             }
         });
-        buffer.append('}');
-        return getRuntime().newString(buffer);
+        str.cat((byte)'}');
+        return str;
     }
 
     /** rb_hash_inspect

src/org/jruby/RubyString.java

@@ -1101,10 +1101,13 @@ private IRubyObject opFormatCommon(ThreadContext context, IRubyObject arg, Compa
         IRubyObject tmp = arg.checkArrayType();
         if (tmp.isNil()) tmp = arg;
 
-        // FIXME: Should we make this work with platform's locale,
-        // or continue hardcoding US?
         ByteList out = new ByteList(value.getRealSize());
+        out.setEncoding(value.getEncoding());
+        
         boolean tainted;
+        
+        // FIXME: Should we make this work with platform's locale,
+        // or continue hardcoding US?
         switch (compat) {
         case RUBY1_8:
             tainted = Sprintf.sprintf(out, Locale.US, value, tmp);