Getting Started With JRuby on

Rails for the GlassFish v3

Application Server
Technology Preview 2

Sun Microsystems, Inc.

4150 Network Circle
Santa Clara, CA 95054
U.S.A.

Part No: 820–4926–05

June 2008
Copyright 2008 Sun Microsystems, Inc. 4150 Network Circle, Santa Clara, CA 95054 U.S.A. All rights reserved.

Sun Microsystems, Inc. has intellectual property rights relating to technology embodied in the product that is described in this document. In particular, and without
limitation, these intellectual property rights may include one or more U.S. patents or pending patent applications in the U.S. and in other countries.
U.S. Government Rights – Commercial software. Government users are subject to the Sun Microsystems, Inc. standard license agreement and applicable provisions
of the FAR and its supplements.
This distribution may include materials developed by third parties.
Parts of the product may be derived from Berkeley BSD systems, licensed from the University of California. UNIX is a registered trademark in the U.S. and other
countries, exclusively licensed through X/Open Company, Ltd.
Sun, Sun Microsystems, the Sun logo, the Solaris logo, the Java Coffee Cup logo, docs.sun.com, Java, and Solaris are trademarks or registered trademarks of Sun
Microsystems, Inc. in the U.S. and other countries. All SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC
International, Inc. in the U.S. and other countries. Products bearing SPARC trademarks are based upon an architecture developed by Sun Microsystems, Inc.
The OPEN LOOK and SunTM Graphical User Interface was developed by Sun Microsystems, Inc. for its users and licensees. Sun acknowledges the pioneering efforts
of Xerox in researching and developing the concept of visual or graphical user interfaces for the computer industry. Sun holds a non-exclusive license from Xerox to
the Xerox Graphical User Interface, which license also covers Sun's licensees who implement OPEN LOOK GUIs and otherwise comply with Sun's written license
agreements.
Products covered by and information contained in this publication are controlled by U.S. Export Control laws and may be subject to the export or import laws in
other countries. Nuclear, missile, chemical or biological weapons or nuclear maritime end uses or end users, whether direct or indirect, are strictly prohibited. Export
or reexport to countries subject to U.S. embargo or to entities identified on U.S. export exclusion lists, including, but not limited to, the denied persons and specially
designated nationals lists is strictly prohibited.
DOCUMENTATION IS PROVIDED “AS IS” AND ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE DISCLAIMED, EXCEPT TO
THE EXTENT THAT SUCH DISCLAIMERS ARE HELD TO BE LEGALLY INVALID.

Copyright 2008 Sun Microsystems, Inc. 4150 Network Circle, Santa Clara, CA 95054 U.S.A. Tous droits réservés.
Sun Microsystems, Inc. détient les droits de propriété intellectuelle relatifs à la technologie incorporée dans le produit qui est décrit dans ce document. En particulier,
et ce sans limitation, ces droits de propriété intellectuelle peuvent inclure un ou plusieurs brevets américains ou des applications de brevet en attente aux Etats-Unis
et dans d'autres pays.
Cette distribution peut comprendre des composants développés par des tierces personnes.
Certaines composants de ce produit peuvent être dérivées du logiciel Berkeley BSD, licenciés par l'Université de Californie. UNIX est une marque déposée aux
Etats-Unis et dans d'autres pays; elle est licenciée exclusivement par X/Open Company, Ltd.
Sun, Sun Microsystems, le logo Sun, le logo Solaris, le logo Java Coffee Cup, docs.sun.com, Java et Solaris sont des marques de fabrique ou des marques déposées de
Sun Microsystems, Inc. aux Etats-Unis et dans d'autres pays. Toutes les marques SPARC sont utilisées sous licence et sont des marques de fabrique ou des marques
déposées de SPARC International, Inc. aux Etats-Unis et dans d'autres pays. Les produits portant les marques SPARC sont basés sur une architecture développée par
Sun Microsystems, Inc.
L'interface d'utilisation graphique OPEN LOOK et Sun a été développée par Sun Microsystems, Inc. pour ses utilisateurs et licenciés. Sun reconnaît les efforts de
pionniers de Xerox pour la recherche et le développement du concept des interfaces d'utilisation visuelle ou graphique pour l'industrie de l'informatique. Sun détient
une licence non exclusive de Xerox sur l'interface d'utilisation graphique Xerox, cette licence couvrant également les licenciés de Sun qui mettent en place l'interface
d'utilisation graphique OPEN LOOK et qui, en outre, se conforment aux licences écrites de Sun.
Les produits qui font l'objet de cette publication et les informations qu'il contient sont régis par la legislation américaine en matière de contrôle des exportations et
peuvent être soumis au droit d'autres pays dans le domaine des exportations et importations. Les utilisations finales, ou utilisateurs finaux, pour des armes nucléaires,
des missiles, des armes chimiques ou biologiques ou pour le nucléaire maritime, directement ou indirectement, sont strictement interdites. Les exportations ou
réexportations vers des pays sous embargo des Etats-Unis, ou vers des entités figurant sur les listes d'exclusion d'exportation américaines, y compris, mais de manière
non exclusive, la liste de personnes qui font objet d'un ordre de ne pas participer, d'une façon directe ou indirecte, aux exportations des produits ou des services qui
sont régis par la legislation américaine en matière de contrôle des exportations et la liste de ressortissants spécifiquement designés, sont rigoureusement interdites.
LA DOCUMENTATION EST FOURNIE "EN L'ETAT" ET TOUTES AUTRES CONDITIONS, DECLARATIONS ET GARANTIES EXPRESSES OU TACITES
SONT FORMELLEMENT EXCLUES, DANS LA MESURE AUTORISEE PAR LA LOI APPLICABLE, Y COMPRIS NOTAMMENT TOUTE GARANTIE
IMPLICITE RELATIVE A LA QUALITE MARCHANDE, A L'APTITUDE A UNE UTILISATION PARTICULIERE OU A L'ABSENCE DE CONTREFACON.

080606@20209
Contents

JRuby on Rails in GlassFish Tutorial .................................................................................................... 5

Introduction to JRuby and Rails on the GlassFish v3 Application Server .......................................5
What is Ruby-on-Rails? .................................................................................................................5
What is JRuby? ................................................................................................................................6
JRuby on Rails, the GlassFish v3 Application Server, and the GlassFish v3 Gem ....................6
Installing JRuby and Required Gems ...................................................................................................7
▼ Downloading and Installing JRuby 1.1.1 .....................................................................................7
▼ Installing Rails on JRuby ................................................................................................................7
▼ Installing the GlassFish v3 Gem ....................................................................................................8
Creating a Simple Rails Application .....................................................................................................9
▼ Creating the hello Application ......................................................................................................9
▼ Creating the Controller and View .................................................................................................9
▼ Passing Data From the Controller to the View ............................................................................9
▼ Using Rails Without a Database ................................................................................................. 10
Deploying and Running the Application .......................................................................................... 11
▼ Deploying a Rails Application as a Directory ........................................................................... 11
▼ Deploying a Rails Application to the GlassFish V3 Gem ........................................................ 12
Accessing a Database From a Rails Application .............................................................................. 12
▼ Setting Up the MySQL Database Server .................................................................................... 12
▼ Creating a Database-Backed Rails Application ........................................................................ 12
▼ Deploying and Running the Database-Backed Web Application .......................................... 14
Accessing Java Libraries from a Rails Application ........................................................................... 14
▼ Creating the Rails Application That Accesses Java Libraries .................................................. 15
▼ Creating the Views That Display the Images Generated by Java2D Code. ........................... 15
▼ Adding Java2D Code to a Rails Controller ................................................................................ 16
▼ Running a Rails Application That Uses Java 2D Code ............................................................ 18
Further Information ............................................................................................................................ 18

3
4
 JRuby on Rails in GlassFish Tutorial

This tutorial shows you how to get started using JRuby on Rails on the GlassFishTM v3
Technology Preview 2 Application Server by covering the following topics:
■ “Introduction to JRuby and Rails on the GlassFish v3 Application Server” on page 5
■ “Installing JRuby and Required Gems” on page 7
■ “Creating a Simple Rails Application” on page 9
■ “Deploying and Running the Application” on page 11
■ “Accessing a Database From a Rails Application” on page 12
■ “Accessing Java Libraries from a Rails Application” on page 14

Introduction to JRuby and Rails on the GlassFish v3

Application Server
This section gives you an overview of JRuby and Rails on the GlassFish V3 Application Server
by explaining the following concepts:
■ What is Ruby-on-Rails?
■ What is JRuby?
■ The GlassFish v3 Application Server and the GlassFish v3 Gem

What is Ruby-on-Rails?
Ruby is an interpreted, dynamically-typed, object-oriented programming language. It has a
simple, natural syntax that enables developers to create applications quickly and easily. It also
includes the easy-to-use RubyGems packaging utility for customizing a Ruby installation with
additional plug-ins.

5
Introduction to JRuby and Rails on the GlassFish v3 Application Server

Rails is a web application framework that leverages the simplicity of Ruby and eliminates much
of the repetition and configuration required in other programming environments. With Rails,
you can create a database-backed web application, complete with models and tables, by running
a few one-line commands.

To learn more about Ruby on Rails, see Ruby on Rails.

What is JRuby?
JRuby is a JavaTM implementation of the Ruby interpreter. While retaining many of the popular
characteristics of Ruby, such as dynamic-typing, JRuby is integrated with the Java platform.
With JRuby and Rails, you get the simplicity and productivity offered by Ruby and Rails and the
power of the Java platform offered by JRuby, thereby giving you many benefits as a Rails
developer, including these:
■ You can access the rich set of Java libraries from your Rails application.
■ You can use the powerful and secure support of Java Unicode strings with your Rails
application.
■ Your JRuby-on-Rails application can spin off multiple threads because JRuby uses Java
threads, which map to native Ruby threads. Furthermore, you can pool these threads.

To learn more about JRuby, see JRuby.

JRuby on Rails, the GlassFish v3 Application Server,

and the GlassFish v3 Gem
Developing and deploying your Rails application on the GlassFish v3 Application Server gives
you the following advantages over using a typical web server used for running Rails
applications:
■ A simple, integrated deployment environment. In other words, you don't need one set of
software for developing the application and another set of software for deploying it.
■ The ability to deploy multiple Rails applications to one GlassFish instance
■ The ability of a Rails application to handle multiple requests

For more details on these and other advantages of using the GlassFish v3 Application Server for
your JRuby on Rails applications, see Advantages of JRuby-on-Rails with the GlassFish
Application Server.

You have two options for deploying a Rails application on the GlassFish v3 Application Server:
■ Deploy the application as a directory to the Application Server using the asadmin command.
■ Deploy the application as a directory to the GlassFish v3 Gem installed on your JRuby VM.

6 Getting Started With JRuby on Rails for the GlassFish v3 Application Server • June 2008
 Installing JRuby and Required Gems

A Gem is a Ruby package that contains a library or an application. In fact, Rails itself is a Gem
that you install on top of JRuby.

One way to work with JRuby on the GlassFish v3 Application Server is to install the GlassFish v3
Gem on top of your JRuby installation. The GlassFish v3 Gem is just a trimmed-down version
of the GlassFish V3 Application Server and a Grizzly connector for JRuby.

When you install the Gem, you have a GlassFish v3 Application Server embedded in the JRuby
virtual machine. This gives you a more complete development and production environment
because you have everything you need for JRuby on Rails applications running inside the JRuby
VM in addition to everything you need from the Application Server to create web applications.

Installing JRuby and Required Gems

To develop and deploy Rails applications on the GlassFish v3 Application Server, you need to
do the following:
1. Download and install JRuby 1.1.1.
2. Install Rails on top of your JRuby installation
3. Install the GlassFish v3 Gem if you want to deploy your application to a GlassFish instance
running inside your JRuby VM.

▼ Downloading and Installing JRuby 1.1.1

1 Go to the JRuby download site (http://dist.codehaus.org/jruby).

2 Download jruby-bin-1.1.1.zip.

3 Unpack the zip file.

4 Set your JRUBY_HOME environment variable to the location of your JRuby 1.1.1 installation.

5 Add JRUBY_HOME/bin to your system path so that you can invoke JRuby from anywhere in your
directory tree.

▼ Installing Rails on JRuby

● Install the Rails Gem:
jruby —S gem install rails

JRuby on Rails in GlassFish Tutorial 7

Installing JRuby and Required Gems

You should see the following output, which tells you that six Gems and their documentation
have been installed:

complete
Successfully installed activesupport-2.0.2
Successfully installed activerecord-2.0.2
Successfully installed actionpack-2.0.2
Successfully installed actionmailer-2.0.2
Successfully installed activeresource-2.0.2
Successfully installed rails-2.0.2
6 gems installed
Installing ri documentation for activesupport-2.0.2...
Installing ri documentation for activerecord-2.0.2...
Installing ri documentation for actionpack-2.0.2...
Installing ri documentation for actionmailer-2.0.2...
Installing ri documentation for activeresource-2.0.2...
Installing RDoc documentation for activesupport-2.0.2...
Installing RDoc documentation for activerecord-2.0.2...
Installing RDoc documentation for actionpack-2.0.2...
Installing RDoc documentation for actionmailer-2.0.2...
Installing RDoc documentation for activeresource-2.0.2...
The —S parameter that you used to run the command to install Rails tells JRuby to look for the
script anywhere in the JRUBY_HOME path.

▼ Installing the GlassFish v3 Gem

One of the ways to deploy a Rails application is to deploy it to the GlassFish v3 Application
Server running inside the JRuby virtual machine. To do this, you have to install the GlassFish v3
Gem on top of your JRuby installation:

● Run the Gem installer to install the GlassFish v3 Gem:

jruby -S gem install glassfish
You should see the following output:

complete
Successfully installed glassfish-0.1.2-universal-java
1 gem installed

8 Getting Started With JRuby on Rails for the GlassFish v3 Application Server • June 2008
 Creating a Simple Rails Application

Creating a Simple Rails Application

Now that you have completed your installations, you're ready to start coding. This section
shows you how to create a simple application that displays “Welcome to JRuby on Rails on the
GlassFish v3 Application Server!”

▼ Creating the hello Application

1 Go to <JRUBY_HOME>/samples.

2 Create a Rails application called hello by running the following command:

jruby -S rails hello
This command creates the hello directory, which contains a set of automatically-generated
files and directories. The directories containing the files that you'll use the most are:
■ app: Contains your application code
■ config: Contains configuration files, such as database.yml, which you use to configure a
database.
■ public: Contains files and resources that you need to be directly accessible rather than
accessed through the Rails call stack. These include images and straight HTML files.

▼ Creating the Controller and View

By doing this task, you'll create a controller and a default view for your application. The
controller handles requests, dispatches them to other parts of the application as necessary, and
determines which view to render. The view is the file that generates the output to the browser.
In Rails, views are typically written with ErB, a templating mechanism.

1 Go to the <JRUBY_HOME>/samples/hello directory you created in the previous task.

2 Run the following command to create a controller and default view for your application:
jruby script/generate controller home index
You should now see a controller called home_controller.rb in the hello/app/controllers
directory and a view called index.html.erb in the hello/app/views directory.

▼ Passing Data From the Controller to the View

Exchanging data between the controller and the views is a common task in web application
development. In this case, you'll see how to set an instance variable in the controller and access
its value from the view.

JRuby on Rails in GlassFish Tutorial 9

Creating a Simple Rails Application

1 Open <JRUBY_HOME>/samples/hello/app/controllers/home_controller.rb in a text editor.

2 Add an instance variable called @hello_message to the action called index, so that the
controller looks like this:
class HomeController < ApplicationController
def index
@hello_message = "Welcome to JRuby on Rails on the GlassFish V3 Application Server"
end
end

In Rails, the actions are supposed to map to views. So, when you access the index.html.erb file,
the index action executes. In this case, it makes the @hello_message variable available to
index.html.erb.

3 Save the file.

4 Open <JRUBY_HOME>/samples/hello/app/views/index.html.erb in a text editor.

5 At the end of the file, add the following output block:

<%= @hello_message %>

This is a bit of JRuby code embedded into the view that inserts the value of @hello_message
into the page. When you run the application, you will see “Welcome to JRuby on Rails on the
GlassFish v3 Application Server” in your browser.

6 Save the file.

▼ Using Rails Without a Database

Although Rails is intended for creating database-backed web applications, this example is
simple enough that it doesn't require one. In this case, you need to edit the enviroment.rb
configuration file to indicate that your application does not use a database.

1 Open <JRUBY_HOME>/samples/hello/config/environment.rb in a text editor.

2 Remove the pound character (#) in front of line 21 to uncomment it so that it reads as:
config.frameworks -= [ :active_record, :active_resource, :action_mailer ]

ActiveRecord supports database access for Rails applications. When you create model objects,
you will most likely base them on ActiveRecord::Base.

3 Save the file.

10 Getting Started With JRuby on Rails for the GlassFish v3 Application Server • June 2008
 Deploying and Running the Application

Deploying and Running the Application

As described in “JRuby on Rails, the GlassFish v3 Application Server, and the GlassFish v3
Gem” on page 6, you have two ways to deploy your Rails application on the GlassFish v3
Application Server:
■ Deploy it natively as a directory using the asadmin command.
■ Deploy it using the GlassFish v3 Gem

This section shows you how to deploy the hello application you created with the previous
section natively and with the GlassFish v3 Gem and how to run the application in your web
browser. You can use these same instructions to deploy a legacy Rails application as well.

▼ Deploying a Rails Application as a Directory

You can use directory-based deployment to deploy any Rails application natively to the
GlassFish v3 Application Server. To natively deploy the hello application to the Application
Server:

1 Set JRUBY_HOME to the path to your JRuby installation as the last line in one of the following files,
located in the configdirectory of your Application Server installation:

■ For Windows systems: asenv.bat

■ For Unix systems: asenv.conf

2 Save the file.

3 Start the application server.

4 Go to <JRUBY_HOME>/samples.

5 Deploy the hello application by running the asadmin command from your GlassFish v3
Application Server installation:
<AS_HOME>/bin/asadmin deploy hello

6 Run the hello application using the following URL in your browser:
http://localhost:8080/hello/home/index

JRuby on Rails in GlassFish Tutorial 11

Accessing a Database From a Rails Application

▼ Deploying a Rails Application to the GlassFish V3 Gem

1 Go to <JRUBY_HOME>/samples.

2 Deploy the hello application by running the following command:

jruby -S glassfish_rails hello
When the GlassFish instance is finished launching, you should see some output like the
following:

INFO: Rails instance instantiation took : 37754ms

3 Run the application using the following URL in your web browser:
http://localhost:3000/home/index
You should now see the following message in your browser window:

Welcome to JRuby on Rails on the GlassFish V3 Application Server!

Notice that the GlassFish v3 Gem runs on port 3000, not 8080.

Accessing a Database From a Rails Application

One of the main functions of Rails is to make a quick-and-easy task of creating an application
that accesses a database. This section shows you the steps to create a simple application that
accesses a book database using MySQL. It assumes that you've already installed JRuby 1.1.1,
Rails 2.0.2, and the required Gems.

▼ Setting Up the MySQL Database Server

1 Download and install the MySQL 5.0 Community Server
(http://dev.mysql.com/downloads/mysql/5.0.html#downloads)

2 Configure the server according to the MySQL documentation, including entering a root
password.

3 Start the server.

▼ Creating a Database-Backed Rails Application

1 Go to the <JRUBY_HOME>/samples directory of your JRuby 1.1.1 installation.

12 Getting Started With JRuby on Rails for the GlassFish v3 Application Server • June 2008
 Accessing a Database From a Rails Application

2 Create the books application template so that it is configured to use the MySQL database by
running the following command:
jruby -S rails books -d mysql

3 Go to the books directory you just created.

4 Open config/database.yml in a text editor.

5 Enter your MySQL root password where it asks for it under the development heading in the
database.yml file.

6 Go back to the books directory if you are not already there.

7 Create the database by running the following command:

jruby -S rake db:create

When the database creation is complete, you should see output that looks something like this:

** Execute db:create

The rake command invokes the Rake tool. The Rake tool builds applications by running Rake
files, which are written in Ruby and provide instructions for building applications.

8 Create the scaffold and the Book model for the application by running the following command:
jruby script/generate scaffold book title:string
author:string isbn:string description:text

When you run the script/generate command you specify the name of the model, the names
of the columns, and the types for the data contained in the columns.
A scaffold is the set of code that Rails generates to handle database operations for a model
object, which is Book in this case. The scaffold consists of a controller and some views that allow
users to perform the basic operations on a database, such as viewing the data, adding new
records, and editing records. Rails also creates the model object when generating the scaffold.

9 Create the database tables by running the following command:

jruby -S rake db:migrate

When Rails is finished creating the tables, you should see something like the following output:

CreateBooks: migrated (0.1322ms) =========

If you need to reset the database later, you can run jruby —S rake db:reset.

JRuby on Rails in GlassFish Tutorial 13

Accessing Java Libraries from a Rails Application

▼ Deploying and Running the Database-Backed Web

Application
With this task, you will deploy the books application to the GlassFish v3 Gem. You can
alternatively deploy it to your regular GlassFish v3 application server using directory-based
deployment, as described in “Deploying a Rails Application as a Directory” on page 11.

1 Go to <JRUBY_HOME>/samples/books.

2 Deploy the application to the GlassFish V3 Gem by running the following command:
jruby -S glassfish_rails books

3 Run the application in your web browser using the following URL:
http://localhost:3000/books
The opening page says “Listing books” and has an empty table, meaning that there are no book
records in the database yet. To add book records to the table, do the next step.

4 Add records to the table by clicking the New book link on the index.html page.

5 Enter the data for book on the new.html page and click Create.

Accessing Java Libraries from a Rails Application

The primary advantage of developing with JRuby is that you have access to Java libraries from a
Rails application. For example, say you want to create an image database and a web application
that allows processing of the images. You can use Rails to set up the database-backed web
application and use the powerful Java 2DTM API for processing the images on the server-side.

This section shows you how to get started using Java libraries in a Rails application while
stepping you through building a simple Rails application that does basic image processing with
the Java 2D API.

This application demonstrates the following concepts involved in using Java libraries in a Rails
application:
■ Giving your controller access to Java libraries.
■ Creating constants to refer to Java classes.
■ Performing file input and output using the java.io and javax.imageio packages.
■ Assigning Java objects to Ruby objects.
■ Calling Java methods and using variables.
■ Converting arrays from Java language arrays to Ruby arrays.
■ Streaming files to the client

14 Getting Started With JRuby on Rails for the GlassFish v3 Application Server • June 2008
 Accessing Java Libraries from a Rails Application

For simplicity's sake, this application does not use a database. You will need a JPEG file to run
this application.

▼ Creating the Rails Application That Accesses Java

Libraries
1 Go to <JRUBY_HOME>/samples.

2 Create an application by running this command:

jruby -S rails imageprocess

3 Open <JRUBY_HOME>/samples/imageprocess/config/environment.rb in a text editor.

4 Follow steps 2 and 3 from the instructions in section, “Using Rails Without a Database”on
page 10.

5 Go to the <JRUBY_HOME>/samples/imageprocess directory you just created.

6 Create a controller and default view for the application by running this command:
jruby script/generate controller home index

7 Go to the <JRUBY_HOME>/samples/imageprocess/app/views/home directory.

8 Create a second view by copying the default view into a view called seeimage.html.erb:
cp index.html.erb seeimage.html.erb

▼ Creating the Views That Display the Images Generated

by Java2D Code.
With this task, you will perform the following tasks:
■ Load an image on which you want to perform image processing with Java2D
■ Make the initial view show the original image and provide a link that the user clicks to
perform the ColorConvertOp image processing operation on it.
■ Make the other view display the processed image.

1 Find a JPEG image that you can use with this application.

2 Add the image to <JRUBY_HOME>/samples/imageprocess/public/image.

JRuby on Rails in GlassFish Tutorial 15

Accessing Java Libraries from a Rails Application

3 Go to <JRUBY_HOME>/samples/imageprocess/app/views/home.

4 Open index.html.erb in a text editor.

5 Replace the contents of this file with the following HTML markup:
<html>
<body>
<img src="../../images/kids.jpg"/><p>
<%= link_to "Perform a ColorConvertOp on this image", :action => "seeimage" %>
</body>
</html>

This page loads an image from <JRUBY_HOME>/samples/imageprocess/public/images and

provides a link that references to the seeimage action. The seeimage action maps to the
seeimage view, which shows the processed image.

6 Replace kids.jpg from line 3 of index.html.erb with the name of your image that you saved
from step 3 of this procedure.

7 Save index.html.erb.

8 Open seeimage.html.erb in a text editor.

9 Replace the contents of this file with the following HTML markup:
<html>
<body>
<img src="/home/processimage"/><p>
<%= link_to "Back", :action => "index" %>
</body>
</html>

The img tag on this page accesses the processimage action in HomeController. The
processimage action is where you will put the Java2D code to process the image you loaded
into index.html.erb.

▼ Adding Java2D Code to a Rails Controller

With this task, you will add the code to process your JPEG image.

1 Add the following line to HomeController, right after the class declaration:
include Java

This line is necessary for you to access any Java libraries from your controller.

16 Getting Started With JRuby on Rails for the GlassFish v3 Application Server • June 2008
 Accessing Java Libraries from a Rails Application

2 Create a constant for the BufferedImage class so that you can refer to it by the shorter name:
BI = java.awt.image.BufferedImage

3 Add an empty action, called seeimage, at the end of the controller:

def seeimage
end
This action is mapped to the seeimage.html.erb view.

4 Give the controller access to your image file using java.io.File, making sure to use the name
of your image in the path to the image file. Place the following line inside the seeimage action:
filename = "#{RAILS_ROOT}/public/images/kids.jpg"
imagefile = java.io.File.new(filename)
Notice that you don't need to declare the types of the variables, filename or imagefile. JRuby
can tell that filename is a String and imagefile is a java.io.File instance because that's
what you assigned them to be.

5 Read the file into a BufferedImage object and create a Graphics2D object from it so that you
can perform the image processing on it. Add these lines directly after the previous two lines:
bi = javax.imageio.ImageIO.read(imagefile)
w = bi.getWidth()
h = bi.getHeight()
bi2 = BI.new(w, h, BI::TYPE_INT_RGB)
big = bi2.getGraphics()
big.drawImage(bi, 0, 0, nil)
bi = bi2
biFiltered = bi
Refer to The Java Tutorial for more information on the Java 2D API. The important points are :
■ You can call Java methods in pretty much the same way in JRuby as you do in Java code
■ You don't have to initialize any variables.
■ You can just create a variable and assign anything to it. You don't need to give it a type.

6 Add the following code that converts the image to grayscale:

colorSpace = java.awt.color.ColorSpace.getInstance(
java.awt.color.ColorSpace::CS_GRAY)
op = java.awt.image.ColorConvertOp.new(colorSpace, nil)
dest = op.filter(biFiltered, nil)
big.drawImage(dest, 0, 0, nil);

7 Stream the file to the browser:

os = java.io.ByteArrayOutputStream.new
javax.imageio.ImageIO.write(biFiltered, "jpeg", os)
string = String.from_java_bytes(os.toByteArray)

JRuby on Rails in GlassFish Tutorial 17

Further Information

send_data string, :type => "image/jpeg", :disposition => "inline",

:filename => "newkids.jpg"
Sometimes you need to convert arrays from Ruby to Java code or from Java code to Ruby. In this
case, you need to use the from_java_bytes routine to convert the bytes in the output stream to
a Ruby string so that you can use it with send_data to stream the image to the browser. JRuby
provides some other routines for converting types, such as to_java to convert from a Ruby
Array to a Java String. See Conversion of Types.

▼ Running a Rails Application That Uses Java 2D Code

1 Deploy the application on the GlassFish v3 Gem:
jruby -S glassfish_rails imageprocess

2 Run the application by entering the following URL into your browser:
http://localhost:3000/home/index
You should now see an image and a link that says, “Perform a ColorConvertOp on this image.”

3 Click the link.

You should now see a grayscale version of the image from the previous page.

Further Information
For more information on Ruby-on-Rails, JRuby, and JRuby on the GlassFish Application
Server, see the following resources.
■ Ruby-on-Rails
■ JRuby
■ Scripting on the GlassFish Application Server

18 Getting Started With JRuby on Rails for the GlassFish v3 Application Server • June 2008