Ruby on Rails is an open-source web application framework that uses the Model-View-Controller pattern. It uses Ruby as its programming language. Rails provides conventions for building database-backed web applications, including generating scaffolding for basic CRUD operations. The document demonstrates how to generate a Rails application, scaffold a Bookmarks model, add validations and associations to Categories, and integrate Ajax functionality. Rails emphasizes conventions over configuration for directory structure and default actions.

1. Ruby on Rails: An Introduction
JA-SIG Summer Conference 2007
Michael Irion
The University of Tulsa

2. What is Ruby on Rails (RoR)?
• Ruby on Rails is an open-source, full-stack
framework for developing database-backed web
applications according to the Model-View-Control
pattern

3. Overview of Ruby on Rails
• Ruby is the programming language used to
manipulate the framework
• Rails is the framework that provides the necessary
infrastructure
• Rails is written in Ruby

4. Ruby Features
• Ruby is an interpreted language (No compile step
necessary)
• Ruby is an Object Oriented language.
• Everything is an object (No primitives)
• Ruby draws from Perl, Smalltalk, and Lisp

5. Duck Typing in Ruby
• Objects are dynamic, and their types are determined
at runtime
• The type of a Ruby object is much less important
than it’s capabilities
• If a Ruby object walks like a duck and talks like a
duck, then it can be treated as a duck

6. Rails Philosophy
• Convention over configuration (no XML)
• Don’t Repeat Yourself (DRY)
• Rails is opinionated

7. Rails Architecture
• Rails applications are implemented using the Model-
View-Controller (MVC)
• Model - ActiveRecord
• View - ActionView
• Controller - ActionController

8. Starting the Bookmarks Application
• Generate application
> rails bookmarks

9. Directory Layout
• Rails applications have a common directory structure
• /app - the MVC core
/controllers
/helpers - provides extra functionality for views
/models
/views/nameofcontroller - templates for controller
actions

10. Directory Layout
/components - will be deprecated
/config - database, route and environment configuration
/db - database schema and migrations
/lib - functions that don’t map to MVC
/log
/public - static web resources (html, css, javascript etc.)
/script - rails utilities
/test - tests and fixtures
/tmp
/vendor - 3rd party plugins

11. Rails Environment Modes
• Rails runs in different modes, depending on the
parameters given to the server on startup. Each
mode defaults to it’s own database schema
• Development (verbose logging and error messages)
• Test
• Production

12. Starting Rails
• > cd /directorypath/bookmarks
• Start the server
> ruby script/server start
• Default environment is development
• Default port is 3000
• http://127.0.0.1:3000

13. Welcome Aboard - Now What?
• Hello world seems appropriate
>ruby script/generate controller hello
exists app/controllers/
exists app/helpers/
create app/views/hello
exists test/functional/
create app/controllers/hello_controller.rb
create test/functional/hello_controller_test.rb
create app/helpers/hello_helper.rb

14. Mapping URLs to Controllers and Actions
• http://127.0.0.1:3000/hello/sayit
• http://127.0.0.1:3000 - address and port of the
webserver
• hello - name of the controller
• sayit - name of the action (method in controller)

15. Editing the Controller
def sayit
render :text => "<h2>Hello World!</h2>"
end

16. Now for an actual Bookmark
• Edit config/database.yml
development:
adapter: mysql
database: bookmarks_development
username: username
password: password
host: localhost

17. Create the Database
• This step depends on the database and dba tool of
your choice. Create a new schema/dbname for
bookmarks_development, and assign rights for the
user you listed in database.yml.

18. Bookmark Model
• Our bookmark model will (initially) need two
properties
• URL
• Title

19. Scaffolding for Bookmarks
• Rails can generate all the basic CRUD operations
for simple models via scaffolding.
• Scaffolding is temporary way to get applications
wired quickly.
> ruby script/generate scaffold_resource bookmark
url:string title:string

20. Migrations
• Rails uses migrations to version the database.
• Rails tries to minimize SQL at every opportunity
• Migrations are automatically created whenever you
generate a new model
• Migration files are located in db/migrations
• The version number is stored in a table called
schema_info

21. Bookmarks Migration
located in db/migrate/001_create_bookmarks.rb
class CreateBookmarks < ActiveRecord::Migration
def self.up
create_table :bookmarks do |t|
t.column :url, :string
t.column :title, :string
end
end
def self.down
drop_table :bookmarks
end
end

22. Running the Migration
• Rake is the general purpose build tool for rails,
much like make, or ant. It has many functions, one
of which is to control migrations.
>rake db:migrate
• Now the table has been created

23. Bookmarks Table ID
• Bookmarks table has the following fields - id, url,
and title
• Where did the id field come from?
• Convention of configuration - Rails automatically
creates an id field for each new table and uses it as
the primary key

24. Bookmarks Controller
The /app/controllers/bookmarks.rb default action:
def index
@bookmarks = Bookmark.find(:all)
respond_to do |format|
format.html # index.rhtml
format.xml { render :xml => @bookmarks.to_xml }
end
End

25. Mapping URLs to Controllers and Actions
• http://127.0.0.1:3000/bookmarks/
• http://127.0.0.1:3000 - address and port of the
webserver
• hello - name of the controller
• / - name of the action (blank maps to the index
action)

26. Bookmarks Model - Don’t Repeat Yourself
• No getters/setters. Rails uses information from the
database.
class Bookmark < ActiveRecord::Base
end

27. Bookmarks View
Located in views/bookmarks/index.rhtml
<% for bookmark in @bookmarks %>
<tr>
<td><%=h bookmark.url %></td>
<td><%=h bookmark.title %></td>
<td><%=h bookmark.description %></td>
<td><%= link_to 'Show', bookmark_path(bookmark) %></td>
<td><%= link_to 'Edit', edit_bookmark_path(bookmark) %></td>
<td><%= link_to 'Destroy', bookmark_path(bookmark), :confirm => 'Are you
sure?', :method => :delete %></td>
</tr>
<% end %>

28. Convention over Configuration
• Bookmark model automatically looks for a table in
the database with a plural form of it’s name.
(bookmarks)
• The Bookmarks controller automatically renders the
template located in views according to the controller
name and the action (views/bookmarks/index.rhtml)

29. Ajax Helpers
• Rails allows you to program many AJAX calls in
ruby, instead of writing javascript directly
• Script.aculo.us and Prototype libraries are included
• A quick example. Autocomplete for text boxes

30. AJAX Autocomplete
Add to Bookmarks controller
auto_complete_for :bookmarks, :url
Add to views/bookmarks/edit.rhtml
<%= text_field_with_auto_complete :bookmark, :url %>
In views/layouts/bookmarks.rhtml, add
<%= javascript_include_tag :defaults %>

31. Validations
• Rails has a number of validation helpers that can be
added to the model.
class Bookmark < ActiveRecord::Base
validates_presence_of :url, :title
end

32. Validations
• validates_presence_of
• validates_length_of
• validates_acceptance_of
• validates_confirmation_of
• validates_uniqueness_of
• validates_format_of
• validates_numericality_of
• validates_inclusion_in
• validates_exclusion_of
• validates_associated :relation

33. Associations - Adding Categories to Bookmarks
• The bookmarks are working great, but it would be
nice if we could group them by category
• Rails uses associations to build relationships
between tables
• Associations are independent of database foreign
key constraints

34. Types of Associations
• has_one
• belongs_to
• has_many
• has_and_belongs_to_many
• has_many :model1, :through => :model2

35. Changes to the Database
• A new categories table needs to be created
• A category_id field needs to be added to the bookmarks
table
> ruby script/generate scaffold_resource category name:string
• This creates the all the scaffolding and the migration
db/migrate/002_create_categories.rb
• Note the category table is pluralized as categories.
>ruby script/generate migration alter_bookmarks_add_category_id
• This creates
db/migrate/003_alter_bookmarks_add_category_id.rb

36. Alter Bookmarks Migration
def self.up
add_column :bookmarks, :category_id, :integer
end
def self.down
remove_column :bookmarks, :category_id
end
>rake db:migrate

37. Types of Associations
• has_one
• belongs_to
• has_many
• has_and_belongs_to_many
• has_many :model1, :through => :model2

38. Database Relationships
• Parent (or Master) models that have collections of
other models use the has_many relationship
• Child (or Detail) models contain the id field of their
parent record and they use the belongs_to
relationship

39. Associations Model Code
class Bookmark < ActiveRecord::Base
validates_presence_of :url, :title
belongs_to :category
end
class Category < ActiveRecord::Base
has_many :bookmarks
end

40. Associations Controller code
def edit
@bookmark = Bookmark.find(params[:id])
@categories = Category.find(:all)
end

41. Associations View Code
<p>
<b>Category</b><br />
<%= collection_select('bookmark', 'category_id',
@categories, 'id', 'name') %>
</p>

42. Tools
• Textmate (Mac OS X)
• RadRails (Eclipse plugin) www.radrails.org
• Other commercial and opensource IDEs are being
made available

43. Resources
• Programming Ruby: The Pragmatic Programmers'
Guide - Second Edition
• Agile Web Development with Rails—Second
Edition
• Rails main site http://www.rubyonrails.com
• My email: michael-irion@utulsa.edu