http://recipes.mentaframework.org/posts/list/2.page JForum - http://www.jforum.net
To support plain Ruby, all you need to do is copy the jruby.jar file inside the /WEB-INF/lib directory of your Mentawai web application. However, if you plan to use RubyGems and the Ruby Native Libraries (like 'date' for example) you will need to install JRuby in the machine running your Tomcat web server. To install JRuby is very easy. Follow the steps below:

:arrow: Download the zip file with the JRuby installation from here: http://dist.codehaus.org/jruby/ (Ex: jruby-bin-1.1.1.zip)

:arrow: Extract everything inside your root directory (or any directory)

:arrow: Set the environment variable JRUBY_HOME. (Ex: JRUBY_HOME=c:\jruby-1.1.1)

:arrow: Set the environment variable JRUBY_OPTS to -rubygems so that you don't need to require 'rubygems' in your code.

:arrow: Change your PATH environment variable to include %JRUBY_HOME\bin so that you can call the jruby script from anywhere in your shell.

If you did the above steps correctly, you should be able to play with jruby in your shell. Check the examplew below:
[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]

Now let's check an example of how to run Ruby inside your Mentawai web application. (download Mentawai 1.13 [url=http://www.mentaframework.org/beta/mentawai.jar]here[/url] if you need to)

All your ruby code must be placed inside the /WEB-INF/ruby/ directory of your web application. Mentawai loads ([i]do the require[/i]) any Ruby file from this directory plus it will reload any modified file pretty much like a JSP.

An action written in 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]

A Java Action calling Ruby code: /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]

Ruby code which is called by the Java action above: /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/57/60.page http://recipes.mentaframework.org/posts/preList/57/60.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/57/66.page http://recipes.mentaframework.org/posts/preList/57/66.page GMT