// @RubyLevelMethod(name="downcase")
public RubyString downcase() {
int length = this.sb_.length();
if (length == 0) {
return ObjectFactory.createString();
}
char[] ca = new char[length];
this.sb_.getChars(0, length, ca, 0);
for (int i = 0; i < ca.length; i++) {
ca[i] = Character.toLowerCase(ca[i]);
}
return ObjectFactory.createString(new StringBuffer().append(ca));
}
// @RubyLevelMethod(name="tr_s")
public RubyValue tr_s(RubyValue arg1, RubyValue arg2) {
RubyString string = ObjectFactory.createString(toString());
RubyString from = (RubyString) arg1;
RubyString to = (RubyString) arg2;
string.tr_s(from.toString(), to.toString());
return string;
}
private RubyString sub(RubyString g, RubyArray args) {
if (null == args || args.size() != 2) {
int actual_argc = (null == args) ? 0 : args.size();
throw new RubyException(
RubyRuntime.ArgumentErrorClass,
"in `sub': wrong number of arguments (" + actual_argc + " for 2)");
}
if (!(args.get(1) instanceof RubyString)) {
throw new RubyException(
RubyRuntime.ArgumentErrorClass,
"can't convert " + args.get(1).getRubyClass().getName() + " into String");
}
RubyString s = (RubyString) args.get(1);
if (args.get(0) instanceof RubyRegexp) {
RubyRegexp r = (RubyRegexp) args.get(0);
return r.sub(g, s);
} else if (args.get(0) instanceof RubyString) {
RubyString r = (RubyString) args.get(0);
String result = StringMe.replaceFirst(g.toString(), r.toString(), s.toString());
return ObjectFactory.createString(result);
} else {
throw new RubyException(
RubyRuntime.ArgumentErrorClass,
"wrong argument type " + args.get(0).getRubyClass().getName() + " (expected Regexp)");
}
}
// @RubyLevelMethod(name="split")
public RubyValue split(RubyArray args) {
RubyValue r = (null == args) ? GlobalVariables.get("$;") : args.get(0);
Collection /*<String>*/ splitResult;
boolean bSkipFirstEmptyItem = false;
if (r == RubyConstant.QNIL) {
splitResult = split(this, " ");
} else if (r instanceof RubyRegexp) {
RubyRegexp reg = (RubyRegexp) r;
splitResult = split(this, reg, args);
if (reg.getPattern().getPattern().startsWith("(?=")) bSkipFirstEmptyItem = true;
} else if (r instanceof RubyString) {
splitResult = split(this, ((RubyString) r).toString());
} else {
throw new RubyException(
RubyRuntime.ArgumentErrorClass,
"wrong argument type " + r.getRubyClass() + " (expected Regexp)");
}
RubyArray a = new RubyArray(splitResult.size());
int i = 0;
// for (String str : splitResult) {
for (Iterator iter = splitResult.iterator(); iter.hasNext(); ) {
String str = (String) iter.next();
if (!(bSkipFirstEmptyItem && 0 == i && (str == null || str.equals("")))) {
// To conform ruby's behavior, discard the first empty element
a.add(ObjectFactory.createString(str));
}
++i;
}
return a;
}
@RubyLevelMethod(name = "to_s")
public RubyString to_s(RubyValue v) {
int radix = v.toInt();
if (radix < 2 || radix > 36) {
throw new RubyException(RubyRuntime.ArgumentErrorClass, "illegal radix " + radix);
}
return ObjectFactory.createString(this.toString(radix));
}
public RubyValue post_match() {
String res = "";
int nMatchEnd = result_.endOffset(result_.groups() - 1);
if (nMatchEnd >= 0 && nMatchEnd + 1 < str_.length()) res = str_.substring(nMatchEnd);
if (res == null) return RubyConstant.QNIL;
return ObjectFactory.createString(res);
}
public RubyValue pre_match() {
String res = "";
int nMatchEnd = result_.beginOffset(0);
if (nMatchEnd >= 0 && nMatchEnd < str_.length()) res = str_.substring(0, nMatchEnd);
if (res == null) return RubyConstant.QNIL;
return ObjectFactory.createString(res);
}
RubyValue getRetValue() {
RubyValue ret = RubyConstant.QNIL;
if (isNoThreadedMode()) {
ret = ObjectFactory.createString(getSyncEngine().getNotify().getNotifyBody());
getSyncEngine().getNotify().cleanNotifyBody();
}
return ret;
}
// @RubyLevelMethod(name="delete")
public RubyValue delete(RubyArray args) {
if (null == args) {
throw new RubyException(RubyRuntime.ArgumentErrorClass, "wrong number of arguments");
}
RubyString string = ObjectFactory.createString(toString());
String arg = ((RubyString) args.get(0)).toString();
string.delete(arg);
return string;
}
public RubyString appendString(RubyValue v) {
if (v instanceof RubyString) {
return appendString((RubyString) v);
} else {
RubyValue r = RubyAPI.callPublicNoArgMethod(v, null, RubyID.toSID);
if (r instanceof RubyString) return appendString((RubyString) r);
return ObjectFactory.createString(r.toString());
}
}
@RubyLevelMethod(name = "gets", module = true)
public static RubyValue gets(RubyValue receiver) {
String s = null;
try {
s = in_.readLine();
} catch (IOException e) {
}
GlobalVariables.set((null == s ? RubyConstant.QNIL : ObjectFactory.createString(s)), "$_");
return GlobalVariables.get("$_");
}
// @RubyLevelMethod(name="[]")
public RubyValue array_access(RubyArray args) {
String string = toString();
if (args.size() == 1) {
RubyValue arg = args.get(0);
if (arg instanceof RubyString) {
String str = ((RubyString) arg).toString();
if (string.indexOf(str) >= 0) {
return ObjectFactory.createString(str);
} else {
return RubyConstant.QNIL;
}
} else if (arg instanceof RubyRange) {
RubyRange range = (RubyRange) arg;
int start = range.getLeft().toInt();
int end = range.getRight().toInt();
return substring(string, start, end, range.isExcludeEnd());
} else if (arg instanceof RubyRegexp) {
RubyRegexp regexp = (RubyRegexp) arg;
RubyMatchData match = regexp.match(string);
if (match != null) {
return ObjectFactory.createString(match.toString());
} else {
return RubyConstant.QNIL;
}
} else {
int index = arg.toInt();
if (index < 0) {
index = string.length() + index;
}
if (index < 0 || index >= string.length()) {
return RubyConstant.QNIL;
} else {
return ObjectFactory.createFixnum(string.charAt(index));
}
}
} else {
int start = args.get(0).toInt();
int length = args.get(1).toInt() - 1;
return substring(string, start, start + length, false);
}
}
public RubyValue captures() {
RubyArray ar = new RubyArray();
for (int i = 1; i < result_.groups(); i++) {
String res = result_.group(i);
if (res == null) ar.add(RubyConstant.QNIL);
else ar.add(ObjectFactory.createString(res));
}
return ar;
}
@RubyLevelMethod(name = "sprintf", module = true)
public static RubyValue sprintf(RubyValue receiver, RubyArray args) {
String fmt = args.get(0).toStr();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PrintStream ps = new PrintStream(baos);
ps.printf(fmt, RubyKernelModule.buildFormatArg(args, 1));
ps.flush();
ps.close();
return ObjectFactory.createString(baos.toString());
}
public RubyValue to_a() {
RubyArray ar = new RubyArray();
for (int i = 0; i < result_.groups(); i++) {
String str = result_.group(i);
if (str != null) ar.add(ObjectFactory.createString(str));
else ar.add(RubyConstant.QNIL);
}
return ar;
}
// @RubyLevelMethod(name="swapcase")
public RubyString swapcase() {
int length = this.sb_.length();
if (length == 0) {
return ObjectFactory.createString();
}
char[] ca = new char[length];
this.sb_.getChars(0, length, ca, 0);
for (int i = 0; i < length; i++) {
char c = ca[i];
if (Character.isUpperCase(c)) {
ca[i] = Character.toLowerCase(c);
} else if (Character.isLowerCase(c)) {
ca[i] = Character.toUpperCase(c);
}
}
return ObjectFactory.createString(new StringBuffer().append(ca));
}
// @RubyLevelMethod(name="*")
public RubyValue operator_star(RubyValue arg) {
String string = toString();
int count = arg.toInt();
if (count < 0) {
throw new RubyException(RubyRuntime.ArgumentErrorClass, "negative argument");
}
StringBuffer result = new StringBuffer();
for (int i = 0; i < count; ++i) {
result.append(string);
}
return ObjectFactory.createString(result);
}
// @RubyLevelMethod(name="%")
public RubyValue format(RubyValue arg) {
String format = toString();
String s;
// RHO_MOBILE
if (arg instanceof RubyArray) {
// s = StringMe.format(format,
// com.xruby.runtime.lang.RubyKernelModule.buildFormatArg((RubyArray)arg, 0));
s = StringMe.format(format, (RubyArray) arg);
} else {
// s = StringMe.format(format, com.xruby.runtime.lang.RubyKernelModule.buildFormatArg(new
// RubyArray(arg), 0));
RubyArray args = new RubyArray(arg);
s = StringMe.format(format, args);
}
return ObjectFactory.createString(s);
}
// @RubyLevelMethod(name="[]")
public RubyValue aref(RubyValue arg) {
if (arg instanceof RubyFixnum) {
int index = arg.toInt();
if (index < 0) index += result_.groups();
String res = result_.group(index);
if (res == null) return RubyConstant.QNIL;
return ObjectFactory.createString(res);
} else if (arg instanceof RubyString) {
// TODO: implement m = /(?<foo>a+)b/.match("ccaaab"); m["foo"] #=> "aaa"
throw new RuntimeException("Not implemented");
}
RubyArray ar = (RubyArray) to_a();
return ar.aref(arg);
}
private RubyValue substring(String string, int begin, int end, boolean isExcludeEnd) {
if (begin < 0) {
begin = string.length() + begin;
}
if (end < 0) {
end = string.length() + end;
}
if (!isExcludeEnd) {
++end;
}
if (begin < 0 || end < 0 || begin > end || begin > string.length() || end > string.length()) {
return RubyConstant.QNIL;
}
return ObjectFactory.createString(string.substring(begin, end));
}
@RubyLevelMethod(name = "to_s")
public static RubyValue anyObjToS(RubyValue receiver) {
String className = receiver.getRubyClass().getName();
return ObjectFactory.createString(
"#<" + className + ":0x" + Integer.toHexString(receiver.hashCode()) + "x>");
}
@RubyLevelMethod(name = "inspect")
public static RubyValue objInsepct(RubyValue receiver) {
return ObjectFactory.createString(receiver.inspect());
}
// @RubyLevelMethod(name="+")
public RubyString plus(RubyValue v) {
StringBuffer sb = new StringBuffer();
sb.append(this.sb_);
sb.append(v.toRubyString().sb_);
return ObjectFactory.createString(sb);
}
@RubyLevelMethod(name = "to_s")
public RubyString to_s() {
return ObjectFactory.createString(this.toString());
}
// @RubyAllocMethod
public static RubyString alloc(RubyValue receiver) {
return ObjectFactory.createString((RubyClass) receiver, "");
}
// @RubyLevelMethod(name="to_s")
public RubyString to_s() {
return ObjectFactory.createString(this.sb_.toString());
}
// @RubyLevelMethod(name="to_s")
public RubyString to_s() {
return ObjectFactory.createString(result_.toString());
}
// @RubyLevelMethod(name="strip")
public RubyString strip() {
return ObjectFactory.createString(sb_.toString().trim());
}
// @RubyLevelMethod(name="pack")
public RubyValue pack(RubyValue arg) {
String format = ((RubyString) arg).toString();
return ObjectFactory.createString(ArrayPacker.pack(this, format));
}
// @RubyLevelMethod(name="dump")
public RubyString rubyDump() {
return ObjectFactory.createString(this.dump());
}