Programando em Ruby com o Mentawai (integração total com JRuby)

A partir da versão 1.13 o Mentawai possui suporte total ao JRuby. Você pode escrever suas actions (e sua aplicação) inteiramente em Ruby ou você pode chamar qualquer código Ruby de dentro de suas actions em Java (ou de qualquer ponto da sua aplicação em Java).

Para suportar código Ruby, tudo que você necessita é copiar o arquivo jruby.jar para dentro do /WEB-INF/lib da sua aplicação. Entretanto, se você pretende usar RubyGems ou as bibliotecas nativas do Ruby (como 'date' por exemplo) você precisará ter o JRuby instalado na máquina que está rodando o seu Tomcat. Para instalar o JRuby é muito fácil:

Baixe o arquivo zip com a instalação da última versão do JRuby aqui: http://dist.codehaus.org/jruby/ (Ex: jruby-bin-1.1.1.zip)

Extraia tudo no seu diretório raiz (ou em qualquer outro)

Sete a variável de ambiente JRUBY_HOME. (Ex: JRUBY_HOME=c:\jruby-1.1.1)

Sete a variável de ambiente JRUBY_OPTS para -rubygems. (Assim você não precisa requerer 'rubygems' nos seus códigos)

Coloque o diretório %JRUBY_HOME%\bin no seu PATH de forma que você possa executar o comando jruby de qualquer lugar.

Se você fizer os passos acima você terá o jruby disponível no seu shell. Veja os exemplos abaixo:

Agora vamos ao exemplo de código Ruby rodando dentro do Mentawai (baixe a versão beta do Mentawai 1.13 aqui)

Todo e qualquer código Ruby deve ficar dentro do diretório /WEB-INF/ruby da sua aplicação web. O Mentawai carrega qualquer arquivo Ruby dentro desse diretório e tb faz o reload automático em caso de modificação (como uma página JSP).

Action inteiramente em Ruby: /WEB-INF/ruby/action_test.rb

Action em Java chamando código Ruby: /WEB-INF/src/org/hello/action/Hello.java

Código Ruby acessado pela action acima: /WEB-INF/ruby/users_test.rb

ApplicationManager:

Abaixo temos um resumo completo das funcionalidades do suporte a JRuby do Mentawai. (somente em inglês) (a partir da versão 1.15) (baixe o jar beta aqui)

Simple API to call ruby methods on any Ruby object from Java

JRubyWrapper for making ruby method calls even easier

Support method chaining. Ex: "methods.sort.grep"

Auto-reload any ruby file from the loadpath

Load any ruby file from the classpath with the loadFromClasspath method

Get a singleton instance of the JRubyInterpreter anywhere in your code with the JRubyInterpreter.getInstance() method

Support all JRuby environment variables and provide defaults for them. Ex: JRUBY_OPTS for -rubygems and -Ku , JRUBY_SHELL, JRUBY_SCRIPT, JRUBY_LIB and JRUBY_HOME.

Windows and Linux support

The file foo.rb anywhere in your loadpath (Ruby equivalent of Java's classpath)

OBS: Don't forget to change this file to see how it will be automatically reloaded by JRubyInterpreter.

Plug and play with JRubyInterpreter:

import org.mentawai.jruby.*;
import java.util.List;
import java.util.Map;

public class Test {

public static void main(String[] args) throws Exception {
        
        JRubyInterpreter ruby = JRubyInterpreter.getInstance();
        
        Object foo = ruby.eval("Foo.new('Sergio')"); // using eval...
        
        System.out.println("Foo class: " + foo.getClass()); // should be a RubyObject...
        
        System.out.println("Foo: " + foo); // to_s from Ruby will be called!
        
        ruby.call(foo, "hi"); // calling method hi...
        
        ruby.call(foo, "name=", "Joe"); // calling setter...
        
        ruby.call(foo, "hi"); // calling method hi...
        
        ruby.set(foo, "name", "Bill"); // shorter version for calling setter...
        
        ruby.call(foo, "hi"); // calling method hi...
        
        System.out.println("Name: " + ruby.call(foo, "name")); // calling getter...
        
        List<String> methods = (List<String>) ruby.call(foo, "methods.sort"); // method chaining...
        
        for(String s: methods) {
            
            System.out.println("M1: " + s);
            
        }
        
        methods = (List<String>) ruby.call(foo, "methods.sort.grep", "name="); // method chaining with params... (params only for last method!)
        
        for(String s: methods) {
            
            System.out.println("M2: " + s);
            
        }
        
        // testing respond_to?
        
        boolean ok = ruby.respondTo(foo, "get_a_list"); // calling Ruby's respond_to?...
        
        System.out.println("get_a_list: " + (ok ? "OK" : "NOTOK"));
        
        // getting a list...
     
        List<Object> list = (List<Object>) ruby.call(foo, "get_a_list");
        
        for(Object obj: list) {
         
            System.out.println(obj + " / " + obj.getClass());
            
        }
        
        // getting a hash...
        
        Map<Object, Object> map = (Map<Object, Object>) ruby.call(foo, "get_a_hash");
        
        for(Object key: map.keySet()) {
            
            Object v = map.get(key);
            
            System.out.println(key + " / " + key.getClass() + " => " + v + " / " + v.getClass());
        }
    }
}

Using the JRubyWrapper:

import org.mentawai.jruby.*;
import java.util.List;
import java.util.Map;

public class TestWrapper {

public static void main(String[] args) throws Exception {
        
        JRubyInterpreter ruby = JRubyInterpreter.getInstance();
        
        Object foo = ruby.eval("Foo.new('Sergio')"); // using eval...
        
        System.out.println("Foo class: " + foo.getClass()); // should be a RubyObject...
        
        System.out.println("Foo: " + foo); // to_s from Ruby will be called!
        
        JRubyWrapper fooW = new JRubyWrapper(foo);
        
        fooW.call("hi"); // calling method hi...
        
        fooW.call("name=", "Joe"); // calling setter...
        
        fooW.call("hi"); // calling method hi...
        
        fooW.set("name", "Bill"); // shorter version for calling setter...
        
        fooW.call("hi"); // calling method hi...
        
        System.out.println("Name: " + fooW.call("name")); // calling getter...

boolean ok = fooW.respondTo("get_a_hash");
        
        System.out.println("Ok: " + ok);
        
    }
}