Fast-track Apps Development

Developing a Web application based on database has never been this easy. Ruby
on Rails is a solution that speeds up the development process by providing a
skeletal code framework for application development. It is an Open Source
project written in Ruby, while Ruby itself is a pure object oriented programming
language. Rails provides a framework for developing web-based database driven
application. An application developed with Ruby on Rails is based on
Model-View-Controller (MVC) architecture. Faster application development is
possible as Rails follows two principles, viz, 'Don't Repeat Yourself' (DRY) and
'Convention over Configuration' (CoC). In this article, we will explore how Ruby
on Rails can be used for faster Web-app development and seeing these principles
in action.

Setup and configuration

We have carried the Ruby installer on this month's PCQ Professional CD. It
comes with the RubyGems package manager. You can install the Rails framework
either by installing it from within Ruby by calling a remote installation
command or by installing the InstantRails package. To install Rails, we used
RubyGems package manager. From the command prompt, we entered the following
command:

gem install rails --remote

During installation, RubyGems downloads all the libraries that Rails depends
upon and for each dependency it prompts before downloading. So press 'Y' (Yes)
for each of the dependencies. The other method is to extract the InstantRails
package and use the InstantRails.exe to start up with the development.

App development

We will build an application based on MySQL database. The application will
be for books management in a library, whereby each book will be placed under a
specific category. So lets create a database 'pcqrubydemo' and under that create
two tables-Categories and Books.

As Rails is an application development framework, it creates the basic
structure needed for the application. Another convention that Rails follows is
that the name of the application and that of database should be same, so the
application name will be 'pcqrubydemo'. For Rails to create the structure we
will first make a directory called Rails Root Directory. From the command
prompt, we will navigate to this directory and give following command:

Rails pcqrubydemo

Here, a subdirectory 'pcqrubydemo' is created, which contains the complete
directory tree of folders and files for the application. Before moving on to the
application development, let's just look at the subdirectories that were created
for the application. As Rails is based on Model-View-Controller paradigm, it
uses the same to organize the source code.

* app/controllers: Controllers handles Web request from a user. All
controller classes are placed in this subdirectory.

* app/views: It holds HTML/JSP pages which are used for data input and
information display to user.

* app/models: This holds classes that model and wrap the data for
application's database.

Once you've created your database, you need to run the Scaffold command in Ruby on Rails to generate a framework for each table

Now, as our database and empty application are ready, we will start building
a framework for the application based on the database. For this we need to edit
the database configuration settings of the application. First, we need to change
the database name, username, password and host in the file 'database.yml'
located in the config directory under the main application directory, ie, 'pcqrubydemo'.
After setting up the database configuration, we can instruct Rails to build up
the framework based on the database tables. As Rails is based on Convention over
Configuration principle, i.e., by establishing a standard naming convention the
framework will develop the relevant code. This means the classes and methods
will be generated by the framework based on the table and column names. These
generated code structures are called 'scaffolding', and the term suggests, it
provides the outer support to the application. So to generate the scaffolding
for the Categories table, we will use the following command:

ruby script\generate scaffold category category

When you install Rails through remote install call, the dependencies are automatically downloaded

This will instruct Rails to construct the scaffolding for the application, ie,
the code structure related to the Categories table. The convention that Rails
follows is of singular model class name mapping to plural database table names.
In our case, it is category mapping to Categories table and book mapping to
Books table. As per the MVC architecture, the code generated will contain the
model, view and controllers files. Rails names the model file as category.rb and
places that under app/models folder. Same way, the controllers file,
category_controller.rb, is generated and placed under app/controllers
subdirectory of the application root folder. The HTML pages for showing insert
and delete of the database entries are also created under app/views folder.
Similarly, we will also create the scaffolding of the application based on books
table by following command:

ruby script\generate scaffold book book

This will generate the model and controller classes for the books table and
also generate the views regarding the table. Now, we have the application ready
to work on.

The listing of different categories and the page showing the category selection for the new book creation page

Testing the application

To see how Rails has developed the application, we first need to start the
built-in webserver WEBrick. To start it, we use following command from the
application's root directory 'pcqrubydemo':

ruby script/server

In the browser window, browse to http://localhost:3000/category. This will
open a page from where we can view, create, edit and insert a category into the
database. Similarly, if you suffix the same URL with book, it will set the page
to display the books list. Both pages show links to create, read, update and
delete entries from both the database tables. Rails has created the relevant
code structure for these functions and eliminated the work a developer puts in
to code for those functions. For entering a new book, we do not have option to
choose the category for that book. Now to put the category selection option, we
just need to modify model definition for category and book. In category.rb, we
will define the relationship that exists between Categories and Books table.

class Category < ActiveRecord::Base

has_many :books

end

As just one category can be assigned to a book, we need to modify the class
Book. We will add following code that will ensure this.

class Book < ActiveRecord::Base

belongs_to :category

end

To give the selection option to the user, we'll modify some Rails generated
view code related to Book class. Since Rails is based on 'Don't Repeat Yourself'
principle, we have a partial form created by Rails that corresponds to both New
and Edit methods. We just need to modify the partial form and the changes get
reflected on New and Edit views of the Book class. The following code snippet
will show the category selection option on the New book creation page:

for="book_category_id">Category


<%= select("book", "category_id", Category.find(:all).collect {|c| })
%>

To view the category selection option, first restart the WEBrick server. When
we browse to new Book page we view the Category Selection option there. Now to
make the pages more appealing, we can modify the HTML tags and put the retrieved
data into a table format.

Conclusion

As you can see, Ruby on Rails can be very helpful for creating Web
applications that are database driven, and the best thing is that it requires
little coding only.