@RubyLevelMethod(name = "trace_var", module = true) public static RubyValue trace_var(RubyValue receiver, RubyArray args, RubyBlock block) { if (null == args || args.size() < 1) { int actual_argc = (null == args) ? 0 : args.size(); throw new RubyException( RubyRuntime.ArgumentErrorClass, "in `trace_var': wrong number of arguments (" + actual_argc + " for 1)"); } if (!(args.get(0) instanceof RubySymbol)) { throw new RubyException( RubyRuntime.ArgumentErrorClass, args.get(0).toString() + " is not a symbol"); } String name = ((RubySymbol) args.get(0)).toString(); RubyValue v = args.get(1); if (v instanceof RubyProc) { GlobalVariables.addTraceProc(name, (RubyProc) v); } else if (null != block) { GlobalVariables.addTraceProc(name, ObjectFactory.createProc(block)); } else { throw new RubyException( RubyRuntime.ArgumentErrorClass, "tried to create Proc object without a block"); } return RubyConstant.QNIL; }
private void processResponse(RubyValue res) { if (res != null && res != RubyConstant.QNIL && res instanceof RubyHash) { RubyHash resHash = (RubyHash) res; RubyValue resBody = null; RubyArray arKeys = resHash.keys(); RubyArray arValues = resHash.values(); for (int i = 0; i < arKeys.size(); i++) { String strKey = arKeys.get(i).toString(); if (strKey.equals("request-body")) resBody = arValues.get(i); else if (strKey.equals("status")) responseCode = arValues.get(i).toInt(); else if (strKey.equals("message")) responseMsg = arValues.get(i).toString(); else resHeaders.addProperty(strKey, arValues.get(i).toString()); } String strBody = ""; if (resBody != null && resBody != RubyConstant.QNIL) strBody = resBody.toRubyString().toString(); if (!RHOCONF().getBool("log_skip_post")) LOG.TRACE(strBody); try { responseData = new ByteArrayInputStream(strBody.getBytes("UTF-8")); } catch (java.io.UnsupportedEncodingException exc) { LOG.ERROR("Error getting utf-8 body :", exc); } if (responseData != null) contentLength = Integer.parseInt(resHeaders.getPropertyIgnoreCase("Content-Length")); } }
// @RubyLevelMethod(name="gsub!") public RubyValue gsub_danger(RubyArray args, RubyBlock block) { if (null == block) { RubyString result = gsub(this, args); if (result == this) { return RubyConstant.QNIL; } else { return setString(result.toString()); } } else { if (null == args || args.size() != 1) { int actual_argc = (null == args) ? 0 : args.size(); throw new RubyException( RubyRuntime.ArgumentErrorClass, "in `gsub!': wrong number of arguments (" + actual_argc + " for 1)"); } if (!(args.get(0) instanceof RubyRegexp)) { throw new RubyException( RubyRuntime.ArgumentErrorClass, "wrong argument type " + args.get(0).getRubyClass().getName() + " (expected Regexp)"); } RubyRegexp r = (RubyRegexp) args.get(0); return setString(r.gsub(this, block).toString()); } }
@RubyLevelMethod(name = "open") public static RubyValue open(RubyValue receiver, RubyArray args, RubyBlock block) { String filename = args.get(0).toStr(); RubyIO io; if (args.size() <= 1) { io = ObjectFactory.createFile(filename, "r"); } else if (args.get(1) instanceof RubyFixnum) { String mode = "r"; int i = args.get(1).toInt(); if ((i & RDWR) != 0) { mode = mode + "w"; } io = ObjectFactory.createFile(filename, mode); } else { RubyString mode = (RubyString) args.get(1); io = ObjectFactory.createFile(filename, mode.toString()); } if (null == block) { return io; } else { RubyValue v = block.invoke(receiver, io); io.close(); return v; } }
private void processResponse(RubyValue res) { if (res != null && res != RubyConstant.QNIL && res instanceof RubyHash) { RubyHash resHash = (RubyHash) res; RubyValue resBody = null; RubyArray arKeys = resHash.keys(); RubyArray arValues = resHash.values(); for (int i = 0; i < arKeys.size(); i++) { String strKey = arKeys.get(i).toString(); if (strKey.equals("request-body")) resBody = arValues.get(i); else if (strKey.equals("status")) responseCode = arValues.get(i).toInt(); else if (strKey.equals("message")) responseMsg = arValues.get(i).toString(); else resHeaders.addProperty(strKey, arValues.get(i).toString()); } String strBody = ""; if (resBody != null && resBody != RubyConstant.QNIL) strBody = resBody.toRubyString().toString(); log(strBody); responseData = new ByteArrayInputStream(strBody.getBytes()); if (responseData != null) contentLength = Integer.parseInt(resHeaders.getPropertyIgnoreCase("Content-Length")); } }
// @RubyLevelMethod(name="[]=") public RubyValue aset(RubyArray args) { if (3 == args.size()) { int index = args.get(0).toInt(); int length = args.get(1).toInt(); return replace(index, length, args.get(2)); } throw new RubyException( RubyRuntime.ArgumentErrorClass, "wrong number of arguments (" + args.size() + " for 2)"); }
@RubyLevelMethod(name = "respond_to?") public static RubyValue respond_to(RubyValue receiver, RubyArray args) { if (null == args || args.size() < 1) { int actual_argc = (null == args) ? 0 : args.size(); throw new RubyException( RubyRuntime.ArgumentErrorClass, "in `respond_to': wrong number of arguments (" + actual_argc + " for 1)"); } boolean include_private = (RubyConstant.QTRUE == args.get(1)); RubyID mid = RubyID.intern(args.get(0).toStr()); return ObjectFactory.createBoolean(hasMethod(receiver, mid, include_private)); }
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 = "eval", module = true) public static RubyValue eval(RubyValue receiver, RubyArray args) { RubyBinding binding = null; if (args.get(1) instanceof RubyBinding) { binding = (RubyBinding) args.get(1); } String file_name = null; if (args.size() > 2) { file_name = args.get(2).toStr(); } return eval(args.get(0).toStr(), binding, file_name); }
// RHO_COMMENT public boolean equals(Object o, boolean bConvToAry) { if (this == o) { return true; } if (o instanceof RubyArray) { RubyArray that = (RubyArray) o; int size = array_.size(); if (size != that.size()) { return false; } for (int i = 0; i < size; ++i) { if (!this.get(i).equals(that.get(i))) { return false; } } return true; } else if (o instanceof RubyValue && bConvToAry) { RubyValue v = (RubyValue) o; if (!v.respondTo(RubyID.toAryID)) { return false; } else { return v.equals(this); } } else { return false; } }
// @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="end_with?") public RubyValue opEndWith(RubyArray v) { for (int i = 0; i < v.size(); i++) { RubyValue res = opEndWith(v.get(i)); if (res == RubyConstant.QTRUE) return RubyConstant.QTRUE; } return RubyConstant.QFALSE; }
private Collection /*<String>*/ split(RubyString g, RubyRegexp r, RubyArray args) { if (args.size() <= 1) { return r.split(g.toString(), 0); } else { RubyFixnum i = (RubyFixnum) args.get(1); return r.split(g.toString(), i.toInt()); } }
// @RubyLevelMethod(name="chomp!") public RubyValue chomp_danger(RubyArray args) { RubyValue separator = (null == args) ? GlobalVariables.get("$/") : args.get(0); if (chomp(((RubyString) separator).toString())) { return this; } else { return RubyConstant.QNIL; } }
// @RubyLevelMethod(name="indexes", alias="indices") public RubyValue indexes(RubyArray args) { RubyArray a = new RubyArray(args.size()); for (int i = 0; i < size(); i++) { RubyFixnum n = (RubyFixnum) args.get(i); a.add(get(n.toInt())); } return a; }
// @RubyLevelMethod(name="collect!") public RubyValue collect_danger(RubyBlock block) { RubyArray a = (RubyArray) RubyAPI.callPublicNoArgMethod(this, block, RubyID.intern("collect")); clear(); for (int i = 0; i < a.size(); i++) { add(a.get(i)); } return this; }
// FIXME:This method should be module. @RubyLevelMethod(name = "raise", alias = "fail") public static RubyValue raise(RubyValue value, RubyArray args) { RubyExceptionValue e; if (null == args) { // With no arguments, raises the exception in $! or raises a RuntimeError if $! is nil. RubyValue v = GlobalVariables.get("$!"); if (RubyConstant.QNIL == v) { e = new RubyExceptionValue(RubyRuntime.RuntimeErrorClass, ""); } else { e = (RubyExceptionValue) v; } } else if (1 == args.size() && (args.get(0) instanceof RubyString)) { // With a single String argument, raises a RuntimeError with the string as a message. e = new RubyExceptionValue( RubyRuntime.RuntimeErrorClass, ((RubyString) args.get(0)).toString()); } else if (args.get(0) instanceof RubyExceptionValue) { // Otherwise, the first parameter should be the name of an Exception class // (or an object that returns an Exception when sent exception). The optional second // parameter sets the message associated with the exception, and the third parameter // is an array of callback information. e = (RubyExceptionValue) args.get(0); if (args.size() > 1) { e.setMessage(((RubyString) args.get(1)).toString()); } } else { RubyClass v = (RubyClass) args.get(0); e = new RubyExceptionValue(v, 1 == args.size() ? "" : ((RubyString) args.get(1)).toString()); } throw new RubyException(e); }
@RubyLevelMethod(name = "method_missing", module = true) public static RubyValue methodMissing(RubyValue receiver, RubyArray args) { RubySymbol method_name = (RubySymbol) args.get(0); RubyClass klass = receiver.getRubyClass(); klass = (klass != null) ? klass.getRealClass() : null; throw new RubyException( RubyRuntime.NoMethodErrorClass, "undefined method '" + method_name.toString() + "' for " + klass.getName()); }
@RubyLevelMethod(name = "throw", module = true) public static RubyValue throwMethod(RubyValue receiver, RubyArray args) { RubyExceptionValue e; RubyValue tag = args.get(0); if (tag instanceof RubySymbol || tag instanceof RubyString) { e = new RubyExceptionValueForThrow(tag, args.get(1)); } else if (tag instanceof RubyExceptionValue) { e = (RubyExceptionValue) tag; } else if (tag instanceof RubyClass) { RubyClass c = (RubyClass) tag; e = new RubyExceptionValue(c, c.getName() + " is not a symbol"); } else { e = new RubyExceptionValue( RubyRuntime.ArgumentErrorClass, tag.toString() + " is not a symbol"); } throw new RubyException(e); }
@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()); }
// @RubyLevelMethod(name="replace") public RubyValue replace(RubyValue arg) { RubyArray anotherArray = (RubyArray) arg; if (this == anotherArray) return this; clear(); for (int i = 0; i < anotherArray.size(); i++) { add(anotherArray.get(i)); } return this; }
// @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; }
// @RubyLevelMethod(name="delete!") public RubyValue delete_danger(RubyArray args) { if (null == args) { throw new RubyException(RubyRuntime.ArgumentErrorClass, "wrong number of arguments"); } String arg = ((RubyString) args.get(0)).toString(); if (delete(arg)) return this; return RubyConstant.QNIL; // return delete(arg) ? this : RubyConstant.QNIL; }
// @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); } }
// @RubyLevelMethod(name="gsub") public RubyValue gsub(RubyArray args, RubyBlock block) { if (null == block) { return gsub(this, args); } else { if (null == args || args.size() != 1) { int actual_argc = (null == args) ? 0 : args.size(); throw new RubyException( RubyRuntime.ArgumentErrorClass, "in `gsub': wrong number of arguments (" + actual_argc + " for 1)"); } if (!(args.get(0) instanceof RubyRegexp)) { throw new RubyException( RubyRuntime.ArgumentErrorClass, "wrong argument type " + args.get(0).getRubyClass().getName() + " (expected Regexp)"); } RubyRegexp r = (RubyRegexp) args.get(0); return r.gsub(this, block); } }
private boolean recursiveAdd(RubyArray receiver, RubyArray array) { boolean modified = false; for (int i = 0; i < array.size(); i++) { RubyValue val = array.get(i); if (val instanceof RubyArray) { modified = true; recursiveAdd(receiver, (RubyArray) val); } else { receiver.add(val); } } return modified; }
// @RubyLevelMethod(name="new", singleton=true) public static RubyValue newArray(RubyValue receiver, RubyArray args, RubyBlock block) { RubyArray a; if (null == args) { a = new RubyArray(); } else if (null == block) { if (args.get(0) instanceof RubyArray) { a = (RubyArray) args.get(0).clone(); } else { RubyFixnum size = (RubyFixnum) args.get(0); RubyValue default_value = args.get(1); a = ObjectFactory.createArray(size.toInt(), default_value); } } else { RubyFixnum size = (RubyFixnum) args.get(0); a = new RubyArray(); for (int i = 0; i < size.toFloat(); i++) { RubyValue return_value = block.invoke(receiver, ObjectFactory.createFixnum(i)); a.add(return_value); } } a.setRubyClass((RubyClass) receiver); return a; }
public static Object[] buildFormatArg(RubyArray args, int start) { Object[] raw_args = new Object[args.size() - start]; for (int i = 0; i < args.size() - start; ++i) { Object v = args.get(i + start); if (v instanceof RubyFixnum) { raw_args[i] = ((RubyFixnum) v).toInt(); } else if (v instanceof RubyFloat) { raw_args[i] = ((RubyFloat) v).doubleValue(); } else { raw_args[i] = v; } } return raw_args; }
@RubyLevelMethod(name = "instance_eval") public static RubyValue instanceEval(RubyValue receiver, RubyArray args, RubyBlock block) { if (null == args && null == block) { throw new RubyException(RubyRuntime.ArgumentErrorClass, "block not supplied"); } if (null != args) { RubyBinding binding = new RubyBinding(); System.out.println(receiver); binding.setScope((RubyModule) receiver); binding.setSelf(receiver); return eval(args.get(0).toStr(), binding); } else { block.setSelf(receiver); return block.invoke(receiver); } }
// @RubyLevelMethod(name="insert") public RubyArray insert(RubyArray ary) { int argc = ary.size(); if (argc == 1) { return this; } if (argc < 1) { throw new RubyException( RubyRuntime.ArgumentErrorClass, "wrong number of arguments (at least 1)"); } int pos = ary.get(0).toInt(); if (pos < 0) { pos += this.array_.size() + 1; } return this.insert(pos, ary.subarray(1, ary.size() - 1)); }