org.jruby.util.RubyStringBuilder Maven / Gradle / Ivy
package org.jruby.util;
import org.jcodings.Encoding;
import org.jcodings.specific.USASCIIEncoding;
import org.jcodings.unicode.UnicodeEncoding;
import org.jruby.*;
import org.jruby.runtime.ThreadContext;
import org.jruby.runtime.builtin.IRubyObject;
import org.jruby.util.io.EncodingUtils;
import static org.jruby.util.StringSupport.MBCLEN_CHARFOUND_LEN;
import static org.jruby.util.StringSupport.MBCLEN_CHARFOUND_P;
import static org.jruby.util.StringSupport.codePoint;
/**
* Helper methods to make Ruby Strings without the ceremony of manually building the string up.
*/
public class RubyStringBuilder {
public static RubyString types(Ruby runtime, RubyModule type) {
ThreadContext context = runtime.getCurrentContext();
return inspectIdentifierByteList(runtime, type.toRubyString(context).getByteList());
}
public static RubyString types(Ruby runtime, RubyModule type1, RubyModule type2) {
ThreadContext context = runtime.getCurrentContext();
RubyString fullTypeName = type1.toRubyString(context).catString("::").cat(type2.toRubyString(context));
return inspectIdentifierByteList(runtime, fullTypeName.getByteList());
}
public static RubyString ids(Ruby runtime, String id) {
ByteList identifier = runtime.newSymbol(id).getBytes();
return inspectIdentifierByteList(runtime, identifier);
}
/**
* Convert object to proper Ruby String representation of an id. This will not work for any string.
* It must represent an identifier the systems knows about.
*
* @param runtime
* @param object
*/
public static RubyString ids(Ruby runtime, IRubyObject object) {
ByteList identifier;
if (object instanceof RubyString) {
identifier = ((RubyString) object).getByteList();
} else if (object instanceof RubySymbol) {
identifier = ((RubySymbol) object).getBytes();
} else {
identifier = object.convertToString().getByteList();
}
return inspectIdentifierByteList(runtime, identifier);
}
public static RubyString inspectIdentifierByteList(final Ruby runtime, ByteList byteList) {
Encoding enc = byteList.getEncoding();
byte bytes[] = byteList.getUnsafeBytes();
int p = byteList.getBegin();
int end = p + byteList.getRealSize();
RubyString result = RubyString.newStringLight(runtime, new ByteList(end - p + 2));
result.getByteList().setBegin(1); // just in-case we need to prepend a '"'
Encoding resultEnc = runtime.getDefaultInternalEncoding();
boolean isUnicode = enc.isUnicode();
boolean asciiCompat = enc.isAsciiCompatible();
boolean needsQuotes = false;
if (resultEnc == null) resultEnc = runtime.getDefaultExternalEncoding();
if (!resultEnc.isAsciiCompatible()) resultEnc = USASCIIEncoding.INSTANCE;
result.associateEncoding(resultEnc);
int prev = p;
Encoding actEnc = EncodingUtils.getActualEncoding(enc, byteList);
if (actEnc != enc) {
enc = actEnc;
if (isUnicode) isUnicode = enc instanceof UnicodeEncoding;
}
while (p < end) {
int n = StringSupport.preciseLength(enc, bytes, p, end);
if (!MBCLEN_CHARFOUND_P(n)) {
if (p > prev) result.cat(bytes, prev, p - prev);
n = enc.minLength();
if (end < p + n) n = end - p;
while (n-- > 0) {
result.modifyExpand(result.size() + 4);
Sprintf.sprintf(runtime, result.getByteList() ,"\\x%02X", bytes[p] & 0377);
prev = ++p;
}
continue;
}
n = MBCLEN_CHARFOUND_LEN(n);
final int c = enc.mbcToCode(bytes, p, end); int cc = 0;
p += n;
if ((asciiCompat || isUnicode) &&
(c == '"' || c == '\\' ||
(c == '#' &&
p < end &&
MBCLEN_CHARFOUND_P(StringSupport.preciseLength(enc, bytes, p, end)) &&
((cc = codePoint(runtime, enc, bytes, p, end)) == '$' ||
cc == '@' || cc == '{')
)
)) {
if (p - n > prev) result.cat(bytes, prev, p - n - prev);
result.cat('\\');
if (asciiCompat || enc == resultEnc) {
prev = p - n;
continue;
}
}
switch (c) {
case '\n': cc = 'n'; break;
case '\r': cc = 'r'; break;
case '\t': cc = 't'; break;
case '\f': cc = 'f'; break;
case '\013': cc = 'v'; break;
case '\010': cc = 'b'; break;
case '\007': cc = 'a'; break;
case 033: cc = 'e'; break;
default: cc = 0; break;
}
if (cc != 0) {
if (p - n > prev) result.cat(bytes, prev, p - n - prev);
result.cat('\\');
result.cat(cc);
prev = p;
continue;
}
// FIXME: Can't use Encoding.isAscii because it does not treat int as unsigned 32-bit
if ((enc == resultEnc && enc.isPrint(c)) || (asciiCompat && (c < 128 && c > 0) && enc.isPrint(c))) {
continue;
} else {
if (p - n > prev) result.cat(bytes, prev, p - n - prev);
String format = StringSupport.escapedCharFormat(c, isUnicode);
if (!format.equals("%c")) needsQuotes = true;
Sprintf.sprintf(runtime, result.getByteList() ,format, (c & 0xFFFFFFFFL));
prev = p;
continue;
}
}
if (p > prev) result.cat(bytes, prev, p - prev);
if (needsQuotes) {
result.prepend('"');
result.cat('"');
}
return result;
}
public static String str(Ruby runtime, IRubyObject value, String message) {
RubyString buf = (RubyString) value.asString().dup();
catUTF8(runtime, buf, message);
return buf.toString();
}
public static String str(Ruby runtime, String message, IRubyObject value) {
RubyString buf = runtime.newString(message);
buf.cat19(value.asString());
return buf.toString();
}
public static String str(Ruby runtime, String messageBegin, IRubyObject value, String messageEnd) {
RubyString buf = runtime.newString(messageBegin);
buf.cat19(value.asString());
catUTF8(runtime, buf, messageEnd);
return buf.toString();
}
public static String str(Ruby runtime, IRubyObject value, String message, IRubyObject value2) {
RubyString buf = (RubyString) value.asString().dup();
catUTF8(runtime, buf, message);
buf.cat19(value2.asString());
return buf.toString();
}
public static String str(Ruby runtime, IRubyObject value, String message, IRubyObject value2, String message2) {
RubyString buf = (RubyString) value.asString().dup();
catUTF8(runtime, buf, message);
buf.cat19(value2.asString());
catUTF8(runtime, buf, message2);
return buf.toString();
}
public static String str(Ruby runtime, String messageBegin, IRubyObject value, String messageMiddle, IRubyObject value2) {
RubyString buf = runtime.newString(messageBegin);
buf.cat19(value.asString());
catUTF8(runtime, buf, messageMiddle);
buf.cat19(value2.asString());
return buf.toString();
}
public static String str(Ruby runtime, String messageBegin, IRubyObject value, String messageMiddle, IRubyObject value2, String messageEnd) {
RubyString buf = runtime.newString(messageBegin);
buf.cat19(value.asString());
catUTF8(runtime, buf, messageMiddle);
buf.cat19(value2.asString());
catUTF8(runtime, buf, messageEnd);
return buf.toString();
}
public static String str(Ruby runtime, String messageBegin, IRubyObject value, String messageMiddle, RubyString value2,
String messageMiddle2, IRubyObject value3, String messageMiddle3, RubyString value4, String messageEnd) {
RubyString buf = runtime.newString(messageBegin);
buf.cat19(value.asString());
catUTF8(runtime, buf, messageMiddle);
buf.cat19(value2);
catUTF8(runtime, buf, messageMiddle2);
buf.cat19(value3.asString());
catUTF8(runtime, buf, messageMiddle3);
buf.cat19(value4);
catUTF8(runtime, buf, messageEnd);
return buf.toString();
}
private static void catUTF8(final Ruby runtime, final RubyString str, final String value) {
EncodingUtils.encStrBufCat(runtime, str, value);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy