Rails na pratica

Ruby on Rails na prática

Túlio Ornelas

Agenda
• Ruby
• Rails
• Instalando o Rails
• Criando um projeto
• Criando primeiro C.R.U.D
• Validando C.R.U.D
• Segundo C.R.U.D

Um pouco sobre Ruby
• Criada em 1993 por Yukihiro Matz
• Linguagem interpretada
• Tipagem dinâmica
• Fortemente tipada
• Orientada a objetos
• Livre
• http://www.ruby-lang.org/

Um pouco sobre Ruby
• Instalando
 Linux: sudo apt-get install ruby
 Windows: One-click-installer
• http://www.ruby-lang.org/pt/downloads/
 Mac OS/X: port install ruby

• Testando a instalação
 ruby -v
 Irb -v

Um pouco sobre Ruby
• Interpretando um arquivo

• Interpretando diretamente um comando

Um pouco sobre Ruby
• Em Ruby tudo é OO

Um pouco sobre Ruby
• Criando uma classe
 Em Ruby:

 Em Java:

Um pouco sobre Ruby
• Criando um objeto:
 Ruby:

 Java:

Note a sintaxe simplificada! Não é necessário
declarar, a variável é criada quando utilizada.

Um pouco sobre Ruby
• Criando uma classe com método e
construtor:
 Ruby Java

Um pouco sobre Ruby
• Variáveis:
 Local:

 De instância:

 De classe:

Variáveis de classe são comparadas a atributos
estáticos (static) em java.

Um pouco sobre Ruby
• Métodos
 De instância:

 Da classe:

 Privados e Protegidos:

Um pouco sobre Ruby
• Criando métodos de acesso as variáveis

• attr_accessor e attr_reader são métodos
que geram os métodos get/set
dinamicamente

Um pouco sobre Ruby
• Reestruturando
nossa classe
User

Um pouco sobre Ruby
• Herança

Um pouco sobre Ruby
• Testando a herança

Um pouco sobre Ruby
• Booleans

 As únicas coisas falsas em Ruby são nil e false

Um pouco sobre Ruby
• LAB
 Dado um número imprimir todos os ímpares
até ele

Um pouco sobre Ruby
• Solução

Quer aprender mais?

http://www.pragprog.com/

O que é o Rails?
• Meta-Framework MVC
• Desenvolvido em linguagem Ruby

Rails
• Lançado em julho de 2004

• Solução completa, produtiva com baixa
curva de aprendizagem

• Conceitos:
 DRY (Don’t Repeat yourself)
 Convention of configuration

Rails - composição
• O Rails é a junção de 5 frameworks, são
eles:

 Active Record (ORM)
 Action Pack (MVC)
 Action Mailer
 Action Support
 Action WebServices

Rails - instalando
• O Rails é uma rubygem, por isso precisamos
do gem corretamente instalado.
• Uma “gem” é código ruby empacotado. Pode
ser comparado ao .jar em Java.

• Rubygems é instalado junto com o ruby,
caso contrário: sudo apt-get install rubygems

Rails - instalando
• Dependências:
 libsqlite3-dev
 ruby1.8-dev
• Abra o console e digite:
gem install sqlite3-ruby (driver)
gem install rails
*Confirme a instalação das dependências quando solicitado.

Rails - instalando
• Verificando a instalação

Rails – criando o projeto
• Para criar um projeto utilize o comando:
 Rails <nome do projeto>
• Por exemplo:
 Rails bug_tracking

• Dessa forma o rails Irá gerar o arcabouço
de um projeto MVC

• Vamos criar o projeto bug_tracking

• Vamos subir o servidor com ruby script/server e entrar
na URL http://localhost:3000

• Note que nosso projeto não tem nada.
Vejamos as configurações do nosso
ambiente:

Rails – o projeto
• Analisaremos apenas o diretório app por
enquanto

• Controllers => Diretório com os controladores da
aplicação
• Models => Os modelos do seu domínio
• Views => As telas
• Helpers => Classes de ajuda (conversão,
etc)

Rails
• Scripts padrões do Rails, vejamos dois:
 Generate => Cria uma estrutura básica para
um modelo.
 Server => Inicia o servidor da aplicação.

• Modo de usar:
 Ruby script/generate <parâmetros>
 Ruby script/server

Rails
• Antes de continuar o desenvolvimento
devemos conhecer o rake

 Um utilitário Ruby semelhante ao make
do C/C++, ou Ant no Java.
 Exemplo:
• Rake db:create:all

Rails
• Configuração do banco em
config/database.yml
O banco padrão do Rails é o
SQLite3 que é um banco de
dados embarcado

São criados 3 contextos:
desenvolvimento, teste e
produção

Rails – primeiro C.R.U.D
• Vamos utilizar o gerador scaffold
(andaime) que é um gerador de c.r.u.d

ruby script/generate scaffold project name:string
description:string owner:string

• Note que os atributos do seu modelo são
passados para o script, e ele irá gerar
uma migrate correspondente.

• Saída do scaffold:

Migrations (migrações) são um forma de evoluir o
schema do banco de dados

• Antes de analisarmos o ocorrido, vamos
terminar a criação do nosso modelo.
• Execute os comandos:
Rake db:create:all O comando db:migrate irá aplicar as
migrations que ainda não foram
Rake db:migrate aplicadas.

• Saída do db:migrate

• Acesse a URL http://localhost:3000/projects

• Vamos analisar os comandos do rake
utilizados:

Rake db:create:all
 Esse comando utiliza o rake para criar as
tabelas para todos os modelos ainda não
criados

Rake db:migrate

 Construídas as tabelas devemos criar as
colunas.
 As migrations servem para criação
incremental dos esquemas do banco de
dados dos modelos

• Vejamos primeiro a migration gerada:

Nome do arquivo:
Número de série composto pela data

20090816190631_create_projects.rb

Tipo Nome da tabela

• A migration de projeto está em:

• Código:

• Código do modelo e do helper:

• Estão vazios pois ainda não possuem
nenhuma regra de negócio!
• As colunas do banco serão injetadas pelo
ActiveRecord como atributos no modelo

• Código do controlador
• Método index

Rails – Active Record
• Vejamos alguns métodos que nossos
modelos herdam de ActiveRecord::Base
• save
• find(id)
• find(:all, :conditions => “”)
 find(:first, :conditions => “”)
 find(:last, :conditions => “”)
 Parâmetros opcionais:
• :join, :order, :limit, :offset, :select, :readonly, :from,
:group, :lock ...

• Mais métodos
 update_attributes(hash)
 destroy
 find_by_sql(string)

• Dinamic finders
 find_all_by_name_and_age(name, age)
 find_by_name(name)
 find_by_age(name)
 find_all_by_name_or_middle_name(name,
middle_name)
 etc


• Params é um hash do Rails que possui todos os
atributos do request. :id é o identificador do
atributo id.

Rails
• O flash é um hash que é apagado na
próxima requisição, por isso ele é muito
útil em guardar mensagens de sucesso,
erro, etc.

Rails
• O Rails cria um controlador para o modelo com
URL’s rest, como pode ser observado
• Essas url’s são criadas através de rotas
map.connect ':controller/:action/:id'
map.connect ':controller/:action/:id.:format'
• As rotas ficam no arquivo config/routes.rb e são
associadas aos controladores assim:
map.resources :projects

• Vejamos como as views, telas, são
criadas:
Neste caso temos um layout
Para o nosso controlador
projects, mas poderiamos ter
apenas um layout para
aplicação toda:

application.html.erb

• Projects.html.erb

Rails
• Onde ficam os arquivos css e javascript?

A tag stylesheet_link_tag
facilita o acesso aos arquivos css

Código gerado na execução
da aplicação.

• Index.html.erb

A tag <% é utilizada para executar algum comando
ruby e <%= para escapar algum valor. *H é uma
função de um helper, serve para não escapar o html

Rails
• Rotas (rake routes)

 projects_path listagem
 project para o show (detalhamento)
 new_project_path página de criação
 edit_project_path(project) página de edição

• New.html.erb e Edit.html.erb
O new e o Edit são exatamente iguais,
Mudando apenas o nome do botão
submit. Suas operações são diferenciadas
pelo método HTTP utilizado.

Cria um formulário para o objeto informado,
gerando a URL dependendo do método
HTTP utilizado

Apresenta as mensagens de erro,
caso existam

• Nosso modelo ainda não implementa
nenhuma regra de negócio, vamos
incrementar:

 Para isso vamos utilizar os métodos
validates_
 Iremos validar o nome, que deve ser único,
obrigatório, maior que cinco (5), menor que
cinqüenta (50) e o responsável é obrigatório

• Vejamos o novo código do modelo:

Rails – segundo C.R.U.D
• Vamos criar um novo modelo Bug que
possui um projeto
• Vamos atualizar o nosso modelo projeto,
para que este possua vários Bug’s
• Vamos relacionar os controladores

ruby script/generate scaffold bug
project:belongs_to description:string

• Vamos adicionar uma validação na
migration criada

• Com as modificações feitas vamos
atualizar o banco

rake db:migrate

• Agora vamos relacionar projeto a bug
• Um projeto poderá ter muitos bugs

• Com os modelos relacionados, vamos
criar rotas relacionadas entre eles
• Para isso vamos editar o arquivo
config/routes.db

• Removi a rota direta para bug

• Podemos pedir ao rake para nos informar
todas as rotas possíveis com o comando:
rake routes

• Vamos adicionar o link de “novo bug” em
projeto/show.html.erb

• Vamos corrigir bug/new.html.erb para que
esse realmente aponte para o projeto

• Depois de criado o bug vamos
redirecionar para página do projeto

• Resultado
http://localhost:3000/projetos/1
http://localhost:3000/projetos/1/bugs/new

• Vamos melhorar a apresentação do
projeto exibindo os bugs, adicione na
página projeto/show.html.erb

• Resultado

• Pronto! Agora precisamos apenas
configurar nossa aplicação na página
principal

• Delete a página public/index.html que é a
página de apresentação do projeto

• E faça o mapeamento do controlador
principal no arquivo config/routes.rb

• config/routes.rb

http://localhost:3000/

Quer aprender mais?

http://www.pragprog.com/
http://www.urubatan.com.br/

Ruby on Rails na prática

Obrigado
ornelas.tulio@gmail.com
twitter.com/tulios

Rails na pratica

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Rails na pratica

Último

Rails na pratica