Ruby on Rails is a web application framework that follows the model-view-controller (MVC) pattern. It emphasizes convention over configuration and includes tools and frameworks needed to build database-backed web applications according to its conventions. Some of these conventions include generating model, view, and controller code automatically through scaffolding and using RESTful routing. The document provides an overview of how to build a basic Rails application that displays a list of people from a database. It demonstrates concepts like MVC, RESTful routing, ActiveRecord models, database migrations, and using form helpers and templates to create views.

1. RUBY ON RAILS

2. Ruby vs Java

3. Ruby = Slower

4. Java = Verbose

5. Ruby == Java
What's the same?

6. Garbage collected

7. Strongly typed objects

8. public, private, and protected

9. Ruby != Java
What's different?

10. No compilation

11. begin...end vs {}

12. require instead of import

13. Parentheses optional
in method calls

14. Everything is an object

15. No types, no casting, no static type
checking

16. Foo.new vs new Foo()

17. nil == null

18. under_score vs CamelCase

19. No method overloading

20. Mixins vs interfaces

21. Example time

22. Classes

23. class Person
attr_accessor :name
def initialize(name)
@name = name
end
def say(message="default message")
puts "#{name}: #{message}" unless message.blank?
end
end

24. > andre = Person.new("André")
> andre.say("Hello!")
=> André: Hello!

25. Inheritance

26. class RudePerson < Person
def shout(message="default message")
say(message.upcase)
end
end

27. Mixins

28. module RudeBehaviour
def shout(message="default message")
say(message.upcase)
end
end
class Person
include RudeBehaviour
# ...
end

29. Readability nazi's
Usually 5+ ways to do the same thing, so it looks nice.

30. def repeat(message="default message", count=1)
# say message count times.
end

31. def repeat(message="default message", count=1)
loop do
say(message)
count -= 1
break if count == 0
end
end

32. def repeat(message="default message", count=1)
while(count > 0)
say(message)
count -= 1
end
end

33. def repeat(message="default message", count=1)
until(count == 0)
say(message)
count -= 1
end
end

34. def repeat(message="default message", count=1)
(0...count).each do
say(message)
end
end

35. def repeat(message="default message", count=1)
for index in (0...count)
say(message)
end
end

36. def repeat(message="default message", count=1)
count.times do
say(message)
end
end

37. Meta-programming
Changing the code on the fly

38. > Person.new.respond_to?(:shout)
=> false
> Person.include(RudeBehaviour)
=> Person
> Person.new.respond_to?(:shout)
=> true

39. # Add the 'shout' method to each object that has a 'say' method.
> Object.subclasses.each{ |o| o.include(RudeBehaviour) if o.respond_to?(:say) }

40. We can manipulate code

41. class Person
["hello", "goodbye", "howdie"].each do |word|
define_method("say_#{word}") do
say("#{name}: #{word}")
end
end
end

42. > Person.new("André").say_hello
=> André: hello

43. Who even needs methods?
The power of method_missing

44. class Person
def method_missing(method_name, *arguments)
if method_name.starts_with?("say_")
# Say everything after 'say_'
say(method_name[4..-1])
else
super
end
end
end

45. Your turn

46. Animal kingdom
Build a Fish, Chicken, and Platypus

47. 4 Each animal makes a noise (blub, tock, gnarl)
4 All animals have health
4 Certain animals have a beak (chicken, platypus, NOT
fish)
4 Animals with a beak can peck other animals
(health--)
4 Certain animals can lay eggs (fish, chicken, NOT
platypus)

48. module RudeBehaviour
def shout(message="default message")
say(message.upcase)
end
end
class Person
include RudeBehaviour
attr_accessor :name
def initialize(name)
self.name = name
end
def say(message="default message")
puts "#{name}: #{message}" unless message.blank?
end
end

49. class Animal
attr_accessor :health
def initialize
self.health = 100
end
def make_noise noise
puts noise
end
end
module Beaked
def peck(animal)
animal.health -= 1
end
end
class Egg ; end
module EggLayer
def lay_egg
Egg.new
end
end
class Chicken < Animal
include Beaked, EggLayer
def make_noise
super("tock")
end
end

50. Rails
A web framework

51. DRY & MVC
Convention over configuration

52. [EXPLAIN MVC GRAPH]

53. GET http://localhost:3000/people

54. Routing
# config/routes.rb
MyApp::Application.routes.draw do
get "/people", to: "people#index"
end

55. The Controller
# app/controllers/people_controller.rb
class PeopleController < ApplicationController
def index
end
end

56. The view
# app/views/people/index.html
<p>Hello world!</p>

57. This is a bit plain...
Let's add some dynamic data

58. The Controller
# app/controllers/people_controller.rb
class PeopleController < ApplicationController
def index
@people = ["André", "Pieter", "Matthijs"]
end
end

59. The view (ERB)
# app/views/people/index.html.erb
<ul>
<% @people.each do |person| %>
<li><%= person %></li>
<% end %>
</ul>

60. The view (SLIM)
# app/views/people/index.html.slim
ul
- @people.each do |person|
li= person

61. What about a database?
The default is SQLLite

62. The model
# app/models/person.rb
class Person < ActiveRecord::Base
end

63. Migrations
# db/migrations/00000000_create_people.rb
class CreatePeople < ActiveRecord::Migration
def change
create_table :people do |t|
t.string :name
end
end
end
rails g migration create_people name:string

64. Wait!!!?
How does it know people belongs to the person model?

65. Convention over
configuration
Tables are plural, models are singular

66. > rake db:create db:migrate

67. The Controller
# app/controllers/people_controller.rb
class PeopleController < ApplicationController
def index
@people = Person.all
end
end

68. The view (SLIM)
# app/views/people/index.html.slim
ul
- @people.each do |person|
li= person.name

69. Convention over
configuration
All columns are mapped to methods

70. Okay, lets add some people.

71. > Person.new(name: "André").save
> Person.new(name: "Pieter").save
> Person.new(name: "Matthijs").save
> Person.count
=> 3

72. Validations
> Person.new.save
=> true

73. The model
# app/models/person.rb
class Person < ActiveRecord::Base
validates :name, presence: true
end

74. Validations
> p = Person.new
> p.save
=> false
> p.errors.messages
=> {:name=>["can't be blank"]}

75. Let's add a form
This will introduce two new 'actions'

76. NEW & CREATE
the form, and the creation

77. Routing
# config/routes.rb
MyApp::Application.routes.draw do
get "/people", to: "people#index"
get "/people/new", to: "people#new"
post "/people", to: "people#create"
end

78. Routing
# config/routes.rb
MyApp::Application.routes.draw do
resources :people, only: [:index, :new, :create]
end

79. Convention over
configuration
index, show, new, edit, create, update, destroy

80. The Controller
# app/controllers/people_controller.rb
class PeopleController < ApplicationController
def index
@people = Person.all
end
def new
@person = Person.new
end
end

81. The view (ERB)
# app/views/people/new.html.erb
<%= form_for @person do |f| %>
<div>
<%= f.text_field :name %>
</div>
<div>
<%= f.submit "Save" %>
</div>
<% end %>

82. The view (SLIM)
# app/views/people/new.html.slim
= form_for @person do |f|
div= f.text_field :name
div= f.submit "Save"
From now on, we will continue in SLIM, but ERB is just as
good.

83. The Controller
# app/controllers/people_controller.rb
class PeopleController < ApplicationController
# def index ...
# def new ...
def create
@person = Person.new(person_attributes)
if @person.save
redirect_to action: :index
else
render :new
end
end
private
def person_attributes
params.require(:person).permit(:name)
end
end

84. The view (SLIM)
# app/views/people/new.html.slim
- @person.errors.full_messages.each do |error|
div.red= error
= form_for @person do |f|
div= f.text_field :name
div= f.submit "Save"

85. Finally, destroying stuff.

86. Routing
# config/routes.rb
MyApp::Application.routes.draw do
resources :people, only: [:index, :new, :create, :destroy]
end

87. The view (SLIM)
# app/views/people/index.html.slim
ul
- @people.each do |person|
li= link_to(person.name, person_path(person), method: :delete)
NOTE: the method is the HTTP method, not the controller method.

88. Path helpers
> rake routes
Prefix Verb URI Pattern Controller#Action
-------------------------------------------------------------
people GET /people people#index
person GET /people/:id people#show
new_person GET /people/new people#new
edit_person GET /people/:id/edit people#edit
POST /people people#create
PATCH /people/:id people#update
DELETE /people/:id people#destroy

89. The Controller
# app/controllers/people_controller.rb
class PeopleController < ApplicationController
# def index ...
# def new ...
# def create ...
def destroy
Person.find(params[:id]).destroy
redirect_to action: :index
end
end

90. Example time

91. Installing ruby (OSX)
> brew install rbenv ruby-build
Then add eval "$(rbenv init -)" to your .profile
> rbenv install 2.2.3
Linux: https://github.com/sstephenson/rbenv

92. Installing Rails
> gem install rails

93. Making your app
> rails new [my_app]

94. Structure
- app
- models
- views
- controllers
- config
- db
- Gemfile / Gemfile.lock

95. Dependencies
# Gemfile
gem 'slim-rails'
Add this line to your Gemfile to use slim, then install them:
> bundle install

96. Running your app
> rails s

97. Build a small app (45 mins)
Use the pdf for reference

98. Your app should:
4 be able to add items
4 be able to edit items
4 be able to destroy items
4 be able to show a single item
4 be able to show a list of items

99. Next up: relations
has_many, belongs_to, has_one, has_many_through

100. The model
# app/models/person.rb
class Person < ActiveRecord::Base
validates :name, presence: true
has_many :skills
end
# app/models/skill.rb
class Skill < ActiveRecord::Base
belongs_to :person
end

101. Migrations
# db/migrations/00000000_create_skills.rb
class CreateSkills < ActiveRecord::Migration
def change
create_table :skills do |t|
t.string :name
t.references :person
end
end
end

102. But this binds the skill to a
single person...

103. We need a link table
Rails forces you to name it properly!

104. # app/models/proficiency.rb
class Proficiency < ActiveRecord::Base
belongs_to :person
belongs_to :skill
end

105. Migrations
# db/migrations/00000000_create_proficiencies.rb
class CreateProficiencies < ActiveRecord::Migration
def change
create_table :proficiencies do |t|
t.references :person
t.references :skill
end
end
end

106. Migrations
# db/migrations/00000000_remove_person_reference_from_skills.rb
class RemovePersonReferenceFromSkills < ActiveRecord::Migration
def change
remove_reference :skills, :person
end
end

107. The model
# app/models/person.rb
class Person < ActiveRecord::Base
validates :name, presence: true
has_many :proficiencies
has_many :skills, through: :proficiencies
end
# app/models/skill.rb
class Skill < ActiveRecord::Base
has_many :proficiencies
has_many :people, through: :proficiencies
end
# app/models/proficiency.rb
class Proficiency < ActiveRecord::Base
belongs_to :person
belongs_to :skill
end

108. > andre = Person.new(name: "André")
> andre.skills << Skill.create(name: "Knitting")
> andre.save

109. Update your app (30 mins)
Use the pdf for reference

110. Your app should:
4 have a relationship through a link table
4 have the forms to create/update/destroy the
related items (in our example: Skills)
4 should NOT be able to build the relationship using a
form (yet).

111. Building nested forms
Though usually it can be prevented by making the link table a first-class citizen.

112. The view
# app/views/people/new.html.slim
= form_for @person do |f|
div= f.text_field :name
= f.fields_for :proficiencies, @person.proficiencies.build do |g|
div= g.collection_select :skill_id, Skill.all, :id, :name
div= f.submit "Save"

113. The controller
# app/controllers/people_controller.rb
class PeopleController < ApplicationController
# def index ...
# def new ...
# def create ...
private
def person_attributes
params.require(:person).permit(:name, proficiencies_attributes: [:skill_id])
end
end

114. The model
# app/models/person.rb
class Person < ActiveRecord::Base
validates :name, presence: true
has_many :proficiencies
has_many :skills, through: :proficiencies
accepts_nested_attributes_for :proficiencies
end

115. Update your app (30 mins)
Use the pdf for reference

116. Your app should:
4 should be able to build the relationship using a form.
4 you can pick: nested or first-class

117. Testing
Pick your poison: rspec, test-unit,

118. # test/models/person_test.rb
require 'test_helper'
class PersonTest < ActiveSupport::TestCase
test "Person has a name, that is required" do
assert !Person.new.valid?
assert Person.new(name: "André").valid?
end
end
Run your tests
> rake test

119. # test/integration/people_get_test.rb
require 'test_helper'
class PeopleGetTest < ActionDispatch::IntegrationTest
test "that the index shows a list of people" do
# Build three people
names = ["André", "Matthijs", "Pieter"]
names.each{ |name| Person.create(name: name) }
get people_path
assert_response :success
assert_select "li", "André"
assert_select "li", "Matthijs"
assert_select "li", "Pieter"
end
end

120. Update your app (15 mins)
Use the pdf for reference

121. Your app should:
4 Test your validations, and relationships.
4 Test a few basic forms

122. Building API's
Making a JSON API for your models

123. Routing
# config/routes.rb
MyApp::Application.routes.draw do
resources :people
namespace :api do
resources :people
end
end

124. The controller
# app/controllers/api/people_controller.rb
class Api::PeopleController < ApplicationController
def index
render json: Person.all
end
end

125. The response
[ { id: 1, name: "André" },
{ id: 2, name: "Pieter" },
{ id: 3, name: "Matthijs" } ]

126. Adapting the JSON
Multiple ways to achieve the same thing.

127. The model
# app/models/person.rb
class Person < ActiveRecord::Base
def as_json options={}
{ name: name }
end
end

128. But this changes it
everywhere
JSON is also a view

129. The controller
# app/controllers/api/people_controller.rb
class Api::PeopleController < ApplicationController
def index
@people = Person.all
end
end

130. The view
# app/views/api/people/index.json.jbuilder
json.array! @people, :name

131. This means we can even
merge both controllers
just drop the jbuilder view in the original views
the view will be selected using the request format

132. Update your app (45 mins)
Use the pdf for reference

133. Your app should:
4 Have a view JSON api
4 Test the API

134. Q & A
Specific questions go here

135. EXTRA: Update your app
(60 mins)
Use the pdf for reference

136. Your app should:
4 Do something you want it too
4 We will help.