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???

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

• O início deste tutorial foi baseado neste link: http://kb.reflectivesurface.com/br/tutoriais/rubyOnRails/ qualquer semelhança não é mera conhecidência
• Api de rails completa: http://api.rubyonrails.org/