Introduction
This article provides an introduction to Ruby on Rails. Ruby is a programming language that is interpreted and Rails is a framework written on top of Ruby for writing Web Applications. The article starts with an introduction to Ruby with respect to the basic syntax usage and provides plenty of samples for illustrating conditional constructs and looping constructs. Also the advanced concepts like Classes /Objects and modules will also explained with examples. The later section of the article explains Rails and it starts with the basics of the Model View Controller Architecture for writing Rails application.
Ruby Introduction
Ruby is an interpreted language that is easy to use and contains various object oriented features. In this section, we will see the basics of Ruby like variable declaration, conditional constructs, looping, classes/object etc. Readers who are new to ruby can be benefitted with the usage of Ruby in this section.
Hello Word
The following code snippet shows how to declare a variable and store some value in it. It later displays the variable’s value in the console.
hello = "Hello World" puts hello
Getting input from user
As seen in the last example, the function puts() can be used to output the content to the console and the method gets() is used to obtain the input from the user.
puts("Enter a number");
number = gets();
puts("The number entered is #{number}");
Also have a look at how the variable’s value is used within strings. The pattern used will be ‘#{variableName}’ when this variable is used within double-quotes.
Declaring Arrays
Ruby supports the declaration of an array through the following syntax. The index of array location starts from zero.
my_array = ["one", "two"];
puts my_array[1];
puts "Element at location 0 is #{my_array[0]}";
puts "Length of the array is is #{my_array.length}"
fruits = Array.new;
fruits[0] = "Apple";
fruits[1] = "Orange";
fruits[2] = "Grapes";
puts "Length of array is #{fruits.length}"
The length of the array – which tells the number of elements that an array is holding currently can be determined by calling ‘arrayObject.length’. Another way for declaring a dynamic array is to call ‘Array.new’ and the populate the elements with the normal syntax.
Conditional constructs
The following code snippet illustrates the usage of conditional constructs in Ruby. Note the usage of ‘if’, ‘elsif’ and ‘end’ and the usage of AND operations.
pizza_price = 80; if (pizza_price < 100) puts "Price is less"; elsif (pizza_price > 100 && pizza_price <200) puts "Price is medium"; else puts "Price is large" end
The above code displays the price based on various ranges just to illustrate the usage of conditional constructs.
Looping
The usage of ‘for’ loop is given below. The code declares a array of programming languages and then iterates over the loop using ‘for’ loop.
languages = ["C", "C++", "Java", ".NET"];
for language in languages
puts "Language is #{language}";
end
Function
Functions are used to define re-usable logic and it can be invoked multiple times. The usage of functions in Ruby is supported through ‘def’ keyword followed by the function name.
def multiply(a, b)
result = multiply_with_return(a, b);
puts("Inside Multiply without return #{result}");
end
def multiply_with_return(a, b)
puts("Multiplying #{a} with #{b}");
result = a * b;
return result;
end
value = multiply_with_return(10, 10);
puts("Result from multiplying with return is #{value}");
multiply(5, 3);
Functions can support parameters also. In the above code, we have defined functions ‘multiply’ and ‘multiply_with_return’. The first function uses the parameters passed by the caller and displays the result within the function definition. The second function, after calculating the result, returns the result to the caller.
Classes and Objects
In this section, we will see the usage of classes and objects in Ruby. As known, class represents the template for creating objects which contains the combination of related operations and data.
class Arithmetic
def initialize(a, b)
@a = a;
@b = b;
end
def add()
puts("Addition of #{@a} and #{@b} is #{@a + @b}");
end
def sub()
puts("Subtraction of #{@a} and #{@b} is #{@a - @b}");
end
def multiply()
puts("Multiplication of #{@a} and #{@b} is #{@a * @b}");
end
def divide()
puts("Dividing #{@a} with #{@b} results is #{@a / @b}");
end
end
one_two_arithmetic_object = Arithmetic.new(1, 2);
one_two_arithmetic_object.add();
one_two_arithmetic_object.sub();
one_two_arithmetic_object.multiply();
one_two_arithmetic_object.divide();
In the above code, we declare a class called ‘Arithmetic’ and supports related functions like ‘add’, ‘sub’, ‘multiply’ and ‘divide’ which does the basic mathematical operations. Callers can create objects for this class and can invoke the various available operations supported by this class. There is a special method available in the class declaration called ‘initialize’ which will be invoked automatically when an object is created for this class.
Also note the syntax for creating an object for the class. It is the class name followed by ‘new’. The parameters following the ‘new’ keyword are the initialization parameters. Here we have passed the initialization arguments ‘1’ and ‘2’ and hence the function ‘initialize’ will be called with these arguments.
Modules
Modules in ruby are used to group larger number of operations together. In the below example code, we have created two modules called ‘Number_Operations’ and ‘String_Operations’. Note that these modules are defined in files ‘module_number_operations.rb’ and ‘module_string_operations.rb’.
module Number_Operations
def Number_Operations.display()
puts "Contains the utility operations related to numbers";
end
end
module String_Operations
def String_Operations.display()
puts "Contains the utility operations related to string";
end
end
The below code represents the usage of the modules, and for importing the modules within the client applications, the syntax ‘require ‘, should be used. Then the operations are used through the syntax ‘ModuleName.operationName’.
require 'module_string_operations' require 'module_number_operations' puts String_Operations.display(); puts Number_Operations.display();
Rails Framework
Ruby is an interpreted programming language and Rails is a framework written on Ruby for building web applications. Rails prefer the approach on convention over configuration which means that when you create a web application using Rails framework, the supporting tools will provide a lot of sensible defaults so that developers can go and hook in only their customizations instead of writing everything from scratch. Also one can see the how faster it will be in developing web applications through Rails when compared with other popular Web application frameworks.
Rails framework follows the pattern of MVC which stands for Model-View –Controller architecture which is a popular standard/pattern for building web applications. When a client, typically a browser is making a request, it is the Controller which will be handling the request initially. Based on various request parameters, it will identity the type of request and forwards the request to the appropriate Model objects. There can be multiple Model objects that can be maintained in a Web application and it is the Controller’s responsibility to choose a particular Model object based on various parameters. The Model object represents the action part as well as the data handling part. It may hit the database or can perform any business actions with respect to the context and finally build the data suitable for getting it displayed.
In this section we will create a Rails starter application that will display some static text in the browser upon client’s request. Rails come with plentiful of utilities that make the developmental tasks easier. Have a look at the following command which will create a web application. The name of the application is ‘hello’ and the ‘new’ subcommand indicates that we want to create a new application.
rails new hello –O
Executing the above command will produce an output similar to the following.
create
create README
create Rakefile
create config.ru
create .gitignore
create Gemfile
create app
create app/controllers/application_controller.
create app/helpers/application_helper.rb
create app/views/layouts/application.html.erb
create app/mailers
create app/models
create config
create config/routes.rb
create config/application.rb
create config/environment.rb
create config/environments
create config/environments/development.rb
create config/environments/production.rb
create config/environments/test.rb
create config/initializers
create config/initializers/backtrace_silencers
create config/initializers/inflections.rb
create config/initializers/mime_types.rb
create config/initializers/secret_token.rb
create config/initializers/session_store.rb
create config/locales
create config/locales/en.yml
create config/boot.rb
create db
create db/seeds.rb
create doc
create doc/README_FOR_APP
create lib
create lib/tasks
create lib/tasks/.gitkeep
create log
create log/server.log
create log/production.log
create log/development.log
create log/test.log
create public
create public/404.html
create public/422.html
create public/500.html
create public/favicon.ico
create public/index.html
create public/robots.txt
create public/images
create public/images/rails.png
create public/stylesheets
create public/stylesheets/.gitkeep
create public/javascripts
create public/javascripts/application.js
create public/javascripts/controls.js
create public/javascripts/dragdrop.js
create public/javascripts/effects.js
create public/javascripts/prototype.js
create public/javascripts/rails.js
create script
create script/rails
create test
create test/performance/browsing_test.rb
create test/test_helper.rb
create test/fixtures
create test/functional
create test/integration
create test/unit
create tmp
create tmp/sessions
create tmp/sockets
create tmp/cache
create tmp/pids
create vendor/plugins
create vendor/plugins/.gitkeep
As you can see, the execution of the command creates a standard directory layout containing lots of files and folders. Since Ruby applications are MVC based, the folders ‘app/controllers’, ‘app/models’ and ‘app/views’ contain the files related to Controllers, Models and Views respectively. The ‘db’ folder contains information related to database for various environments like development, testing and production. The ‘configuration’ folder represents the application’s configuration information such as request-action mapping and other dependencies. Test cases related files come under the ‘test’ directory. The ‘public’ directory contains the viewable files that can be accessed directly by the client like html, images etc.
To launch the ‘hello’ application, go to the directory ‘hello’ (this new directory was created in the previous step) and type the following. Ruby installation comes with a pre-configured web server called ‘WEBrick’ and the following command starts the web server in the default port number ‘3000’.
rails server => Booting WEBrick => Rails 3.0.0 application starting in development on http://0.0.0.0:3000 => Call with -d to detach => Ctrl-C to shutdown server [2010-10-09 00:36:29] INFO WEBrick 1.3.1 [2010-10-09 00:36:29] INFO ruby 1.9.2 (2010-08-18) [i386-mingw32] [2010-10-09 00:36:29] INFO WEBrick::HTTPServer#start: pid=7816 port=3000
As soon as the server is started, the application can be accessed through the url ‘http://localhost:3000’. This shows the default page which is located in the folder ‘/public/index.html’. This application really doesn’t do anything other than creating the basic template for a web application with a default page. Let us add the basic functionality of creating a controller and a view. The controller takes the responsibility of intercepting the client’s request and it will redirect the control to the view. The view takes the control and the content of the view will be displayed to the browser. The following screen-shot will be displayed when the browser is accessed with the url ‘http://localhost:3000’.
Execute the following command for creating controller and an action. The ‘controller’ subcommand takes the controller name and the action name as arguments. Here the name of the controller is ‘hello’ and the name of the action is ‘hello_action’
rails generate controller hello hello_action
create app/controllers/hello_controller.rb
route get "hello/hello_action"
invoke erb
exist app/views/hello
create app/views/hello/hello_action.html.erb
invoke test_unit
identical test/functional/hello_controller_test.rb
invoke helper
identical app/helpers/hello_helper.rb
invoke test_unit
identical test/unit/helpers/hello_helper_test.rb
The execution of the command creates the controller file ‘hello_controller.rb’ in the folder ‘/app/controllers’. Here is the listing for generated ‘hello_controller.rb’ file.
class HelloController < ApplicationController def hello_action end end
In the above code, the ‘HelloController’ class inherits from the base controller Application. A controller can have multiple actions and one such action provided is ‘hello_action’. This makes the application to be accessed through this way ‘/hello/hello_action’. We haven’t provided an implementation for the action and the default implementation is to look for a view file in the directory ‘/app/views//.html.erb’. The generator is sensible enough to create the file ‘hello_action.html.erb’ in the folder ‘/app/views/hello’. The content of this view file is given below,
<h1>Hello</h1> <p>This is a starter application to setup things using Rails framework
This is a starter application to setup things using Rails framework
Before accessing the application, delete the file ‘index.html’ present in the ‘/public’ directory, the presence of this file overrides the settings. Now accessing the application through the url ‘http://localhost:3000/hello/hello_action’ will display the following view.
Creating Multiple Controllers/Actions and Views
Now that we have a basic understanding on rails, we will extend the above concepts in creating an application that has multiple controllers, actions and views. This sample will illustrate this example by providing the option on displaying the home page of contacts and messages. We will start creating the application by executing the following command,
rails new lister –O
This creates an application called ‘lister’. Change to the directory of ‘lister’. Now we want to create a controller for ‘contacts’ which will control the home page display and the listing for all contacts. Execute the following command for creating the controller called ‘contacts’.
rails generate controller contacts contacts_home contacts_view
Other than creating a controller called ‘contacts’, the above command will create two more actions called ‘contacts_home’ and ‘contacts_view’. The execution of the above command would result in an output similar to the following.
create app/controllers/contacts_controller.rb
route get "contacts/contacts_view"
route get "contacts/contacts_home"
invoke erb
create app/views/contacts
create app/views/contacts/contacts_home.html.erb
create app/views/contacts/contacts_view.html.erb
invoke test_unit
create test/functional/contacts_controller_test.rb
invoke helper
create app/helpers/contacts_helper.rb
invoke test_unit
create test/unit/helpers/contacts_helper_test.rb
The definition of the ‘contacts_controller’ is shown below. Note that other than the regular controller definitions, two action definitions are added to the file.
class ContactsController < ApplicationController def contacts_home end def contacts_view end end
The action ‘contacts_home’ is used to display the home page view for contacts. Here is view definition for ‘contacts_home’ found in ‘/app/views/contacts/contacts_view.html/erb’.
<html> <head> <title>Contacts Home</title> </head> <body> <h1>Contacts Home</h1> <br> <br> <h1>This is the home page for Contacts</h1> <br> <%= link_to "Go to Contacts View.", :action => "contacts_view" %> <br> </body> </html>
Note that the above view page defines the link to the contacts view and the usage of ruby scriptlets in the above between the symbols ‘<#=’ and ‘%>’. A predefined element ‘link_to’ is defined containing the action attribute expressed as ‘action’. The display name given to the action is ‘Go to Contacts View’. The action name is given as ‘contacts_view’, note that this action name should match the action name which is defined in the controller. The inclusion of this scriptlet will introduce a link in the html page and by clicking on the link, the user will be redirected to the ‘contacts_view’ page.
Access to the link ‘http://localhost:3000/contacts/contacts_home’ will display the following page in the browser.
The code listing for ‘contacts_view’ is given below. Note that this view page has some hard-coded contact entries to get them displayed in the browser. Also the view page includes a reference to the contacts home page.
All Contacts
| Name | Number |
|---|---|
| 12345 | David |
| 67890 | Jones |
| 13469 | Lisa |
<html>
<head>
<title>Contacts View</title>
</head>
<body>
<h2>All Contacts</h2>
<table border = "1">
<tr>
<th>Name</th>
<th>Number</th>
</tr>
<tr>
<td>12345</td>
<td>David</td>
</tr>
<tr>
<td>67890</td>
<td>Jones</td>
</tr>
<tr>
<td>13469</td>
<td>Lisa</td>
</tr>
</table>
<br>
<%= link_to "Go to Contacts home.", :action => "contacts_home" %>
</body>
</html>
Access to the link ‘http://localhost:3000/contacts/contacts_view’ will display the following page in the browser.
Execute the following command for creating the controller ‘messages’ with two actions ‘messages_home’ and ‘messages_view’.
rails generate controller messages messages_home messages_view
The source code listing for messages_controller ,’messages_home’ and ‘messages_view’ is not included here and it will look similar to the one that we had already seen before. The URLs for accessing the home page and the listing for messages are ‘http://localhost:3000/messages /messages_home’ and ‘http://localhost:3000/messages /messages_view’ respectively.
Conclusion
This article provided an introduction to Ruby on Rails explaining the basics in writing Web applications using the Rails framework. Various code samples were discussed to illustrate the basics of Rails framework in writing controllers, actions and views.
Leave a Reply