[Tutorial] Criando sua primeira aplicação com Rails

Este tutorial é uma rápida introdução ao Rails, que pretende ajuda-lo a entender como o framework funciona – e porque somos apaixonados por ele. Neste texto, você irá aprender alguns conceitos básicos do Rails, sua estrutura e como ele funciona, através de um exemplo prático. Lembro que você pode instalar o Rails facilmente no Windows usando o RailsInstaller.

Antes, uma breve introdução: O que é o Rails?
O Ruby on Rails é um framework projetado para agilizar o desenvolvimento de aplicações web, utilizando a linguagem Ruby. Ele possibilita que você concentre seus esforços em resolver o problema do seu cliente, deixando a parte (chata) da estrutura da aplicação por conta do framework.

Com o Rails, você não precisa se preocupar em montar a camada de acesso ao banco de dados quando iniciar um projeto. Nem como irá organizar os arquivos que irão compor a aplicação. Seguindo o “Rails Way” (ou o “modo Rails” de fazer as coisas) você irá ganhar em tempo e produtividade. Basta respeitar as convenções, ou seja, as regras do Rails. Essas são as vantagens de usar um bom framework: O trabalho não começa do zero, e você tem que seguir padrões, obrigando a organizar-se. Acredite, isso vai ajudar bastante no trabalho em equipe, na manutenção do código, ou caso outro desenvolvedor assuma o projeto futuramente.

Falando em organização, o Rails utiliza o padrão MVC, que divide a aplicação em partes com funções bem definidas. É importante entender o que é o MVC, pois isso irá ajudar a compreender a lógica do Rails.

MVC (Model-View-Controller)
Nas palavras da Wikipedia, o MVC “é um padrão de arquitetura de software que visa a separar a lógica de negócio da lógica de apresentação, permitindo o desenvolvimento, teste e manutenção isolado de ambos“. Como as aplicações estão cada vez mais complexas, tornou-se importante separar o acesso aos dados/lógica de negócios (model), interface (view), e interação (controller). Isso facilita bastante a manutenção do código e deixa a estrutura da aplicação bem organizada.

Model (modelo)
A camada do modelo é onde estão as classes para as entidades que sua aplicação possui. Considere como exemplo um blog: queremos armazenar os artigos em posts – então teremos um modelo “post”. Podemos implementar comentários também – então teremos um modelo “comentario”. Autores irão escrever os posts – então teremos o modelo “autor”. No Rails, entre outras coisas, o modelo gerencia os relacionamentos, as validações de dados e faz a comunicação com o banco de dados, recuperando e armazenando informações, graças a biblioteca ActiveRecord.

View (visão)
A visão (view), como o nome diz, é responsável pela parte visual da aplicação, onde o usuário faz as requisições (ao clicar num botão, por exemplo) e também onde são apresentadas as informações de resposta. Anview trabalha com HTML e comandos Ruby misturados em arquivos erb (Embedded Ruby), de forma semelhante ao PHP ou ASP. Por conta disso, você vai perceber que os arquivos da view são terminados com *.html.erb. As visões estão constantemente enviando e recebendo informações do controle – a camada C do MVC.

Control (controle)
Alguém deve fazer o meio de campo entre o model e a view: esse é o papel do controle. Podemos dizer que o controle é quem faz as coisas acontecerem dentro do MVC, pois ele recebe a ação da view, pesquisa (ou trata) o resultado junto ao model e devolve o resultado para a view, fazendo girar o ciclo de atividades dentro do MVC.

Caso queira aprender mais sobre MVC, uma busca no Google vai oferecer artigos mais profundos e esclarecedores sobre esse padrão. Mas para você aprender de verdade, nada como colocar a mão na massa; Então vamos prosseguir.

O cardápio do dia
Nesse tutorial, não vamos inventar muito: iremos montar um blog, pois provavelmente você já acessou algum e conhece como ele funciona. Isso torna mais simples assimilar algumas coisas. E caso nunca tenha acessado um blog, voilá! O RubyBrasil é um blog – com esteróides.

Esse será o resultado do tutorial

Antes de começar, é necessário ter em mente a estrutura da nossa aplicação de exemplo. Um blog pode ter posts, autores que escrevem os posts e comentários sobre os posts. Posts também podem pertencer a categorias e serem identificados por tags. Mas para que esse artigo não fique muito extenso, vamos simplificar: teremos apenas posts e comentários no nosso exemplo. Importante: Tenha em mente que um post pode ter vários comentários, entretanto cada comentário pertence a um post.

Criando um novo projeto
Chegou a hora de começar, criando nosso projeto. No Rails, um projeto é uma estrutura de pastas usada para armazenar os arquivos que irão compor sua aplicação. Uma ferramenta essencial durante o desenvolvimento Rails é o prompt de comandos (no windows) ou o terminal (no linux). Para criar nosso projeto, acesse o prompt de comando ou terminal e digite o comando abaixo.

$ rails new blog

Este comando irá fazer com que o Rails crie um diretório chamado blog, e monte dentro dele uma estrutura padrão de pastas e arquivos. Os mais importantes para nós, por enquanto, são esses:

Arquivo	Função
config\database.yml	Contém informações para conexão da aplicação com o banco de dados, como login e senha do SGBD.
config\routes.rb	Arquivo onde definimos como as requisições HTTP serão roteadas.
app\controllers\	Contém os arquivos escritos em Ruby da camada controle (o C do MVC).
app\helpers\	Contém os helpers, classes que facilitam algumas tarefas (como criar formulários).
app\models\	Contém os arquivos escritos em Ruby da camada model (o M do MVC).
app\views\	Contém uma pasta para cada controle que sua aplicação tiver.
db\migrate\	Contém os arquivos de migração, usados para migrar o banco de dados de um estado para outro.

.

Acelerando o desenvolvimento com scaffold
Scaffold, em inglês, significa andaime. É o termo certo para o que ele faz: Cria a estrutura básica de um elemento dentro do seu projeto para que possamos desenvolver a aplicação. Num comando simples, o scaffold gera o modelo, o controle, e as visões (dentre outras coisas), adiantando bastante o seu trabalho. O scaffold pode ser usado também para construir protótipos rápidos, para mostrar ao seu cliente o andamento do trabalho.

Usando scaffold para criar os posts
Para criar os arquivos necessários para gerenciar os posts do nosso blog usando scaffold, primeiro devemos acessar a pasta da nossa aplicação.

$ cd blog/

Depois, estando dentro do diretório blog, basta uma única linha de comando. Nosso post terá o nome do autor, o titulo do post, e o conteúdo.

$ rails generate scaffold post titulo:string conteudo:text

Atente-se ao padrão do comando, que é formado pelo nome do modelo (post), seguido dos campos com seus respectivos tipos de dados (por exemplo, titulo:string econteudo:text).

Como dito antes, esse comando gera um monte de arquivos. Ele cria o modelo chamadopost.rb na pasta app/models, o posts_controller.rb (no plural) na pasta app/controllers, além de criar também as visões na pasta app/views. Ressalto que o Rails organiza as views através de pastas com o nome dos modelos existentes. Então, o scaffold vai gerar uma pasta dentro de app/views com o nome posts, contendo quatro arquivos dentro dela: index.html.erb, edit.html.erb, show.html.erb e new.html.erb. Ou seja, o Rails já criou uma view para algumas ações básicas relacionadas ao item post.

Usando scaffold para criar os comentários
Da mesma forma como criamos os posts, vamos criar também os comentários usando scaffold, através do comando abaixo.

$ rails generate scaffold comentario autor:string conteudo:text post:references

Desta vez, temos algo diferente no fim do comando. Informamos que cada comentário faz referência a post. Isso vai ajudar o Rails a montar o relacionamento entre as tabelas no banco de dados. O Rails saberá que deve criar um campo de chave estrangeira na tabela comentarios, ligando com a chave primária da tabela posts.

Relacionando os modelos Post e Comentario
No banco de dados está tudo OK, mas ainda será necessário explicitar o relacionamento entre post e comentario nos modelos das entidades. Para isso, acesse a pasta app/models e faça uma alteração no arquivo post.rb.

Abra o arquivo e acrescente nele a informação de que há muitos comentários para cada post.

Veja o código RUBY

1 2 3

class Post < ActiveRecord::Base has_many :comentarios end

O arquivo comentario.rb, como foi criado por último e recebeu o post:references em sua definição, já possui a informação de que cada comentário pertence a um post, como você pode conferir.

Veja o código RUBY

1 2 3

class Comentario < ActiveRecord::Base belongs_to :post end

No model comentario.rb não será necessário mexer. Mas logo você verá como será simples fazer com que cada post identifique seus comentários (e vice-versa) graças a esses pequenos comandos milagrosos.

E o banco de dados?
Você pode deixar o gerenciamento do banco de dados nas mãos do Rails. Em alguns casos, vai ser preciso configurar o arquivo database.yml com as informações do banco de dados que deseja utilizar. A partir de então, outras tarefas como criar tabelas, colunas, etc recomenda-se que sejam feitas a partir do Rails, para maior controle.

No nosso caso, vamos usar o banco de dados SQLite, que já vem configurado por padrão quando criamos uma aplicação Rails. Caso você quisesse usar outro banco de dados, como o MySQL, poderia ter informado já na criação da aplicação, como valor do parâmetro d.

$ rails new blog -d mysql

Continuando nossa missão, vamos mandar o Rails criar o banco de dados da aplicação, usando o comando Rake.

$ rake db:create

Pronto, temos nosso banco de dados SQLite criado. Se fosse um MySQL ou qualquer outro que ele suporte, seria a mesma coisa: também teríamos criado a base de dados da mesma forma com esse comando.

As migrações
No Rails, migração é a mudança do banco de dados de um estado para outro. Por exemplo, ao criar uma nova tabela, você altera o estado do banco de dados. Ao incluir/excluir uma coluna de determinada tabela, você altera o estado do banco de dados. Ou seja, alterações na estrutura do banco mudam seu estado, e as migrações permitem que você volte o banco de dados a estados anteriores, desfazendo alterações mal-sucedidas ou desnecessárias.

Quando usamos o scaffold para criar o post e o comentário, também foram criadas suas respectivas migrações, contendo as alterações que serão necessárias fazer ao banco de dados (como criar as tabelas com as colunas informadas). As migrações podem ser conferidas na forma de arquivos individuais na pasta db/migrate.

Vamos executar as migrações pendentes para que os modelos post e comentario possam armazenar seus respectivos dados no banco.

$ rake db:migrate

O Rake é uma ferramenta muito útil no ecossistema do Rails, com várias funções. Você pode aprender mais sobre ele na documentação do Rails.

Vamos ver como está?
Nesse momento, já é possível ver como está ficando nossa aplicação, inclusive testar seu funcionamento. Como o Rails é voltado para aplicações web, será necessário usar um servidor web para rodar o sistema. O próprio Rails possui um servidor chamado Webrick, que serve justamente para ajudar o desenvolvedor a acompanhar o progresso da aplicação.

Inicie o servidor com o comando abaixo no prompt/terminal:

$ rails server

Agora, abra o navegador web de sua preferência e acesse o endereçohttp://localhost:3000/posts para ver o que aparece. Localhost é o endereço local de sua máquina, 3000 é a porta que o servidor Webrick normalmente usa e posts é o nome do controle que desejamos acessar. Por padrão, essa URL irá acionar o método “index” deposts_controller.rb, que por sua vez utilizará a visão “index.html.erb” dentro da pasta app/views/posts.

Quando você clica no link New Post, o navegador acessa o endereçohttp://localhost:3000/posts/new, que contém um formulário para adicionar novos posts. Nesse momento, você está acionando o método “new” de posts_controller.rb, que irá chamar a visão “new.html.erb” na pasta app/views/posts.

Ao clicar no botão Create Post, seu post será salvo e o navegador redirecionado à URLhttp://localhost:3000/posts/show/1, que mostra os detalhes do post. Essa URL chama o metodo “show” do controle posts_controller.rb, passando como valor o id do post cujos detalhes deverão ser mostrados. No caso, está sendo apresentado o detalhe do post de código “1″, através da view “show.html.erb“.

Clique em “New Post” e faça alguns cadastros. Teste os links “Show“, “Edit” e “Destroy“. Tudo funcionando. Por isso que o Ruby on Rails faz tanto sucesso. Até aqui, temos um cadastro de posts plenamente funcional, feito em pouco tempo e com meia dúzia de comandos simples. Caso queira encerrar o servidor e liberar o prompt/terminal, tecle Control + C.

As rotas levam ao post
O endereço da nossa aplicação não está muito intuitivo, pois temos que digitar o nome do controle que queremos acessar (posts). Vamos configurar a aplicação de forma que digitando apenas http://localhost:3000/, o Rails saiba redirecionar para o controle de posts. Quando o objetivo é configurar o direcionamento das páginas, dizemos que é uma mudança de roteamento. Essas configurações estão no arquivo config/routes.rb.

Para que possamos eliminar a necessidade de colocar o controle posts no endereço, temos que fazer duas coisas. A primeira é deletar o arquivo public/index.html, que é criado automaticamente junto com o projeto. Esse arquivo tem apenas as informações sobre a versão do Rails e o ambiente de instalação, e temos que exclui-lo para poder avaliar o resultado da configuração das rotas.

A segunda coisa a fazer é configurar as rotas no arquivo config/routes.rb. Abra o arquivo no seu editor favorito e adicione uma linha definindo qual o controle#método será root, como mostramos abaixo. Nessa configuração, dissemos ao Rails que queremos na página inicial do site o método index do controle posts.

Veja o código RUBY

1 2 3 4 5

Blog::Application.routes.draw do resources :comentarios resources :posts root :to => "posts#index" #linha adicionada end

Perceba que removemos as linhas de comentário para facilitar o entendimento do que deve ser alterado nesse arquivo.

As rotas levam aos comentários
Aproveitando que estamos configurando as rotas, vamos fazer outra alteração. Até o momento, para nossa aplicação Rails, posts estão numa página, e comentários em outra. Mas não é esse nosso interesse realmente. Queremos colocar os comentários na mesma página do seu post correspondente, para que seja mais simples de serem visualizados – como costumamos ver por aí nos blogs.

A alteração a ser feita é bem simples: basta dizer às rotas que o ‘recurso’ post contém o ‘recurso’ comentários.

Veja o código RUBY

1 2 3 4 5 6

Blog::Application.routes.draw do resources :posts do resources :comentarios end root :to => "posts#index" end

Preparando a visão para receber os comentários
Será necessário modificar a visão show dos posts (arquivo app/views/posts/show.html.erb) para que ela mostre, além do conteúdo dos posts, também os comentários cadastrados relacionados a ele e o formulário para adicionar novos comentários.

Veja o código RUBY

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

<p class="notice"><%= notice %></p>   <p> <b>Titulo:</b> <%= @post.titulo %> </p>   <p> <b>Conteudo:</b> <%= @post.conteudo %> </p>   <h2>Comentarios</h2> <% @post.comentarios.each do |comentario| %> <p> <b>Autor:</b> <%= comentario.autor %> </p>   <p> <b>Comentario:</b> <%= comentario.conteudo %> </p> <hr /> <% end %>   <h2>Adicione um comentario:</h2> <%= form_for([@post, @post.comentarios.build]) do |f| %> <div class="field"> <%= f.label :autor %><br /> <%= f.text_field :autor %> </div> <div class="field"> <%= f.label :conteudo %><br /> <%= f.text_area :conteudo %> </div> <div class="actions"> <%= f.submit %> </div> <% end %>   <br />   <%= link_to 'Edit Post', edit_post_path(@post) %> | <%= link_to 'Back to Posts', posts_path %>

Resista à tentação de cadastrar algum comentário nesse instante, pois o controlecomentarios_controller.rb ainda não está pronto para receber seu comentário. Essa é a próxima etapa.

Modificando o controle comentario
Vamos preparar o controle dos comentários para que ele saiba o que fazer quando algum usuário enviar sua opinião através do formulário. Inicialmente, remova os métodos criados por padrão – não vamos precisar deles. Adicione um novo método chamado “create“, como mostra o código abaixo. Esse simples código irá salvar o comentário no banco de dados, já relacionando-o com o post correspondente. Vamos aproveitar e incluir também um método para excluir os comentários indesejados, com o nome de destroy.

Veja o código RUBY

1 2 3 4 5 6 7 8 9 10 11 12 13

class ComentariosController < ApplicationController def create @post = Post.find(params[:post_id]) @comentario = @post.comentarios.create(params[:comentario]) redirect_to post_path(@post) end def destroy @post = Post.find(params[:post_id]) @comentario = @post.comentarios.find(params[:id]) @comentario.destroy redirect_to post_path(@post) end end

Após essas alterações, atualize o navegador para ver como ficou (veja no terminal/prompt se o servidor ainda está rodando). Cadastre alguns comentários para ver funcionando.

Validação no modelo para evitar posts vazios
Apesar do visual não muito parecido com um blog, nossa aplicação já está funcional. Mas vamos aproveitar para conhecer mais algumas funcionalidades que o Rails oferece para nós. Uma delas é a validação de dados, evitando que sua aplicação receba dados inconsistentes. As validações estão relacionadas diretamente aos dados, dessa forma elas são feitas nos modelos.

Vamos aplicar uma validação para que não seja aceito post sem título e sem conteúdo. Até porque um post sem titulo e sem conteúdo não é um artigo válido, certo? Abra o modelo app/models/post.rb e adicione as validações, conforme abaixo.

Veja o código RUBY

1 2 3 4 5

class Post < ActiveRecord::Base has_many :comentarios validates :titulo, :presence => true, :length => { :minimum => 10 } validates :conteudo, :presence => true end

Acabamos de definir que a presença do titulo é obrigatória, além de que deverá ter 10 caracteres no mínimo. O conteúdo apenas tem que obrigatoriamente ser preenchido.

Implementando segurança
Aproveitando outra funcionalidade que o Rails oferece – autenticação HTTP – vamos estabelecer duas simples regras de segurança no nosso blog. Primeiro: Para adicionar um post, o usuário tem que autenticar-se com login e senha. Segundo: Para apagar um comentário, também será necessário autenticação.

Essa regra vai incidir sobre os controles, pois as autenticações serão solicitadas apenas em determinadas ações (métodos). Em vez de implementarmos essa regra noposts_controller.rb e depois repeti-la nos comentarios_controller.rb, vamos adiciona-la uma única vez num lugar onde toda a aplicação poderá enxerga-la. Esse lugar é oapplication_controller.rb, o super-controle cujas regras atingem toda aplicação. Ele evita que você fique espalhando a mesma instrução em vários controles diferentes.

Acesse o arquivo em app/controllers/application_controller.rb e adicione as seguintes linhas:

Veja o código RUBY

1 2 3 4 5 6 7 8 9 10 11 12

class ApplicationController < ActionController::Base protect_from_forgery   private   def autenticacao authenticate_or_request_with_http_basic do |usuario, senha| usuario == 'admin' && senha == 'abracadabra' end end   end

Nas linhas acima, definimos uma regra de autenticação, e já configuramos qual será o usuário/senha. Agora temos que sair inserindo onde essa autenticação será necessária.

A primeira autenticação vai ficar nos posts. Abra o controle app/controllers/posts_controller.rb e acrescente a regra de autenticação logo abaixo da definição de classe. Não apague nada do que está lá, pois os outros métodos ainda serão utilizados.

Veja o código RUBY

1 2 3 4 5 6

class PostsController < ApplicationController before_filter :autenticacao, :except => [:index, :show] # linha adicionada   # GET /posts # GET /posts.xml ...

Perceba que usamos :except, ou seja, a validação será requerida em todos os métodos excetoindex e show. Será solicitado usuário/senha para adicionar, editar e excluir posts.

Agora no controle dos comentários, adicionaremos também a validação. Desta vez, usaremos o parâmetro : only em vez de :except. Abra o app/controllers/comentarios_controller.rb e adicione a linha com a validação.

Veja o código RUBY

1 2 3

class ComentariosController < ApplicationController before_filter :autenticacao, :only => [:destroy] # linha adicionada ...

Melhorando o visual
Por fim, vamos mexer na aparência de nossa aplicação, pois ela parece várias coisas, menos um blog. Como você deve se lembrar do nosso discurso sobre MVC, a parte responsável pelo visual é a view. Nesse exemplo, iremos fazer uma plástica as duas visões mais requisitadas, aindex e a show.

Abra a visão index do post (app/views/posts/index.html.erb), e substitua o código padrão que está lá por este:

Veja o código RUBY

1 2 3 4 5 6 7 8 9 10 11 12 13 14

<h1>Meu Blog</h1>   <% @posts.each do |post| %> <h2><%= link_to post.titulo, post %></h2> <p><%= post.conteudo %></p> <%= link_to 'Ver mais', post %> <%= link_to '[Editar]', edit_post_path(post) %> <%= link_to '[Excluir]', post, :confirm => 'Tem certeza?', :method => :delete %> <hr /> <% end %>   <br />   <%= link_to 'Novo Post', new_post_path %>

Essas poucas linhas irão resolver. Caso você tenha vários posts cadastrados, já perceberá a diferença.

Agora abra a visão show do post (app/views/posts/show.html.erb) e troque o código que está lá por este.

Veja o código RUBY

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

<h1>Meu Blog</h1> <p class="notice"><%= notice %></p>   <h2><%= @post.titulo %></h2> <p><%= @post.conteudo %></p>   <h3>Comentarios</h3> <% @post.comentarios.each do |comentario| %> <p> <b>Autor:</b> <%= comentario.autor %> </p>   <p> <b>Comentario:</b> <%= comentario.conteudo %> </p> <p> <%= link_to 'Apagar Comentario', [comentario.post, comentario], :confirm => 'Tem certeza?', :method => :delete %> </p <hr /> <% end %>   <h3>Adicione um comentario:</h3> <%= form_for([@post, @post.comentarios.build]) do |f| %> <div class="field"> <%= f.label :autor %><br /> <%= f.text_field :autor %> </div> <div class="field"> <%= f.label :conteudo %><br /> <%= f.text_area :conteudo %> </div> <div class="actions"> <%= f.submit %> </div> <% end %>   <br />   <%= link_to 'Editar Post', edit_post_path(@post) %> | <%= link_to 'Voltar aos Posts', posts_path %>

Pronto! Temos um blog funcional desenvolvido em Rails.

O que falta?
Falta trabalhar os menus, um sistema de autenticação mais profissional, um layout mais interessante… Só não falta vontade de aprender, tenho certeza. Com o conhecimento adquirido até aqui, você já é capaz de descobrir muitas coisas sozinho. Reforce seu conhecimento com outros recursos online, eles irão aprofundar mais nos conceitos que abordamos superficialmente.

Além disso, você pode aprender também através de livros. Recomendo o recém-lançadoRails 3 Básico, que você pode comprar com um super desconto na loja virtual da Novatec. O livro é voltado para iniciantes e, apesar do nome, vai além do básico. O conteúdo é bem atualizado e a didática é excelente, tenho certeza de que você irá aprender bastante com ele.

Fonte: Ruby Brasil