Desenvolvendo Aplicações com Ruby on Rails
Introdução
Sewa Mobil Jakarta| |
Toko Bunga |
Toko Bunga Jakarta
Estamos assumindo que você já tem o Rails instalado e tem uma noção de programação e sql.
Para iniciar o nosso estudo sobre Rails estamos propondo desenvolver uma aplicação simples onde cadastramos filmes e informações referentes a estes filmes. Todas as vezes que citarmos algum exemplo será sempre focado no desenvolvimento da aplicação, assim teremos um exemplo prático da utilização de Ruby em Rails, com isso pretendemos facilitar o processo de entendimento da linguagem e da ferramenta. Os exemplos citados serão feitos utilizando GNU/Linux.
Instalando Rails no Debian
Para instalar o rails basta instalar o pacote debina rails com o comando:
aptitude install rails
Iniciando uma aplicação
Para iniciar uma aplicação em Rails basta digitar o comando:
rails nome_da_aplicação
Nosso caso:
rails Filmes
Com este comando o Rails cria uma estrutura para o desenvolvimento da aplicação. Um pacote rails fornece a lógica de controle para as aplicações, unindo a apresentação e o mapeamento de objetos em uma biblioteca
MVC (Model-View-Controller) completa.
Esta estrutura é ilutrada abaixo:
- Filmes: Diretório raiz da aplicação. este diretório terá o mesmo nome que foi escolhido para a nome_da_aplicação anteriormente.
- app: Neste diretório estará toda a árvore de diretórios onde construiremos a nossa aplicação, portanto este é o diretório mais importante :).
- controllers: contém o C do MVC, neste diretório estão os arquivos que fazem o processamento da requisições e invocam as outras partes do sistema;
- helpers: Contém funções auxiliares para os controlers;
- models: Possui os objetos que mapeiam o banco de dados para a aplicação;
- views: Contém os arquivos responsáveis pela apresentação do site;
- components
- config
- db
- doc
- lib
- log
- public
- Rakefile
- README
- script: Possui alguns scripts explicar melhor a utilizadade e os scripts mais comuns.
- test
- tmp
- vendor
SEO Melbourne
Iniciando o servidor
Uma vez criada a aplicação acesse o diretório raiz da mesma (no nosso caso a pasta Filmes) e execute o comando:
./script/server
Com este comando você passará a rodar o servidor WEBRick para que você possa testar a sua aplicação. Este é um servidor Ruby capaz de servir um bom número de usuários mas não aconselhável em produção se você espera muitos acessos.
Você pode passar alguns parâmetros para a inicialização do servidor. Para saber quais são estes parâmetros e o que eles representam
clique aqui in
term papers or
essays.
Por padrão, o servidor Rails roda na porta 3000. Para saber se o servidor Rails está rodando acesse no navegador o endereço:
localhost:3000
. Caso tudo funcione corretamente aparecerá uma página de apresentação do Rails. Caso contrário, modifique a porta no momento de inicializar o servidor e modifique-a também no endereço do navegador.
./script/server -p 3001
Controller
O que é um controller
explicar o que eh um controller
Criando um Controller
O diretório /script contém um outro utilitário chamado generate que serve para automatizar a criação de várias das estruturas do Rails. Iremos gerar um controller com o nome Filmes, para isso basta digitar o comando:
./script/generate controller Filmes
Se você for no diretório /app/controllers agora, verá que existem dois arquivos no mesmo: application.rb, que é o controller geral do qual todos outros descendem e filmes_controller.rb, que é o que você acabou de criar. Abrindo o arquivo, você verá o seguinte:
class FilmesController < ApplicationController
end
Neste momento esse controller não faz absolutamente nada. Se você rodar o servidor Web embutido novamente, apontando para
http://localhost:3000/Filmes/, você verá o seguinte:
Observe que o Rails mapeou automaticamente a classe
FilmesController para a URL /filmes, sem que você precise fazer qualquer coisa.
Adicionando Métodos a um Controller
Um controller que não faz nada não tem utilidade, então vamos definir alguma ação a este controler. Inicialmente ele irá imprimir o conhecido "Alô Mundo" na tela. Para isso vamos criar uma método que realize esta operação.
class FilmesController < ApplicationController
def index
render_text "Alô Mundo!"
end
end
O método
index
é chamado por padrão ao se acessar o controler, caso ele não exista será exibida a página ilustrada na figura 2.
Para se adicionar novas funcionalidades ao controller basta criar novos métodos para o mesmo.
class FilmesController < ApplicationController
def index
render_text "Alô Mundo!"
end
def teste
render_text "Testando..."
end
end
Para testar o novo método criado basta acessar o endereço:
http://localhost:3000/filmes/teste
View?
O que são Views?
escrever um pouco sobre views
Para evitar a necessidade de se escrever código HTML o Rails possui as views, que mapeam ações para apresentação.
Como utilizar as views
Na classe
FilmesController, remova o conteúdo do método index e o método teste deixando o código do controller Filmes assim:
class FilmesController < ApplicationController
def index
end
end
Acessando:
http://localhost:3000/filmes/
Você verá a página assim:
Isso acontece porque o Rails informa que a
view que corresponde àquele método daquele controller não existe. Para remediar isso, crie um novo arquivo em /app/views/filmes chamado index.rhtml, com o seguinte conteúdo:
<h1>Olá Mundo!</h1>
Recarregando a página você verá o conteúdo do template exibido:
Criando Templates para views
Para facilitar ainda mais o trabalho do programador o rails ainda pois um mecanismo de layout que permite o compartilhamento de conteúdo. Para utilizar este mecanismo é muito simples, voltando ao arquivo do controler que criamos (Filmes) colocamos o código:
class FilmesController < ApplicationController
layout "blank"
def index
end
end
Criando agora em
app/views/layouts um arquivo chamado blank.rhtml com o conteúdo:
<html>
<head>
<title> Filmes </title>
</head>
<body>
<h1> Filmes </h1>
<%= @content_for_layout %>
</body>
</html>
Recarregando a página nós obteremos o seguinte resultado:
Podemos notar que o Rails processou o arquivo onde definimos o nosso layout (blank) e o arquivo do controller que contém o nosso método, embutindo o resultado do método no layout geral. O atributo @content_for_layout obtém o texto renderizado pelo template da ação e coloca no layout geral.
Utilizando Banco de Dados
O Rails assume três ambientes de execução: test, development e production. O primeiro é usado para executar unit tests na aplicação, verificando se todo o código passa nos testes prescritos. O segundo, que é o padrão, é usado para o desenvolvimento em si. Quando você iniciou o servidor com o comando acima, o ambiente development é que foi carregado. O último ambiente é usado para colocar a aplicação em produção. Cada um deles possui algumas diferenças que facilitam o uso do Rails nesses contextos específicos.
Por causa disso, o Rails normalmente espera que você crie três bancos de dados, um por ambiente.
Então criaremos os três bancos de dados requisitados pelo rails, estes serão:
- Para o ambiente de teste: filmes_test
- Para o ambiente de desenvolvimento: filmes_development
- Para o ambiente de produção: filmes_production
colocar uma explicação de como criar os banco aqui
Agora, vamos configurar o Rails para reconhecer esse banco. Abra o arquivo /config/database.yml. Esse arquivo fornece ao Rails as configurações dos vários bancos usados pelos diferentes ambientes. Um arquivo padrão aparece assim:
development:
adapter: mysql
database: Filmes_development
username: root
password:
host: localhost
test:
adapter: mysql
database: Filmes_test
username: root
password:
host: localhost
production:
adapter: mysql
database: Filmes_production
username: root
password:
host: localhost
Como pode-se notar nós temos uma arquivo no formato YAML onde temos as informações referentes aos três banco utilizados por uma aplicação Rails.
Como no nosso caso estamos utilizando postgresql com um usuário filmes e senha filmes para acessar o banco temos que modificar este arquivo para:
development:
adapter: postgresql
database: Filmes_development
username: filmes
password: filmes
host: localhost
test:
adapter: postgresql
database: Filmes_test
username: filmes
password: filmes
host: localhost
production:
adapter: postgresql
database: Filmes_production
username: filmes
password: filmes
host: localhost
Atenção: Se você estiver rodando o servidor, você precisa reiniciá-lo após modificar a configuração de banco de dados.
O sistema que estamos nos propondo a criar a título ilustrativo ele possui uma usuários que possuem permissão para cadastrar novos filmes no sistema. Então vamos criar inicialmente a tabela de usuários para o nosso sistema.
O script sql para a criação da tabela é:
CREATE TABLE Users (
id SERIAL,
login VARCHAR(50) default '' NOT NULL,
password VARCHAR(32) default '' NOT NULL,
administrator BOOLEAN DEFAULT 'f' NOT NULL,
PRIMARY KEY(id)
);
A tabela foi criada com este nome porque o rails mapeia automaticamente siguares em plurais. Este pode ser um ponto fraco do rails pois esta é uma carterística que o deixa depende do inglês.
Toda tabela deve ter uma campo id como chave primária, pois o rails utiliza esta informação
para que mesmo???
Você não precisa criar as tabelas no banco da forma tradicional, após falarmos sobre Model veremos como usar o Migration.
Criando Model
Um model é
colocar uam descrição do que é um model aqui
Para criar um model basta usar o scrit/generate novamente com os seguintes argumentos:
script/generate model user
Após este comando será criado o arquivo
/app/models/user.rb com o seguinte conteúdo:
class User < ActiveRecord::Base
end
Somente com este código é o que o Rails precisa para mapear a tabela para o código. Por si só, o model já pode ser usado em qualquer local do código. Mas vamos usar um novo controller para exibir esse model. Use o comando generate mais uma vez:
script/generate controller users
Com este comendo foi gerado o arquivo
app/controllers/users_controller.rb
contendo o conteúdo:
class UsersController < ApplicationController
end
Vamos modificar esse arquivo para utilizar implicitamente o model através de um processo chamado scaffolding. Esse processo cria automaticamente ações do controller para efetuar as operações
CRUD (Create, Read, Update, Delete) no banco. O arquivo fica assim:
class UsersController < ApplicationController
scaffold :user
end
Acessando o endereço:
http://localhost:3000/users
no navegador temos o seguinte resultado:
Aqui vemos que uma ação para o index foi automaticamente criada e, melhor ainda, já exibindo uma tela com a listagem dos registros (embora ainda nenhum exista na tabela).
Um link também foi incluido para adicionar uma pessoa nova. Clicando no link temos:
A ação new também é automaticamente criada pelo mecanismo de scaffolding com tudo o que é necessário para a edição de um usuário. Preencha os campos e clique para submeter os dados. A ação create roda e redireciona para a ação list, que é basicamente um sinônimo para a ação index. A tela resultante fica depois de duas inserções é:
De forma análoga a anterior iremos realizar todos os procedimento necessários para adicionar as informações referentes aos filmes.
- criando configurando banco de dados
- usar
latin1
por enquanto como codificação do banco
-
forçar encoding para latin1
nos headers e no HTML
- criando tabela
- scaffold
- reiniciar o servidor (sempre depois de mudar a conf. do banco)
- navegar pela interface do scaffold
- adicionar coluna
- mudar ordem das colunas
- validação : validates_presence_of => :field
- rails não é scaffolding:
generate scaffold
+ alterando index
- partials
- associações:
has_many :other
; convenção de nome da FK; propriedade adicionada na classe todo.
- herança!
- incluindo coisas (exemplo do blog: comentários)
- XXX.find(params[:id]).yyys.create(
- flash[:notice] = "message"
- redirect
- logs
- testes unitários
- console
Migration - Abistraindo o Banco de Dados
Como foi dito antes, vamos ver agora como criar e alterar tabelas com
Migration.
Após aquele comando
script/generate model user
, foram criados outros arquivos, dentre eles o
db/migrate/001_create_users.rb.
Esse arquivo define a interface com o banco de dados e a partir dele podemos usar o migrate para gerar ou modificar tabelas. Esse é o formato:
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
# t.column :name, :string
end
end
def self.down
drop_table :users
end
end
Você precisa definir o nome e tipo dos campos da tabela:
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.column :login, :string, :null => false
t.column :password, :string, :limit => 32, :null => false
t.column :administrator, :boolean, :default => true
end
end
def self.down
drop_table :users
end
end
Com essa definição você pode executar:
rake migrate
Ele irá executar todas as migrations ainda não executadas. O nome da migration deve ser único e o número também único e sequencial.
Saiba mais sobre Migration em
http://wiki.rubyonrails.com/rails/pages/UnderstandingMigrations
Referências