Introdução

Neste post iremos abordar Ruby on Rails de uma forma mais prática, criando uma aplicação de exemplo.

Conceitos gerais de Ruby on Rails podem ser vistos no post anterior da série.

Para a instalação do Ruby on Rails, siga os dois primeiros passos das instruções do site oficial: http://www.rubyonrails.com.br/down

Mãos à obra

Agora que você já tem o ambiente de desenvolvimento adequadamente instalado, vamos fazer uma aplicação de exemplo menos comum para este tutorial, fugindo do tradicional exemplo de blogs. Iremos criar um servidor para manipular Geofences.

Para mais informações sobre GeoFences, acesse este site.

Para criar sua aplicação, abra a linha de comando e vá para o diretório de sua preferência para armazenar o projeto. Em seguida, execute o seguinte comando

[code collapse=”false”]rails new geofences -B[/code]

Explicações:

• rails -> Ferramenta de linha de comando disponibilizada pela instalação do Rails (existem mais além dessa).
• new -> Comando de criação de uma nova aplicação.
• geofences -> diretório em que será criado o projeto.
• -B -> Argumento passado para que o comando

  [code collapse=”false”]bundle install[/code]

  não seja executado no final da criação da aplicação

Bundler é uma ferramenta para administrar dependências durante o desenvolvimento de uma aplicação Ruby. Ele lê o arquivo Gemfile, que deve estar presente no diretório raíz de sua aplicação, que contém informações das gems que setão utilizadas. O arquivo já contém várias gems iniciais, e você certamente irá modificar este arquivo frequentemente para adicionar, remover ou editar gems de seu projeto.

O comando

[code collapse=”false”]bundle install[/code]

irá baixar e instalar as gems do arquivo, e ele é normalmente executado automaticamente com o comando de criação de um novo projeto para que as gems iniciais já estejam disponíveis. Você pode querer editar as gems antes mesmo da primeira instalação, por isso o argumento -B foi passado no momento da criação do projeto.

Execute, então, na linha de comando, o comando anteriormente ignorado:

[code collapse=”false”]bundle install[/code]

Se você usa Git, é um bom momente para inicializar o repositório e fazer seu primeiro commit.

Mesmo sem escrever uma linha de código em Ruby, você já pode inicializar o servidor. Para fazer isso, execute o seguinte comando:

[code collapse=”false”]rails server[/code]

ou abreviadamente:

[code collapse=”false”]rails s[/code]

Neste ponto, você já é capaz de abrir seu browser na paǵina padrão do Rails rodando sua aplicação. Para fazê-lo acesse http://localhost:3000

Desligue o servidor pressionando CTRL + C na linha de comando em que ele está rodando.

Pequena introdução o padrão de projeto MVC

Rails é definido como um framework MVC (abreviação para “Model-View-Controller”). Isso quer dizer que o comportamento da aplicação segue o seguinte padrão:

• Model -> Manipula dados entre o banco de dados e o resto da aplicação. Você pode definir como uma entidade se comporta, como validações ou atividades a serem feitas antes ou depois de salvar um dado no banco de dados, por exemplo.
• View -> A visualização de uma requisição. Geralmente é uma página HTML, mas pode ser também, JSON ou XML, como veremos mais adiante.
• Controller -> Esta é a junção entre os dados manipulados pelos Models e o que é realizado nas Views, Requisições HTTP que chegam à sua aplicação são enviadas a um Controller que geralmente irá interagir com um ou mais Models e finalmente renderizar o resultado com uma resposta HTTP

Esta é apenas uma versão simples da definição deste padrão de projetos, mas já dá uma ideia de como as coisas funcionam.

Criando nosso recurso

Vamos criar agora nosso recurso de Geofence, que é o dado que nossa aplicação deve manipular.

Por questões de simplificação, começaremos fazendo apenas um Geofence circular com as coordenadas do centro, o raio e um nome para definí-lo.

Execute o seguinte comando:

[code collapse=”false”]rails generate scaffold geofence name:string lat:float lon:float radius:float[/code]

Desta vez utilizamos o comando

[code collapse=”false”]rails generate[/code]

para gerar um scaffold que cria todos os arquivos e códigos necessários para todo o MVC que manipula um Geofence.

Passamos como parâmetro o nome do dado que queremos guardar e seus atributos com seus respectivos tipos.

Migration

Entre os códigos criados pelo comando está nossa database migration, script que manipula mudanças no banco de dados. O arquivo se encontra no diretório geofences/db/migrate.

Abrindo o arquivo, encontramos o seguinte código:

[code collapse=”false” language=”ruby”]
class CreateGeofences < ActiveRecord::Migration
def change
create_table :geofences do |t|
t.string :name
t.float :lat
t.float :lon
t.float :radius

t.timestamps
end
end
end

[/code]

Mesmo sendo fácil de ler e entender o código aceima, ele basicamente significa:

• Criar uma tabela de geofences no banco de dados (Note que o nome da tabela está no plural).
• Possui os campos que definimos no comando de criação (name, lat, lon e radius).
• Também possui timestamps padrões criados e manipulados pelo Rails (created_at e updated_at)

Um pequeno detalhe é que queremos utilizar maior precisão com nossas coordenadas e com o raio, mas não podemos simplesmente definí-los como “double”, mas para fazer essa mudança, precisamos apenas adicionar um pequeno código para mudar a precisão de nossos atributos.

O código resultante será:

[code collapse=”false” language=”ruby”]
t.float :lat, :limit => 53
t.float :lon, :limit => 53
t.float :radius, :limit => 53
[/code]

Mesmo com tudo isso pronto, nosso banco de dados ainda não sabe dessas mudanças. Para que elas se apliquem, devemos executar o seguinte comando:

[code collapse=”false”]rake db:migrate[/code]

Rake é outra ferramenta de linha de comando comum no mundo Ruby e funciona como um Makefile de Ruby. Rails possui várias tarefas rake prontas para serem utilizadas, mas ainda é possível criar suas próprias tarefas se necessário.

Neste caso, apenas aplicamos a migration no banco de dados com o argumento db:migrate.

Model

Nosso modelo para Geofence se encontra em geofences/app/models, mas ao abrí-lo, você deve encontrar apenas a definição de classe, herdando de ActiveRecord::Base, e mais nada.

[code collapse=”false” language=”ruby”]
class Geofence < ActiveRecord::Base
end
[/code]

Testando o banco de dados

Mesmo não tendo nenhuma linha de código no modelo, ele já sabe como interagir internamente com o banco de dados. Para mostrar isso, vamos à linha de comando e executar o seguinte comando:

[code collapse=”false”]rails console[/code]

ou abreviadamente:

[code collapse=”false”]rails c[/code]

Agora estamos numa linha de comando capaz de executar comandos diretamente na nossa aplicação Rails. Primeiramente, vamos nos conectar ao banco de dados com o comando:

[code collapse=”false”]Geofence.connection[/code]

Agora que estamos conectados ao bando de dados, execute o seguinte comando para ver os campos e seus respectivos tipos do banco de dados:

[code collapse=”false”]Geofence[/code]

Repare que o próprio Rails já criou (e administra) uma coluna para id, created_at e updated_at.

Vamos agora criar um Geofence de exemplo:

[code collapse=”false”] Geofence.create(name: "Primeiro Geofence", lat: 1, lon: 2, radius:10) [/code]

Você pode ver como resultado o código SQL gerado para criar o dado na tabela. Para confirmar que o dado foi criado, digite o comando

[code collapse=”false”]Geofence.count[/code]

para ver quantos itens estão presentes na tabela.

Para sair do console, digite

[code collapse=”false”]exit[/code]

Controller

Vamos verificar nosso controller em geofences/app/controllers.

Ao contrário do que aconteceu com o model, Rails criou vários métodos no controller (denominados “actions”). Cada um corresponde a um caminho HTTP (exemplo: /geofences) e um verbo HTTP (GET, POST, PUT, DELETE).

O código em si é bem claro e fácil de entender, mas vou reforçar alguns pontos:

• Não há especificações de como renderizar uma View no código gerado. A razão disso é que as views são baseadas nas actions do controller. Por exemplo: GeofencesController#show irá renderizar o template localizado em app/views/geofences/show.html.erb.
  Veja as views em geofences/app/views/geofences para ter uma ideia das views que serão utilizadas, uma vez que não são todas as actions que correspondem a um template específico.
• Rails já gera o código com suporte a JSON, que será exemplificado mais pra frente neste tutorial.
• Existe um código de proteção contra SQL Injection no controller gerado:

  [code collapse=”false” language=”ruby”]
  def geofence_params
  params.require(:geofence).permit(:name, :lat, :lon, :radius)
  end
  [/code]

  Este código faz com que se respeite apenas os comandos de alterar dados nos campos especificados, evitando que usuários maliciosos tentem executar comandos indesejados em seu banco de dados.

Routes

Ao gerar geofences, Rails já cuidou de alterar o arquivo geofences/config/routes.rb, adicionando a linha

[code collapse=”false”]resources :geofences[/code]

, que basicamente quer dizer para o Rails usar as rotas padrões de REST para o recurso geofences.

Inicie o servidor novamente:

[code collapse=”false”]rails s[/code]

Entre na página http://localhost:3000/geofences

Vamos adicionar a seguinte linha de código no arquivo routes.rb para que a primeira página (http://localhost:3000/) a ser exibida em nossa aplicação seja a lista de geofences no banco de dados:

[code collapse=”false” language=”ruby”]root ‘geofences#index'[/code]

Se você entrar na página http://localhost:3000/ novamente, verá que a página mostrada é a mesma que http://localhost:3000/geofences. Isso acontece porque definimos que o endereço “root” de nossa aplicação será a action ‘index’ do controller de geofences.

Conclusão

Para finalizar este tutorial, entre na página http://localhost:3000/geofences.json e verá que os dados já são retornados em JSON.

Tudo isso funcionando apropriadamente e mal escrevemos código em Ruby.

No próximo tutorial, iremos refinar um pouco mais nossa aplicação.