JRuby x Proxy x Reflection

[saoj]

Estou brincando com o JRuby e tentando instanciar objetos Ruby dentro do Java, para chamar código Ruby de dentro do Java.

Problema básico: o JRuby retorna java.lang.reflect.Proxy para todos os objetos Ruby criados, daí fico impossibilitado de usar qualquer tipo de reflection.

O que eu queria era por reflection chamar um método (desconhecido / não especificado por uma interface) de um objeto Ruby. Parece que o JRuby me deixa na mão em relação a isso…

O proxy do Java poderia colaborar também, mas acho que não tem jeito não, ou seja, se vc tem um Proxy, vc não tem como fazer reflection no objeto que está dentro do Proxy…

[rubinelli]

E se você fizesse a reflection do lado Ruby? Você poderia chamar object.methods para receber a array de métodos públicos do objeto. Isso não seria suficiente?

[saoj]

E se você fizesse a reflection do lado Ruby? Você poderia chamar object.methods para receber a array de métodos públicos do objeto. Isso não seria suficiente?

Vc diz criar um método em ruby do tipo:

def call_method(“methodName”, params)

Daí quando eu quisesse chamar qualquer método do Ruby de dentro do meu Java eu chamaria esse método?

Eu teria que ter esse método na interface do objeto, pelo mesmo problema, para poder chamá-lo… mas já seria um avanço…

Do java eu tenho que chamar object.methods para fazer a reflection… O problema é que o Proxy é fechadíssimo…

[saoj]

Achei! Tem que esperar mais um pouquinho pelo tal de Compile #2:

Compiler #2

Compiler #2 will basically take a Ruby class in a given file (or multiple Ruby classes, if you so choose) and generate a normal Java type. This type will look and feel like any other Java class:

* You can instantiate it with a normal new MyClass(arg1, arg2) from Java code
* You can invoke all its methods with normal Java invocations
* You can extend it with your own Java classes

The basic idea behind this compiler is to take all the visible signatures in a Ruby class definition, as seen during a quick walk through the code, and turn them into Java signatures on a normal class. Behind the scenes, those signatures will just dynamically invoke the named method, passing arguments through as normal. So for example, a piece of Ruby code like this:

class MyClass
def initialize(arg1, arg2); end
def method1(arg1); end
def method2(arg1, arg2 = ‘foo’, *arg3); end
end

Might produce a Java class equivalent to this:

public class MyClass extends RubyObject {
public MyClass(Object arg1, Object arg2) {
callMethod(“initialize”, arg1, arg2);
}

public Object method1(Object arg1) {
return callMethod(“method1”, arg1);
}

public Object method2(Object arg1, Object… optAndRest) {
return callMethod(“method2”, arg1, optAndRest);
}
}

It’s a pretty trivial amount of code to generate, but it completes that “last mile” of Java integration, being directly callable from Java and directly integrated into Java type hierarchies. Triply cool?

The Compiler Is Complete

[Leonardo3001]

Cara,

eu não sei se essa dica pode te ajudar. Mas o Akita, evangelista do Ruby on Rails no Brasil, publicou há um tempo atrás um artigo que fala como usar ruby usando a script engine do java:

Tutorial: Rodando Ruby usando Scripting do Java 6 | AkitaOnRails.com

É isso.