• Instant Rails 2.0 with Rails 2.0.2 and Ruby 1.8.6
• Tomcat 6.0.14
• MySQL 5.0.45
• Eclipse 3.22

In 2004 David Heinemeier Hansson brought out the webapp framework Ruby on Rails (RoR), based on the MVC architecture. It comes packaged with a webserver (WEBrick) and a database (now SQLlite). With surprising speed Ruby on Rails became a popular alternative to Java and PHP for creating web applications. Recently version 2.0 of Ruby on Rails came out with a lot of changes. It has also just become feasible to convert Ruby on Rails applications to WARfiles and deploy them on Java webapp servers like Tomcat, which should hasten the adoption of this framework. There is a popular plugin for Eclipse called RDT.

Although this is not a tutorial, we should give some idea of how streamlined the webapp development process is. It starts by getting Ruby on Rails to generate a skeleton. From the command-line:

> rails -d mysql webofcontacts

> rake db:create:all

It is now necessary to give Ruby on Rails the database password by editing the generated database.yml file. After that:

> ruby script/generate scaffold 
Contact first_name:string last_name:string priority:integer 
phone_nums:string email:string web_page:string photo_uri:string
> rake db:migrate

The server is then started:

> ruby script/server webrick

If you open the project in Eclipse (having first installed the Ruby plugin) you can see the directories that have been created. The screenshot below includes some files that were created during development.

<%= link_to 'CREATE CONTACT', :controller => 'contacts', :action => 'new' %>

It is also easy to bind an entity (such as a Contact) to a form using Rails tags. In the view (*.html.erb files), code to generate a text box for the first name of a contact looks like this:

<%= text_field :contact, :first_name %>

<% form_tag :action => 'change', :id => @contact.id.to_s do -%>
...
<% end %>

Both edit.html.erb (updating the contact) and new.html.erb (creating the contact) can use the same basic form, so within the form_tag block they both include form.html.erb (inserted by render). For example, in the update page:

  <%= render :partial => 'form', :locals => { :f => @contact} %>  
  <p><%= submit_tag 'Update' %></p>

Page composition is managed using layouts. Each entity has its own controller, and each controller has its own layout. Here is a snippet from app/views/layouts/contacts.html.erb:

            <td id="leftnav" width="200">
                <%= render "shared/leftnav" %>
            </td>
            <td id="body" valign="top">
                <%= yield  %>
            </td>

This defines the layout for all the Contact CRUD pages... what about the rest of the pages? How can they all use the same layout? The answer it simply to go into each of the other controllers (e.g. comments_controller.rb) and at the top write:

layout 'contacts'

class Contact < ActiveRecord::Base
  has_many :comments, :order => "created_at desc"
  ...
end

Next: the Controller class. This is the biggest chunk of code. It contains a method for each possible action on the entity. In contacts_controller.rb, the default action is to list all the contacts in the database:

  def index
    @contacts = Contact.find(:all)
    
    respond_to do |format|
      format.html # index.html.erb
      format.xml  { render :xml => @contacts }
    end
  end

The method that is called in the controller depends on how URLs are mapped in config/routes.rb. Here is a sample line:

map.connect 'contacts/change/:id', :controller => 'contacts', :action => 'update'

<%= error_messages_for :contact %>

<%= file_field_tag "photo" %>

save_file(params[:photo], @contact)

def save_file(file, contact)
  if not file.empty?
    file_name = file.original_filename
    sanitize_filename(file_name)
    File.open("#{RAILS_ROOT}/public/resources/images/#{file_name}", "wb") do |f| 
      f.write(file.read)
      contact.photo_uri = file_name
    end
  end
end

def index
  # show login screen
end

def login
  if session["user"] = User.authenticate(params["username"], params["password"])
    redirect_to :controller => "contacts" 
  else
    redirect_to :action => "index" 
  end
end

def self.authenticate(name, password)
  find(:first, 
    :conditions => [ "username = '%s' AND password = '%s'", name, password ]
  )
end

class ContactTest < ActiveSupport::TestCase
  def test_crud
    james = Contact.new(
        :first_name => "James", 
        :last_name => "Mccabe", 
        :priority => 5, 
        :phone_nums => "303233443", 
        :email => "jamesc@oranda.com", 
        :web_page => "http://www.oranda.com", 
        :photo_uri => "JamesMcCabe.jpg")
    assert james.save
    contact = Contact.find(james.id)
    assert_equal(james.first_name, contact.first_name)
    contact.last_name = "McCabe"
    assert contact.save
    assert contact.destroy
  end
end

Next is a functional test class for the contact controller. All it does is test that the front page can be loaded after log in. Normally of course, there would a lot more tests.

class ContactsControllerTest < ActionController::TestCase
  
  def test_should_get_index
    login_admin
    get :index
    assert_response :success
    assert_not_nil assigns(:contacts)
  end
  
  def login_admin
    controller_bak = @controller
    @controller = LoginController.new
    post :login, :username => "admin", :password => "admin"
    @controller = controller_bak
  end
end

Rails comes with its own server -- WEBrick -- and you can use this to test development, test, and production versions of your application. However, it is now also possible to WAR up the webapp and run it on a Java container like Tomcat. JRuby is a Ruby interpreter written in Java and the Goldspike plugin has been built on JRuby to transform Ruby code into Java. You generally need to install the ActiveRecord-JDBC gem and then use Goldspike to create the WAR like this:

rake war:standalone:create

A full set of instructions for using Goldspike is here. The process is still a bit involved, so a gem called Warbler exists to streamline the process. However my experience was that on both Linux and Windows, there are some problems with Warbler (e.g. your RAILS_ROOT gets changed relative to your resources, dislocating things). So Goldspike seems to be still a more stable solution.

Ruby on Rails prides itself on its usability and speed of development. In a 2005 article, Curt Hibbs famously claimed that Ruby on Rails gives 10 times greater productivity than a typical Java framework. It was good to provoke debate, but I would say the real figure is more like 2 than 10: it took me about half as long to develop the sample application in Ruby as in Struts or JSF. It's still an impressive result. Most of the extra features like file upload and authentication were either available out-of-the-box or fairly easy to track down. One use for RoR could be as a rapid prototyping tool, helping to flesh out a specification. It helps of course that Ruby is interpreted meaning that you can just make your changes in the code and see the effects immediately.

One complaint is that when Rails 2.0 came out there were a lot of changes, so that broke a lot of the tutorials and casual code that developers google for. Of course there have been a lot of improvements to Rails, including the release of a faster server (Mongrel as opposed to the old WEBrick).

Furthermore Ruby on Rails is not a flawless piece of software. For example, as of writing sometimes if you change the database account details in database.yml, you will inexplicably get the error:

Access denied for user: ‘root@localhost’ (Using password: NO)