The third talk I gave in December in Milwaukee at Bucketworks. See my blog at blog.mattgauger.com for more info and full blog posts.

1. What’s new and great in
Rails 3

2. Don’t worry!
All the links Text
shown will be
presented at the end of the
slides and on my blog.

3. There’s a lot to talk
about, so

4. This is a long
presentation

5. I wanted to do
something different than
list the changes in Rails 3

6. Allow me to introduce
you to someone.

7. This is Robin

9. “Robin would very much like to be a
kick-ass web developer, but has a hard
time keeping up with the buzzwords.”
-- Flickr description

10. He’s a web
developer

11. He uses Rails 2.3 at his job,

12. where they make state-of-the-art
TODO list web applications
(and fight crime)

13. His boss

15. Batman

16. Wants the team to
use Rails 3.

17. Because he heard it
is the new hotness.

18. Batman tries to stay hip
with the “web stuff”

19. Robin is already fairly
familiar with Rails

20. In this case, he’s going to
be starting from scratch

21. While it is possible to
upgrade from Rails 2.x to
Rails 3, we’re not going to.

22. This is merely a learning
exercise, so we’re skipping
the BDD/TDD for now, too.

23. Robin keeps up with
a few Rails blogs,

24. And he’s read that rvm
is what everyone is using

25. rvm is a way to install and
use different versions of
Ruby on the same machine

26. Robin uses Homebrew
on his Mac, so he types:

27. $ brew install rvm

28. Sidenote:
My recommendation would be to start
with Cinderella if you’re on a Mac

29. What comes with Cinderella?

30. • mysql, postgres, redis, memcached and
mongodb
•ruby (1.8.7) with rails and sinatra via
rvm gemsets. (& install Ruby 1.9 with rvm)
•python (2.7) with pip.
•node.js (0.2.0) with npm.
•erlang (R13B04) environment.
... and brew, and probably a lot more by
now.

31. With rvm, Robin can do this:

32. $ rvm install 1.9.2
$ rvm use 1.9.2

33. $ rvm list
rvm rubies
ruby-1.8.7-p248 [ x86_64 ]
=> ruby-1.9.2-p0 [ x86_64 ]

34. $ ruby -v
ruby 1.9.2p0 (2010-08-18 revision
29036) [x86_64-darwin10.4.1]

35. So now Robin is
rolling on Ruby 1.9.2

36. Next, he needs a gemset

37. A gemset is a collection of
gems, in this case that we’re
associating with a project

38. Robin knows this comes
in later, when he starts
using bundler in his app

39. $ rvm gemset create totodo
$ rvm ruby-1.9.2-p0@totodo

40. Now any gems he installs
will be on Ruby 1.9.2

41. And more importantly,
will be kept with his app.

42. Robin installs Rails 3.0.3

43. $ gem install rails -v 3.0.3

44. And the Heroku gem

45. $ gem install heroku

46. He creates a new app called
totodo (it’s a todo list!)

47. # Create a new Rails 3 app:
$ rails new totodo
$ cd totodo/

48. And grabs gems that
Rails needs with Bundler

49. # Use Bundler to install gems:
$ bundle install

50. Let’s look at Bundler

51. In Rails 2, Robin
would have to do this:

52. # Edit environment.rb:
config.gem "haml"
config.gem "sass"
# Then do
$ rake gems:install

53. In Rails 3 with Bundler:

54. # Edit the Gemfile:
source "http://rubygems.org"
gem "haml"
gem "sass"
# Then run:
$ bundle install

55. We can also use
groups for gems:

56. # Gemfile:
source "http://rubygems.org"
gem "haml"
gem "sass"
group :test,:development do
gem "webrat"
gem "rspec"
end
# Then go run:
$ bundle

57. Now webrat and rspec will
be installed and used, but
only in the environments listed

58. Moving on, we set
up git and heroku

59. # Set up git repo:
$ git init .
$ git add *
$ git commit -m “Initial commit of
bare Rails 3 project.”
# Create a new Heroku app:
$ heroku create
$ git push heroku master

60. Robin is all set to
develop

61. He’s is looking at the
files in his newly
created project,

62. and noticing some
differences

63. config/application.rb
(replaces config/environment.rb)

64. require File.expand_path('../boot', __FILE__)
require 'rails/all'
# If you have a Gemfile, require the gems listed there, including any gems
# you've limited to :test, :development, or :production.
Bundler.require(:default, Rails.env) if defined?(Bundler)
module Totodo
class Application < Rails::Application
# [With a lot of comments cleaned up]
# Configure generators values.
config.generators do |g|
g.orm :active_record
g.template_engine :haml
g.test_framework :rspec, :fixture => true
end
# Configure the default encoding used in templates for Ruby 1.9.
config.encoding = "utf-8"
# Configure sensitive parameters which will be filtered from the log file.
config.filter_parameters += [:password]
end
end

65. The important bit is

66. # Robin is going to use haml and rspec:
# Configure generators values.
config.generators do |g|
g.orm :active_record
g.template_engine :haml
g.test_framework :rspec
end

67. Next,

68. Robin needs a data model
for what he’s storing

69. Which is a TODO list item

70. What makes up a
TODO list item?

71. •ID
•Title (Text)
•Due Date (Datetime)
•Is it done? (Boolean)

72. Robin wants to use
$ script/generate
which he comfortable with

73. But there isn’t a
script/generate in Rails 3

74. # Inside his totodo project folder:
$ ls -al script/
total 8
drwxr-xr-x 3 robin staff 102 Dec 20 01:53 .
drwxr-xr-x 21 robin staff 714 Dec 20 01:55 ..
-rwxr-xr-x 1 robin staff 295 Dec 20 01:53 rails

75. Instead, everything goes
through the rails script

76. # Remember doing these commands?
$ script/generate something
$ script/server
$ script/console

77. # Replaced with:
$ rails generate something
$ rails g something #shorter form
$ rails server
$ rails s # shorter form
$ rails console

78. What Robin wants is
a scaffold

79. Again, he’s just learning
Rails 3 here, so a
scaffold will be fine.

80. $ rails generate scaffold Todo title:string
due_date:datetime done:boolean

81. $ rails generate scaffold Todo title:string due_date:datetime done:boolean
invoke active_record
create db/migrate/20101220080933_create_todos.rb
create app/models/todo.rb
invoke test_unit
create test/unit/todo_test.rb
create test/fixtures/todos.yml
route resources :todos
invoke scaffold_controller
create app/controllers/todos_controller.rb
invoke erb
create app/views/todos
create app/views/todos/index.html.erb
create app/views/todos/edit.html.erb
create app/views/todos/show.html.erb
create app/views/todos/new.html.erb
create app/views/todos/_form.html.erb
[and lots more output than this]

82. That’s a lot of
generated files

83. Robin wants to know
whether migrations are
different in Rails 3

84. So he looks in

85. db/migrate/20101220080933_create_todos.rb

86. class CreateTodos < ActiveRecord::Migration
def self.up
create_table :todos do |t|
t.string :title
t.datetime :due_date
t.boolean :done
t.timestamps
end
end
def self.down
drop_table :todos
end
end

87. That’s very similar to
what Robin is used to.

88. Robin runs the
migration.

89. $ rake db:migrate
(in /Users/robin/Projects/totodo)
== CreateTodos: migrating ==================================
-- create_table(:todos)
-> 0.0019s
== CreateTodos: migrated (0.0020s) =========================

90. Now, Robin wants to hook up
the routes to his new controller

91. He’s read that routes in
Rails 3 are different,

92. but he hasn’t seen them yet

93. He’s pleased to find
that they’re simple:

94. # in config/routes.rb our scaffold placed:
Totodo::Application.routes.draw do
resources :todos
end

95. Robin deletes the
public/index.html file and maps
the root path:

96. Totodo::Application.routes.draw do
root :to => 'todos#index'
resources :todos
end

97. And runs his dev server with
that nifty `rails s` command

99. Robin wants validations
on his model

100. A ToDo list item
should have a title

101. The syntax has
changed a little

102. class Todo < ActiveRecord::Base
validates :title, :presence => true
end

104. Robin has a very,
very basic app started

105. And a long way to
go with Rails 3

106. Robin has a little bit of
time during his lunch break

107. So he reads up on
the Merb project

108. 2006:
The Merb project was
started

109. At its start, Merb just
serves ERb templates
from Mongrel

110. Merb focuses on
essentials

111. Component
modularity

112. Extensible APIs

113. ORM/JS framework
agnostic

114. December 2008:
The Rails team announces
RoR and Merb will merge

115. Rails 3 is the result of
merging Merb and RoR

116. And represents a
significant rewrite of
most of Rails

117. Robin has stumbled
onto a blog post by

118. Yehuda Katz

120. Summarizing the
Merb+RoR merger
back in 2008

121. Rails will become
more modular

122. Rails will have better
performance

123. Rails 3 will have a
defined API, and a
test suite for that API

124. Rails will allow things like
DataMapper or Sequel
to be first-class ORMs

125. Rails 3 will continue
to embrace Rack

126. Reinvigorated, Robin
jumps back into dev

127. As he begins to modify
his controller, he runs into

128. ARel

129. (ActiveRelation)

130. Arel provides an
SQL abstraction

131. Using relational
algebra

132. Old and busted:

133. @users = User.find(:all, :conditions => {:approved => true})

134. New Hotness:

135. @users = User.where(:approved => true)

136. The Rails 2.x-style .find()
method queries the DB
immediately and returns an
array

137. The Arel-style .where()
method returns an
ActiveRecord::Relation

138. What can we do with
an ActiveRelation?

139. Add additional
parameters to the query

140. @users = User.where(:approved => true)
# If a params[:order] was passed in,
# add that condition to the query:
@users = @users.order(params[:order])
@users.each do |u|
...
end

141. @users = User.where(:approved => true)
# If a params[:order] was passed in,
# add that condition to the query:
@users = @users.order(params[:order])
@users.each do |u| # Query runs here!
...
end

142. We can even chain the last
page of code together:

143. User.where(:approved => true).order(params[:order])

144. Rails 2:
named_scope method

145. Rails 3:
scope keyword

146. # Rails 2:
class User < ActiveRecord::Base
named_scope :approved, :conditions => {:approved => true}
end
# Rails 3:
class User < ActiveRecord::Base
scope :approved, where(:approved => true)
end

147. There’s much, much more to Arel.
Read the documentation.

148. Next up, Robin discovers
that he can match any
Rack app to a route

149. Totodo::Application.routes do
match "/home", :to => HomeApp
end

150. In fact, this is a lot like
the routes we saw earlier

151. Totodo::Application.routes.draw do
root :to => 'todos#index'
match "/home", :to => HomeApp
end

152. 'todos#index'
here is really a full fledged
Rack application, too.

153. Routes are namespaced
inside your app.

154. # Instead of:
ActionController::Routing::Routes.draw do |map|
map.resources :todos
end
# You do:
Totodo::Application.routes do
resources :todos
end

155. The i18n gem brings in better
i18n support, but Robin isn’t
going to get into that right now.

156. How has our
Controller changed?

157. A simplified version of
what our scaffold
created would be:

158. class TodosController < ApplicationController
respond_to :html, :xml, :js
# GET /todos
# GET /todos.xml
def index
respond_with(@todos = Todo.all)
end
end

159. As you can see, respond_to
defines the formats the
Controller responds to

160. And responds_with is
the data to send back

161. Our scaffold has already
created the methods for
our Todos controller

162. Robin pushes the
app to Heroku

163. $ git push heroku master
[... lots of output ...]
-----> Launching... done
http://deep-mountain-360.heroku.com/
deployed to Heroku
To git@heroku.com:deep-mountain-360.git
* [new branch] master -> master

165. Where can Robin go
to learn more?

166. Robin can work through the
Rails Tutorial book for Rails 3:
http://railstutorial.org/book

167. Which is a great resource.
Highly recommended!

168. Robin is now equipped
to fight crime, write
TODO lists, and learn
more about Rails 3!

169. His boss wants to give
him a little congrats

170. “POW”

171. Thank you!

172. See me after for free
Github stickers :-)

173. Media used:
http://www.flickr.com/photos/geirarne/43102913/
(CC Attribution-NonCommercial-ShareAlike 2.0)
http://www.flickr.com/photos/redraspus/2883658175
(CC Attribution-NonCommercial-ShareAlike 2.0)
http://www.flickr.com/photos/patolucas/2862975260/
(CC Attribution-ShareAlike 2.0 Generic)

174. Links:
https://github.com/atmos/cinderella
http://rvm.beginrescueend.com/
http://yehudakatz.com/2008/12/23/rails-and-merb-merge/
http://railsforzombies.org
http://railstutorial.org/book
http://rubyonrails.org/screencasts/rails3/
https://github.com/brynary/arel