http://recipes.mentaframework.org/posts/list/4.page JForum - http://www.jforum.net
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:

:arrow: 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)

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

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

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

:arrow: 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:
[code]
c:\>jruby -v
ruby 1.8.6 (2008-04-22 rev 6555) [x86-jruby1.1.1]

c:\>jruby -S gem -v
1.1.0

c:\>jruby -S gem list --local

*** LOCAL GEMS ***

hoe (1.5.1)
hpricot (0.6)
jruby-openssl (0.2.3)
mechanize (0.7.6)
rake (0.8.1)
rspec (1.1.3)
rubyforge (0.4.5)
sources (0.0.1)
[/code]

Agora vamos ao exemplo de código Ruby rodando dentro do Mentawai (baixe a versão beta do Mentawai 1.13 [url=http://www.mentaframework.org/beta/mentawai.jar]aqui[/url])

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
[code]
include_class 'org.mentawai.core.BaseAction'

class MyFirstRubyAction < BaseAction

def execute
output["msg"] = "Hello from JRuby !!!!"
:success
end

end
[/code]

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

import java.util.Iterator;
import java.util.Map;

import org.mentawai.core.BaseAction;
import org.mentawai.jruby.JRubyInterpreter;

public class Hello extends BaseAction {

JRubyInterpreter ruby = JRubyInterpreter.getInstance();

public String execute() {

Object users = ruby.eval("Users.new");

Map map = (Map) ruby.call(users, "get_users");

Iterator iter = map.keySet().iterator();

StringBuilder sb = new StringBuilder();

while(iter.hasNext()) {
sb.append(iter.next()).append(" ");
}

output.setValue("msg", "Hello my friends: " + sb.toString());

return SUCCESS;
}
}
[/code]

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

class Users

def get_users
a = {}
a['Sergio'] = 1
a['Robert'] = 2
a
end

end
[/code]

ApplicationManager:
[code]
package org.hello;

import org.hello.action.Hello;

public class ApplicationManager extends org.mentawai.core.ApplicationManager {

@Override
public void loadActions() {

action("/HelloRuby1", Hello.class).on(SUCCESS, "/hello.jsp");

ruby("/HelloRuby2", "MyFirstRubyAction").on(SUCCESS, "/hello.jsp");

}

}
[/code]

]]> http://recipes.mentaframework.org/posts/preList/56/59.page http://recipes.mentaframework.org/posts/preList/56/59.page GMT
:arrow: Simple API to call ruby methods on any Ruby object from Java
:arrow: JRubyWrapper for making ruby method calls even easier
:arrow: Support method chaining. Ex: "methods.sort.grep"
:arrow: Auto-reload any ruby file from the loadpath
:arrow: Load any ruby file from the classpath with the loadFromClasspath method
:arrow: Get a singleton instance of the JRubyInterpreter anywhere in your code with the JRubyInterpreter.getInstance() method
:arrow: 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.
:arrow: Windows and Linux support


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

[color=red][b]OBS:[/b][/color] Don't forget to change this file to see how it will be automatically reloaded by JRubyInterpreter.

[code]

class Foo

def initialize(name)
@name = name
end

attr_accessor :name

def hi
puts "Hi from #{name}"
end

def get_a_list
[1,2,3]
end

def get_a_hash
{"one" => 1, "two" => 2}
end

def to_s
"I am #{name}"
end

end
[/code]

Plug and play with JRubyInterpreter:

[code]

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());
}
}
}
[/code]

Using the JRubyWrapper:

[code]

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);

}
}
[/code]


]]> http://recipes.mentaframework.org/posts/preList/56/65.page http://recipes.mentaframework.org/posts/preList/56/65.page GMT