O Rails é um framework completo com diversos componentes que permitem que os desenvolvedores Ruby criem qualquer tipo de aplicação voltada para a web. A linguagem Ruby é utilizada para criar todos esses componentes do Rails. Entre os componentes do Rails tem-se o ActionPack para geração de páginas interativas, um servidor de aplicação embutido que será o responsável por exibir as aplicações desenvolvidas com Rails, banco de dados SQLite3 muito utilizado para a fase de desenvolvimento das aplicações, biblioteca para mapeamento objeto-relacional, ferramentas para gerenciar a aplicação, além de diversas outros componentes.

Para trabalhar com Rails basta acessar o site http://www.railsinstaller.org/pt-BR e baixar o pacote completo que traz o Ruby e o Rails no mesmo produto. Esse pacote já inclui a versão correta do Ruby e do Rails.

Ainda é recomendado baixar o pacote que traz o Ruby 1.9 por ser mais estável. Para baixar o Ruby 1.9 que traz o Rails 3.x basta visitar o endereço https://s3.amazonaws.com/railsinstaller/Windows/railsinstaller-2.2.5.exe.

Criando uma aplicação web manualmente

Para criar uma aplicação web com deve-se primeiramente abrir o prompt de comando e navegar até a pasta bin do Ruby e digitar o comando rails seguido pelo nome da aplicação, conforme mostra o exemplo abaixo:


  c:\>rails new c:\appwebmanual
        create
        create  README.rdoc
        create  Rakefile
        create  config.ru
        create  .gitignore
        create  Gemfile
        create  app
        create  app/assets/images/rails.png
        create  app/assets/javascripts/application.js
        create  app/assets/stylesheets/application.css
        create  app/controllers/application_controller.rb
        create  app/helpers/application_helper.rb
        create  app/mailers
        create  app/models
        create  app/views/layouts/application.html.erb
        create  app/mailers/.gitkeep
        create  app/models/.gitkeep
        create  config
        create  config/routes.rb
        create  config/application.rb
        create  config/environment.rb
        create  config/environments
        create  config/environments/development.rb
        create  config/environments/production.rb
        create  config/environments/test.rb
        create  config/initializers
        create  config/initializers/backtrace_silencers.rb
        create  config/initializers/inflections.rb
        create  config/initializers/mime_types.rb
        create  config/initializers/secret_token.rb
        create  config/initializers/session_store.rb
        create  config/initializers/wrap_parameters.rb
        create  config/locales
        create  config/locales/en.yml
        create  config/boot.rb
        create  config/database.yml
        create  db
        create  db/seeds.rb
        create  doc
        create  doc/README_FOR_APP
        create  lib
        create  lib/tasks
        create  lib/tasks/.gitkeep
        create  lib/assets
        create  lib/assets/.gitkeep
        create  log
        create  log/.gitkeep
        create  public
        create  public/404.html
        create  public/422.html
        create  public/500.html
        create  public/favicon.ico
        create  public/index.html
        create  public/robots.txt
        create  script
        create  script/rails
        create  test/fixtures
        create  test/fixtures/.gitkeep
        create  test/functional
        create  test/functional/.gitkeep
        create  test/integration
        create  test/integration/.gitkeep
        create  test/unit
        create  test/unit/.gitkeep
        create  test/performance/browsing_test.rb
        create  test/test_helper.rb
        create  tmp/cache
        ...

Caso o Rails esteja no classpath não é necessário navegar até a pasta bin do Ruby, basta digitar diretamente o comando no prompt. Porém, se for necessário é preciso navegar até a basta bin do Ruby utilizando o comando cd c:\Ruby22\bin e depois executar o comando acima. Vale ressaltar que a pasta pode ser outra se a versão Ruby for diferente desta.

Basicamente entre os diretórios criados tem-se que o diretório app contém os controller, models, views e outros artefatos da aplicação, o diretório config possui as configurações da aplicação como roteamentos que serão utilizados em nosso exemplo, e o diretório db que contém o esquema da base de dados utilizada pela aplicação. Esses três diretórios já foram criados pelo comando acima e serão essenciais para configurarmos uma aplicação manualmente no Rails.

Com isso a aplicação web será gerada em uma nova pasta chamada "appwebmanual". Dessa forma, com o comando acima temos gerado todo o esqueleto necessário para a aplicação.

Também é possível indicar o caminho onde a aplicação será criada, isso é realizado quando se define o nome da aplicação, conforme o exemplo acima em que especificamos o caminho “c:\”, caso contrário a aplicação será criada no diretório corrente do prompt.

Para criar os artefatos básicos de uma aplicação como as páginas para editar, deletar, listar, consultar e criar registros basta utilizar o comando scaffold.

O scaffolding é uma ferramenta do Rails que gera rapidamente todo o código e as páginas necessárias para uma aplicação. Dessa forma, o scaffolding minimiza bastante o tempo dos desenvolvedores para criar todas as funcionalidades que uma aplicação exige como os controllers, models e todas as views da aplicação. Além disso, a ferramenta também ajuda a criar a tabela do banco de dados que irá armazenar essas informações.

No entanto, nem sempre é preciso que todas essas funcionalidades estejam disponíveis. Por exemplo, às vezes torna-se necessário apenas ter uma única página com consulta, ou com algumas funcionalidades. Por isso, se faz necessário conhecer como pode-se criar uma aplicação web manualmente sem a interferência de ferramentas.

Primeiramente deve-se saber que a aplicação precisa de um Routing que associa uma URL com a aplicação, um Model que está associado com uma tabela da base de dados, um Controller que recebe os dados do Model e envia para a View e a View que apresenta as informações ao usuário.

Inicialmente é interessante começar criando o Model, visto que ele afeta diretamente o Controller e a View.

Dessa forma, começaremos a montar uma aplicação passo a passo que mostra alguns anúncios que são registrados na base de dados por um operador. Assim, para criar o Model basta utilizar o comando a seguir:


  c:\appwebmanual>rails generate model anuncio nome:string descricao:text preco:decimal venda_id:integer email:string img_url:string
        invoke  active_record
        create    db/migrate/20160112020358_create_anuncios.rb
        create    app/models/anuncio.rb
        invoke    test_unit
        create      test/unit/anuncio_test.rb
        create      test/fixtures/anuncios.yml

O comando apresentar cria dois scripts dentro do diretório app e db, são eles: o script db/migrate/20160112020358_create_anuncios.rb e app/models/anuncio.rb. O migration é um script em Ruby que pode se conectar com a base de dados e criar a tabela para a aplicação de anúncios. Para executar este script para utilizar o comando rake conforme a seguir:

c:\appwebmanual>rake db:migrate

Este comando executa o script e cria a tabela. Se tudo for criado corretamente o prompt exibirá o log a seguir:

==  CreateAnuncios: migrating =================================================
  -- create_table(:anuncios)
     -> 0.0060s
  ==  CreateAnuncios: migrated (0.0100s) ========================================

O interessante é que três colunas a mais foram criadas nesta tabela, são eles: id, created_at e updated_at. A coluna id é uma chave primária gerada, e as colunas created_at e updated_at são registros que gravam quando o dado é inserido e atualizado. Esses dois registros são utilizados normalmente para auditoria.

Segue na Figura 1 como está a tabela do banco de dados.

Figura 1. Tabela do Banco de Dados com as respectivas colunas.

Para verificar a base de dados é possível fazer o download de um add-in para o Firefox chamado SQLite Manager. Esse add-in permite abrir o arquivo e realizar operações no banco de dados. Para fazer o download deste ad-in basta ir em “Ferramentas” no Firefox e clicar em “Complementos” conforme a Figura 2.

Figura 2. Acessando os complementos o Firefox.

Após isso basta pesquisar pelo nome e instalar o complemento conforme a Figura 3.

Figura 3. Procurando pelo complemento a ser instalado.

Agora basta acessar o menu ferramentas novamente e clicar em SQLite Manager que foi recentemente instalado, como mostra a Figura 4.

Figura 4. Acessando o SQLite Manager no Firefox.

Com isso o SQLite Manager será aberto e exibirá a tela conforme a Figura 5.

Figura 5. Tela inicial do SQLite Manager.

O primeiro passo agora é se conectar com a base de dados do SQLite. Para isso basta ir no menu superior em “Database” e depois na opção “Connect Database” conforme a Figura 6.

Figura 6. Realizando a conexão com o banco de dados SQLite.

Feito isso basta ir até o diretório db e selecionar o arquivo do SQLite conforme mostra a Figura 7.

Figura 7. Selecionando o arquivo do SQLite que contém a base de dados da aplicação.

Agora já é possível realizar operações na base de dados.

Para fazer uma inserção deve-se ir em “Execute SQL” e inserir o comando SQL conforme a Figura 8.

Figura 8. Criando um registro na base de dados SQLite.

Por fim, basta clicar no botão “Run SQL” para o comando ser executado.

Para verificar se o registro foi inserido basta inserir a consulta “SELECT * FROM anuncios” na mesma janela e clicar no botão “Run SQL”. Se o registro for exibido ele foi inserido com sucesso conforme mostra a Figura 9.

Figura 9. Realizando uma seleção para listar o registro incluído no comando anterior.

Agora que o Model foi criado e o banco de dados já está populado com um registro já é possível criar o Controller.

Assim como o Model pode-se gerar o Controller, porém utilizando o comando controller. O comando a ser utilizado é dado conforme abaixo:


  c:\appwebmanual>rails generate controller anuncios
        create  app/controllers/anuncios_controller.rb
        invoke  erb
        create    app/views/anuncios
        invoke  test_unit
        create    test/functional/anuncios_controller_test.rb
        invoke  helper
        create    app/helpers/anuncios_helper.rb
        invoke    test_unit
        create      test/unit/helpers/anuncios_helper_test.rb
        invoke  assets
        invoke    coffee
        create      app/assets/javascripts/anuncios.js.coffee
        invoke    scss
        create      app/assets/stylesheets/anuncios.css.scss

Pode-se notar que o nome do Controller está no plural, diferente no Model que usamos o nome no singular. A convenção do Rails solicita que seja utilizado o nome do Model no singular e do Controller e tabelas do banco de dados no plural. É sempre muito importante seguir as convenções do Rails garantindo assim uma aplicação padronizada e organizada por parte de todos os desenvolvedores da plataforma.

O comando acima gerou a classe Controller no caminho app/controllers/anuncios_controller.rb. Acessando o arquivo do Controller gerado pode-se verificar o código gerado conforme a Listagem 1.

Listagem 1. Código do Controller criado pela ferramenta do Rails.


  class AnunciosController < ApplicationController
  end

O "class" apresentado indica o início do código do Controller, o "AnunciosController" é o nome do Controller, e "ApplicationController" indica o tipo de aplicação Controller. Pode-se notar que o nome do arquivo (anuncios_controller) é similar ao nome da classe (AnunciosController), mas a classe separou os nomes com letras maiúsculas e minúsculas. Por fim, o "end" indica o fim do código do Controller.

Agora já é possível criar a View. Para o nosso exemplo será criado apenas uma página simples que será utilizada como template para todos os anúncios no site. Os templates são criados pelo Embedded Ruby (chamado de ERb) que é parte da biblioteca padrão do Ruby. O ERb basicamente gera a página HTML para o anúncio usando o template e a informação do Model.

Quando o Model e o Controller foram gerados o Rails gerou um código Ruby. No entanto, com a View isso é um pouco diferente, pois a View tem uma interface HTML. Dessa forma, para criar um template é preciso abrir um editor de texto e criar um arquivo chamado show.html.erb e salvá-lo em app/views/anuncios. Segue na Listagem 2 o código do template que nada mais é do que um arquivo com tags HTML.

Listagem 2. Código do template show.html.erb.


  <html>
  <head>
           <title></title>
  </head>
  <body>
           <p>
                     <b>Nome:</b>
           </p>
           <p>
                     <b>Descrição:</b>
           </p>
           <p>
                     <b>Preço:</b>
           </p>
           <p>
                     <b>Venda Id:</b>
           </p>
           <p>
                     <b>Email:</b>
           </p>
  </body>
  </html>

Assim, o ERb criará as páginas através deste template.

A View possui a extensão “.erb” porque precisa interpretar instruções do Ruby que serão processados pelo Embedded Ruby. Alguns desses comandos serão vistos mais adiante no artigo.

O Rails ainda precisa de uma regra que diga qual código executar quando fornecida uma URL. Assim sendo, o Rails utiliza o routes para mapear a URL para o código que fará o processamento da requisição. O routes é definido no Ruby em config/routes.rb.

Dessa forma, é preciso adicionar uma nova rota para o template show.html.erb conforme a Listagem 3.

Listagem 3. Alterando o arquivo de rotas do Rails.


  Appwebmanual::Application.routes.draw do
           match "/anuncios/:id" => "anuncios#show"
  end

Para evitar erros na página inicial deve-se trocar em “\app\views\layouts” no arquivo “application.html.erb” as duas entradas de application por default nas linhas 5 e 6.

Agora basta iniciar o servidor web conforme comando a seguir:


  c:\>cd appwebmanual
  c:\appwebmanual>rails server
  => Booting WEBrick
  => Rails 3.2.21 application starting in development on http://0.0.0.0:3000
  => Call with -d to detach
  => Ctrl-C to shutdown server

E no Browser digitar a URL localhost:3000/anuncios/1. Após isso será exibida a tela da Figura 10.

Figura 10. Acessando a página da aplicação.

Basicamente quando digitamos a URL no browser o Rails recebe uma requisição e passa o caminho do da requisição para o routes.rb que se encarregará de procurar uma rota correspondente. A rota especificada anteriormente possui os símbolos :id, :controller e :action que apontam para o caminho especificado. Assim, dado que a URL é “anuncios/1” tem-se que o id é 1, anuncios é o Controller conforme está configurado na rota e show é o Action que será chamado conforme também especificado no arquivo de rotas. Com isso o Rails sabe que deve chamar o Controller anuncios_controller.rb e a action chamada show passando o parâmetro id para ele. Após isso, o Rails processa a requisição e chama a View “show.html.erb” para exibir os resultados no browser. O Model é o responsável por buscar os dados necessários no Banco de Dados e enviar o resultado de volta para o Controller. O Controller por sua vez armazena as informações retornadas na sua memória, mantendo os dados na variável @anuncio que será configurada posteriormente. Assim, o template tem acesso a essa variável e pode usá-la para exibir os dados retornados.

Embora foram adicionados apenas os elementos principais da página HTML, ainda é preciso adicionar os dados necessários.

Assim, a View precisa saber onde exibir os dados com os respectivos labels. Como sabemos os dados estão na variável @anuncio, portanto alteramos o código do template para exibir os dados conforme o código da Listagem 3.

Listagem 3. Alterando a página show para exibir os dados do Model.


  <html>
  <head>
           <title><%= @anuncio.nome %></title>
  </head>
  <body>
           <p>
                     <b>Nome:</b> <%= @anuncio.nome %>
           </p>
           <p>
                     <b>Descrição:</b> <%= @anuncio.descricao %>
           </p>
           <p>
                     <b>Preço:</b> <%= @anuncio.preco %>
           </p>
           <p>
                     <b>Venda Id:</b> <%= @anuncio.venda_id %>
           </p>
           <p>
                     <b>Email:</b> <%= @anuncio.email %>
           </p>
  </body>
  </html>

Também será necessário definir o action “show” no Controller, este método será responsável por chamar o Model passando o id recebido na URL. Segue na Listagem 5 o código do Controller.

Listagem 5. Código do Controller com o método show definido.


  class AnunciosController < ApplicationController
           def show
                     @anuncio = Anuncio.find(params[:id])
           end
  end

Agora acessando novamente a URL localhost:3000/anuncios/1 recebemos no browser a tela conforme a Figura 11.

Figura 11. Acessando a aplicação passando como parâmetro um id registrado no banco de dados.

O ERb será responsável por ler o template acima olhando principalmente as expressões dentro de "<%=" e "%>". Assim, o ERb processa essas informações e substitui a expressão pelos seus respectivos valores.

Ficar digitando o id na URL não é interessante para os usuários da aplicação, por isso o mais interessante é criar uma página index com uma página mais amigável e que os usuários não precisem digitar o id dos produtos. Para isso primeiramente é necessário mudar o arquivo route apontando para o index conforme a Listagem 5.

Listagem 5. Arquivo route alterado com informações da nova página criada.


  match "/anuncios/" => "anuncios#index"
  match "/anuncios/:id" => "anuncios#show"

Agora é preciso criar o código index no Controller e o template HTML chamado index.

Portanto, vamos criar uma página index que exibirá todos os registros do banco de dados. Também serão criados links para todas as páginas da base de dados. Para isso é necessário criar uma nova action para o Controller.

Primeiramente vamos alterar o código do Controller inserindo o código da index conforme a Listagem 6.

Listagem 6. Alterando o Controller para processar informações para a index.


  class AnunciosController < ApplicationController
   
           def show
                     @anuncio = Anuncio.find(params[:id])
           end
   
           def index
                     @anuncios = Anuncio.find(:all)
           end
   
   
  end

Com isso será retornado um único objeto contendo todos os registros na tabela da base de dados, esse objeto é um Array.

Por fim, podemos criar a página index que percorrerá todo o array e exibirá os resultados para o usuário conforme mostra o código da Listagem 7.

Listagem 7. Criando um template para a página index.


  <html>
  <head>
           <title>Todos Anúncios</title>
  </head>
  <body>
           <h1>Todos Anúncios</h1> 
   
           <ul>
           <% for anuncio in @anuncios %>
                     <li> <a href="/anuncios/<%=anuncio.id%>"> <%=anuncio.nome%> </a> </li>
           <% end %>
           </ul>
  </body>
  </html>

Agora podemos apenas acessar a URL localhost:3000/anuncios e tem-se como resultado a página exibida conforme a Figura 12.

Figura 12. Página inicial exibindo os registros da base de dados.

Clicando sobre o item tem-se como resultado os detalhes do item sendo exibido na próxima página conforme Figura 13.

Figura 13. Acessando os detalhes dos registros exibidos na página index.

Com isso, a aplicação está pronta, apesar de ser mais trabalhoso desenvolver sem o scaffolding o programador tem um maior controle de cada passo que é desenvolvido.

Bibliografia

[1] Jay McGavren. Head First Ruby (O’Reilly, 2015).

[2] Ruby Programming Language
https://www.ruby-lang.org/.

[3] David Griffiths. Head First Rails (O’Reilly, 2015).