RubyonRails:AnIntroduction

JA-SIG Summer Conference 2007

Michael Irion
The University of Tulsa

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

OverviewofRubyonRails
Ruby is the programming language used to
manipulate the framework
Rails is the framework that provides the necessary
infrastructure
Rails is written in Ruby

RubyFeatures
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

DuckTypinginRuby
Objects are dynamic, and their types are determined
at runtime
The type of a Ruby object is much less important
than its capabilities
If a Ruby object walks like a duck and talks like a
duck, then it can be treated as a duck

RailsPhilosophy
Convention over configuration (no XML)
Dont Repeat Yourself (DRY)
Rails is opinionated

RailsArchitecture
Rails applications are implemented using the ModelView-Controller (MVC)
Model - ActiveRecord
View - ActionView
Controller - ActionController

StartingtheBookmarksApplication
Generate application
> rails bookmarks

DirectoryLayout
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

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

RailsEnvironmentModes
Rails runs in different modes, depending on the
parameters given to the server on startup. Each
mode defaults to its own database schema
Development (verbose logging and error messages)
Test
Production

StartingRails
> cd /directorypath/bookmarks
Start the server
> ruby script/server start
Default environment is development
Default port is 3000
http://127.0.0.1:3000

WelcomeAboardNowWhat?
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

MappingURLstoControllersandActions
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)

EditingtheController
def sayit
render :text => "<h2>Hello World!</h2>"
end

NowforanactualBookmark
Edit config/database.yml
development:
adapter: mysql
database: bookmarks_development
username: username
password: password
host: localhost

CreatetheDatabase
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.

BookmarkModel
Our bookmark model will (initially) need two
properties
URL
Title

ScaffoldingforBookmarks
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

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

BookmarksMigration
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

RunningtheMigration
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

BookmarksTableID
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

BookmarksController
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

MappingURLstoControllersandActions
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)

BookmarksModelDontRepeatYourself
No getters/setters. Rails uses information from the
database.
class Bookmark < ActiveRecord::Base
end

BookmarksView
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 %>

ConventionoverConfiguration
Bookmark model automatically looks for a table in
the database with a plural form of its name.
(bookmarks)
The Bookmarks controller automatically renders the
template located in views according to the controller
name and the action (views/bookmarks/index.rhtml)

AjaxHelpers
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

AJAXAutocomplete
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 %>

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

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

AssociationsAddingCategoriestoBookmarks
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

TypesofAssociations

has_one
belongs_to
has_many
has_and_belongs_to_many
has_many :model1, :through => :model2

ChangestotheDatabase
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

AlterBookmarksMigration
def self.up
add_column :bookmarks, :category_id, :integer
end
def self.down
remove_column :bookmarks, :category_id
end
>rake db:migrate

TypesofAssociations

has_one
belongs_to
has_many
has_and_belongs_to_many
has_many :model1, :through => :model2

DatabaseRelationships
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

AssociationsModelCode
class Bookmark < ActiveRecord::Base
validates_presence_of :url, :title
belongs_to :category
end
class Category < ActiveRecord::Base
has_many :bookmarks
end

AssociationsControllercode
def edit
@bookmark = Bookmark.find(params[:id])
@categories = Category.find(:all)
end

AssociationsViewCode
<p>
<b>Category</b><br />
<%= collection_select('bookmark', 'category_id',
@categories, 'id', 'name') %>
</p>

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

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