package org.jruby;
import org.jruby.anno.JRubyMethod;
import org.jruby.anno.JRubyClass;
import org.jruby.internal.runtime.methods.AliasMethod;
import org.jruby.internal.runtime.methods.DelegatingDynamicMethod;
import org.jruby.internal.runtime.methods.DynamicMethod;
import org.jruby.internal.runtime.methods.IRMethodArgs;
import org.jruby.internal.runtime.methods.ProcMethod;
import org.jruby.runtime.ArgumentDescriptor;
import org.jruby.runtime.Block;
import org.jruby.runtime.ClassIndex;
import org.jruby.runtime.Helpers;
import org.jruby.runtime.MethodBlockBody;
import org.jruby.runtime.ObjectAllocator;
import org.jruby.runtime.PositionAware;
import org.jruby.runtime.Signature;
import org.jruby.runtime.ThreadContext;
import org.jruby.runtime.builtin.IRubyObject;
import org.jruby.runtime.callsite.CacheEntry;
@JRubyClass(name="Method")
public class RubyMethod extends AbstractRubyMethod {
protected IRubyObject receiver;
protected RubyMethod(Ruby runtime, RubyClass rubyClass) {
super(runtime, rubyClass);
}
public static RubyClass createMethodClass(Ruby runtime) {
RubyClass methodClass = runtime.defineClass("Method", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
runtime.setMethod(methodClass);
methodClass.setClassIndex(ClassIndex.METHOD);
methodClass.setReifiedClass(RubyMethod.class);
methodClass.defineAnnotatedMethods(AbstractRubyMethod.class);
methodClass.defineAnnotatedMethods(RubyMethod.class);
return methodClass;
}
public static RubyMethod newMethod(
RubyModule implementationModule,
String methodName,
RubyModule originModule,
String originName,
CacheEntry entry,
IRubyObject receiver) {
Ruby runtime = implementationModule.getRuntime();
RubyMethod newMethod = new RubyMethod(runtime, runtime.getMethod());
newMethod.implementationModule = implementationModule;
newMethod.methodName = methodName;
newMethod.originModule = originModule;
newMethod.originName = originName;
newMethod.entry = entry;
newMethod.method = entry.method;
newMethod.sourceModule = entry.sourceModule;
newMethod.receiver = receiver;
return newMethod;
}
@JRubyMethod(name = {"call", "[]"})
public IRubyObject call(ThreadContext context, Block block) {
return method.call(context, receiver, sourceModule, methodName, block);
}
@JRubyMethod(name = {"call", "[]"})
public IRubyObject call(ThreadContext context, IRubyObject arg, Block block) {
return method.call(context, receiver, sourceModule, methodName, arg, block);
}
@JRubyMethod(name = {"call", "[]"})
public IRubyObject call(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) {
return method.call(context, receiver, sourceModule, methodName, arg0, arg1, block);
}
@JRubyMethod(name = {"call", "[]"})
public IRubyObject call(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) {
return method.call(context, receiver, sourceModule, methodName, arg0, arg1, arg2, block);
}
@JRubyMethod(name = {"call", "[]"}, rest = true)
public IRubyObject call(ThreadContext context, IRubyObject[] args, Block block) {
return method.call(context, receiver, sourceModule, methodName, args, block);
}
@JRubyMethod
public RubyFixnum arity() {
int value;
if (method instanceof IRMethodArgs) {
value = ((IRMethodArgs) method).getSignature().arityValue();
} else {
value = method.getArity().getValue();
}
return getRuntime().newFixnum(value);
}
@JRubyMethod(name = "eql?", required = 1)
public IRubyObject op_eql(ThreadContext context, IRubyObject other) {
return op_equal(context, other);
}
@Override
@JRubyMethod(name = "==", required = 1)
public RubyBoolean op_equal(ThreadContext context, IRubyObject other) {
return context.runtime.newBoolean( equals(other) );
}
@Override
@JRubyMethod(name = "===", required = 1)
public IRubyObject op_eqq(ThreadContext context, IRubyObject other) {
return method.call(context, receiver, sourceModule, methodName, other, Block.NULL_BLOCK);
}
@Override
public boolean equals(Object other) {
if (!(other instanceof RubyMethod)) {
return false;
}
if (method instanceof ProcMethod) {
return ((ProcMethod) method).isSame(((RubyMethod) other).getMethod());
}
if (getMetaClass() != ((RubyBasicObject) other).getMetaClass()) {
return false;
}
RubyMethod otherMethod = (RubyMethod)other;
return receiver == otherMethod.receiver && originModule == otherMethod.originModule &&
( isSerialMatch(otherMethod.method) || isMethodMissingMatch(otherMethod.getMethod().getRealMethod()) );
}
private boolean isMethodMissingMatch(DynamicMethod other) {
return (method.getRealMethod() instanceof RubyModule.RespondToMissingMethod) &&
((RubyModule.RespondToMissingMethod) method.getRealMethod()).equals(other);
}
private boolean isSerialMatch(DynamicMethod otherMethod) {
return method.getRealMethod().getSerialNumber() == otherMethod.getRealMethod().getSerialNumber();
}
@JRubyMethod
public RubyFixnum hash(ThreadContext context) {
return context.runtime.newFixnum(hashCodeImpl());
}
@Override
public int hashCode() {
return (int) hashCodeImpl();
}
private long hashCodeImpl() {
return receiver.hashCode() * method.getRealMethod().getSerialNumber();
}
@JRubyMethod(name = "clone")
@Override
public RubyMethod rbClone() {
RubyMethod newMethod = newMethod(implementationModule, methodName, originModule, originName, entry, receiver);
newMethod.setMetaClass(getMetaClass());
return newMethod;
}
@JRubyMethod
public IRubyObject to_proc(ThreadContext context) {
Ruby runtime = context.runtime;
MethodBlockBody body;
Signature signature;
ArgumentDescriptor[] argsDesc;
if (method instanceof IRMethodArgs) {
signature = ((IRMethodArgs) method).getSignature();
argsDesc = ((IRMethodArgs) method).getArgumentDescriptors();
} else {
signature = Signature.from(method.getArity());
argsDesc = Helpers.methodToArgumentDescriptors(method);
}
int line = getLine();
body = new MethodBlockBody(runtime.getStaticScopeFactory().getDummyScope(), signature, entry, argsDesc,
receiver, originModule, originName, getFilename(), line == -1 ? -1 : line - 1);
Block b = MethodBlockBody.createMethodBlock(body);
return RubyProc.newProc(runtime, b, Block.Type.LAMBDA);
}
@JRubyMethod
public RubyUnboundMethod unbind() {
RubyUnboundMethod unboundMethod =
RubyUnboundMethod.newUnboundMethod(implementationModule, methodName, originModule, originName, entry);
unboundMethod.infectBy(this);
return unboundMethod;
}
@JRubyMethod(name = {"inspect", "to_s"})
@Override
public IRubyObject inspect() {
Ruby runtime = getRuntime();
ThreadContext context = runtime.getCurrentContext();
RubyString str = RubyString.newString(runtime, "#<");
String sharp = "#";
str.catString(getType().getName()).catString(": ");
RubyModule definedClass;
RubyModule mklass = originModule;
if (method instanceof AliasMethod || method instanceof DelegatingDynamicMethod) {
definedClass = method.getRealMethod().getDefinedClass();
}
else {
definedClass = method.getDefinedClass();
}
if (definedClass.isIncluded()) {
definedClass = definedClass.getMetaClass();
}
if (mklass.isSingleton()) {
IRubyObject attached = ((MetaClass) mklass).getAttached();
if (receiver == null) {
str.cat19(inspect(context, mklass).convertToString());
} else if (receiver == attached) {
str.cat19(inspect(context, attached).convertToString());
sharp = ".";
} else {
str.cat19(inspect(context, receiver).convertToString());
str.catString("(");
str.cat19(inspect(context, attached).convertToString());
str.catString(")");
sharp = ".";
}
} else {
str.catString(mklass.getName());
if (definedClass != mklass) {
str.catString("(");
str.catString(definedClass.getName());
str.catString(")");
}
}
str.catString(sharp);
str.catString(this.methodName);
if (!methodName.equals(method.getName())) {
str.catString("(");
str.catString(method.getName());
str.catString(")");
}
if (method.isNotImplemented()) {
str.catString(" (not-implemented)");
}
str.catString(">");
return str;
}
@JRubyMethod
public IRubyObject receiver(ThreadContext context) {
return receiver;
}
@JRubyMethod
public IRubyObject source_location(ThreadContext context) {
Ruby runtime = context.runtime;
String filename = getFilename();
if (filename != null) {
return runtime.newArray(runtime.newString(filename), runtime.newFixnum(getLine()));
}
return context.nil;
}
public String getFilename() {
DynamicMethod realMethod = method.getRealMethod();
if (realMethod instanceof PositionAware) {
PositionAware poser = (PositionAware) realMethod;
return poser.getFile();
}
return null;
}
public int getLine() {
DynamicMethod realMethod = method.getRealMethod();
if (realMethod instanceof PositionAware) {
PositionAware poser = (PositionAware) realMethod;
return poser.getLine() + 1;
}
return -1;
}
@JRubyMethod
public IRubyObject parameters(ThreadContext context) {
return Helpers.methodToParameters(context.runtime, this);
}
@JRubyMethod(optional = 1)
public IRubyObject curry(ThreadContext context, IRubyObject[] args) {
return to_proc(context).callMethod(context, "curry", args);
}
@JRubyMethod
public IRubyObject super_method(ThreadContext context) {
return super_method(context, receiver, sourceModule.getSuperClass());
}
@JRubyMethod
public IRubyObject original_name(ThreadContext context) {
if (method instanceof AliasMethod) {
return context.runtime.newSymbol(((AliasMethod)method).getOldName());
}
return name(context);
}
}