Ruby on Rails 102

Guilherme Cavalcanti
Redu
27 de Maro de 2014

Roteiro

ActiveRecord
Callbacks
Query Interface
Scopes

Mos obra

Antes de tudo

Antes de tudo
A Documentao sua amiga
http://api.rubyonrails.org/
http://guides.rubyonrails.org/
http://rubyonrails.org/

Callbacks

Callbacks
Associam comportamento ao ciclo de
vida de um modelo
Por exemplo, executar alguma ao
quando um objeto ActiveRecord :
validado, criado, deletado,
atualizado, salvo

Exemplos de uso

class User < ActiveRecord::Base

validates :login, :email, presence: true

before_validation :ensure_login_has_a_value

protected
def ensure_login_has_a_value
if login.nil?
self.login = email unless email.blank?
end
end
end

class User < ActiveRecord::Base

validates :login, :email, presence: true

before_create do |user|
user.name = user.login.capitalize if user.name.blank?
end
end

Callbacks disponveis
Ciclo de criao de um objeto
before_validation!
after_validation!
before_save!
around_save!
before_create!
around_create!
after_create!
after_save!

Ciclo de atualizao de um objeto

before_validation!
after_validation!
before_save!
around_save!
before_update!
around_update!
after_update!
after_save!

Callbacks disponveis
Ciclo de deleo de um objeto
before_destroy!
around_destroy!
after_destroy!

Query Interface

Query Interface
Interface que define acesso ao banco e
instancia os objetos
ActiveRecord facilita a interao entre o
objeto e banco de dados

Retornando um simples
objeto
Usando a primary key (find)
# Encontra um client com id = 10
client = Client.find(10)
# => #<Client id: 10, first_name: "Ryan">

# O SQL gerado por Rails

SELECT * FROM clients WHERE (clients.id = 10) LIMIT 1

Usando mtodos j prontos

client = Client.last
# => #<Client id: 221, first_name: "Russel">

SELECT * FROM clients ORDER BY clients.id DESC LIMIT 1

client = Client.first
# => #<Client id: 1, first_name: "Lifo">

SELECT * FROM clients LIMIT 1

Retornando muitos
objetos
Usando as primary keys (find)
client = Client.find([1, 10]) # Or even Client.find(1, 10)
# => [#<Client id: 1, first_name: "Lifo">, #<Client id: 10,
first_name: "Ryan">]

SELECT * FROM clients WHERE (clients.id IN (1,10))

Retornando todos os elementos de um

objeto
# S existem dois elementos guardados no banco
clients = Client.all
# => [#<Client id: 221, first_name: "Russel">, #<Client id: 10,
first_name: "Ryan">]

Condies
String pura
client = Client.where("orders_count = '2'")
# => [#<Client id: 1, first_name: "Lifo", orders_count: 2>, #<Client
id: 10, first_name: "Ryan", orders_count: 2>]

SELECT * FROM clients WHERE (clients.orders_count = '2')

Passando Array como parmetro

Client.where("orders_count = ?", params[:orders])
Client.where("orders_count = ? AND locked = ?", params[:orders], false)
Client.where("created_at >= :start_date AND created_at <= :end_date",
{start_date: params[:start_date], end_date: params[:end_date]})

Client.where(created_at: (params[:start_date].to_date)..
(params[:end_date].to_date))

SELECT "clients".* FROM "clients" WHERE ("clients"."created_at" BETWEEN

'2010-09-29' AND '2010-11-30')

Ordem e Seleo
Ordem
Client.order("created_at DESC")
# ou
Client.order("created_at ASC")

Client.order("orders_count ASC, created_at DESC")

Seleo de coluna
Client.select("viewable_by, locked")

SELECT viewable_by, locked FROM clients

Limite e Oset
Limite e Oset
Client.limit(5).offset(30)

SELECT * FROM clients LIMIT 5 OFFSET 30

Scopes

Scopes
So mtodos
Especificam consultas comumente
utilizadas
Pode-se utiliz-los nos modelos e
associaes

Scopes

class User < ActiveRecord::Base!

scope :seniors, where('age > 65')!
end!
!
User.seniors!
# => Todos usurios com mais de 65 anos!
course.students.seniors!
# => Todos usurios do curso que possuem mais de 65 anos!

Scopes
Tambm pode ser escrito assim:
class User < ActiveRecord::Base!
scope :seniors, -> { where('age > 65') }!
end!

uma funo annima

S executada quando o escopo for chamado

E qual a vantagem?

Scopes
E qual a vantagem?
class User < ActiveRecord::Base!
scope :born_today, -> { where(birthday: Date.today) }!
end!

Depende do dia em que executado

Passando parmetros

class User < ActiveRecord::Base!

scope :born_at, ->(date) { where(birthday: date)}!
end!

class User < ActiveRecord::Base!

scope :born_before, ->(date) { where("birthday < ?", date) }!
end!

Encadeamento

class User < ActiveRecord::Base!

scope :born_at, ->(date) { where(birthday: date)}!
scope :women, -> { where(gender: 'female') }!
end!
!
User.women!
# => Todas as mulheres!
User.born_at(10.days.ago)!
# => Todos os usurios nascidos h 10 dias!
User.women.born_at(10.days.ago)!
# => Todas as mulheres nascidas h 10 dias!

Referncias

Rails Guides - http://

guides.rubyonrails.org/

Mos a obra

Obrigado. :)