Rails básico (cont.): helpers, validações, migrations e partial

Continuando a série de posts sobre Rails, vamos dar uma olhada em mais alguns recursos básicos da linguagem. Se você não viu o post anterior, então dê uma olhada aqui: Rails básico: MVC, scaffold e migrations, pois vamos utilizar o projeto inicialmente construído.

Um pouco mais sobre helpers

No post anterior vimos o que são helpers e como eles podem atuar de maneira prática. Vamos então utilizar o helper dos contatos para formatar o número do telefone dos nossos contatos. Primeiro rode o servidor (‘rails server’) e adicione algum contato na agenda, lembre de utilizar um número de telefone válido, no caso que tenha os dois dígitos do DDD e os oito dígitos do número em si(mais na frente vamos ver como garantir isso).

Note como fica o número do telefone. Seria interessante adicionarmos os parênteses no DDD por exemplo, ou colocar um hífen separando o 4 primeiros e 4 últimos dígitos. Vamos então criar um método no helper para formatar o número, este método vai receber uma string como parâmetro, que será a string do número do telefone, e vai formatá-la da seguinte forma: (##)####-####. Abra então o arquivo ‘contatos_helper.rb’ na pasta ‘app/helpers’ e adicione o método:

  def formata_telefone(n_telefone)
    tel_formatado = "("
    tel_formatado << n_telefone[0..1]
    tel_formatado << ")"
    tel_formatado << n_telefone[2..5]
    tel_formatado << "-"
    tel_formatado << n_telefone[6..9]
    tel_formatado
  end

Este método é uma solução bem simples, criamos uma nova string e copiamos o conteúdo para um nova string formatada. Ao utilizar, por exemplo ‘n_telefone[2..5]’ estamos extraindo os caracteres iniciando na casa 2 até a casa 5 da string ‘n_telefone’. O operador ‘<<' faz um append na string, como se fosse o append do StringBuilder no java.

Com o método pronto, basta fazer a chamada ao método nas views dos contatos. Abra então o arquivo 'index.html.erb' na pasta 'app/views/contatos' e altere o código onde é exibido o número do telefone:

...
<% @contatos.each do |contato| %>
  <tr>
    <td><%= contato.nome %></td>
    <td><%= formata_telefone(contato.telefone) %></td>
...

Agora adicione também o código na view show. Abra o arquivo 'show.html.erb' na mesma pasta e altere o código:

...
  <b>Telefone:</b>
  <%= formata_telefone(@contato.telefone) %>
...

Pronto, agora recarregue a página http://localhost:3000/contatos e você deverá ver os números formatados. Ao clicar no botão 'Show' de algum contato, também será exibido o número formatado.

Validação personalizada

Discutimos antes que o projeto como está permite adicionar qualquer string como número do telefone, além de não fazer nenhuma restrição ao tamanho do telefone. Vamos então criar algumas validações para verificar estas situações.

Como as validações devem estar nos arquivos do modelo, abra o arquivo ‘contato.rb’ na pasta ‘app/models’. Nele, devem estar até agora as validações de presença que adicionamos no post anterior, agora vamos criar nossa própria validação. Adicione o seguinte código dentro da classe:

  validate :eh_numero
  private
  def eh_numero
    errors.add("telefone", " - Deve ser um numero") unless telefone =~ /^[\d]+$/
  end

Aqui estamos dizendo que o Rails deve validar o método ‘eh_numero’. Dentro deste método estamos utilizando a estrutura ‘unless’ do Ruby, que executa a ação da esquerda, a menos que a condição da direita seja verdadeira.

Outro operador é o ‘=~’ que serve para comparar strings com expressões regulares, neste caso esta expressão apenas garante que a string deve ser formada de um ou mais números.

Então, a menos que a string ‘telefone’ seja formada por números, será adicionado um erro na pilha de erros do Rails, através da chamada a ‘errors.add()’.

Para testar se tudo funcionou, volte na página e tente adicionar como telefone uma string qualquer que contenha uma letra. Será então exibida a mensagem de erro no topo da tela.

Agora, precisamos garantir que a string tenha um tamanho de 10, para indicar um número de telefone. Vamos então adicionar outra validação, seguindo a mesma ideia do exemplo anterior:

 validate :tem_dez_digitos
...
  def tem_dez_digitos
    errors.add("telefone", " - Deve ter dez digitos") unless telefone.size == 10
  end

Aqui utilizamos a mesma estrutura, agora verificando se o tamanho do telefone é igual a 10. Tente agora adicionar um novo contato com menos de dez dígitos e a mensagem deverá ser exibida.

A ideia aqui foi mostrar como adicionar validadores personalizados, no entanto o Rails oferece vários validadores para evitar este trabalho. Um exemplo é o validador ‘validates_format_of’ que verifica o formato de uma string com uma expressão regular. Poderíamos então substituir o nosso validador personalizado por este, bastando apenas uma linha:

  validates_format_of :telefone, :with => /^[\d]+$/, :message => " - Deve ser um numero"

Outro validador que poderia nos poupar trabalho é o ‘validates_length_of’ que verifica o tamanho de uma string:

  validates_length_of :telefone, :is => 10, :message => " - Deve ter dez digitos"

Além do ‘:is’, este validador aceita parâmetros como ‘:maximum’, ‘:minimum’, ‘:in’, entre outros. Uma visita na página da API do Rails (http://apidock.com/rails/ActiveModel/Validations) vai lhe dar uma visão bem melhor sobre todas as validações do framework.

Um pouco mais sobre Migrations

No post anterior, vimos que o ‘scaffold’ cria uma migration para construir a tabela da entidade. Vamos então criar nossa própria migration. Para exemplificar, vamos supor que agora precisamos armazenar também os e-mails dos contatos, ou seja, vamos alterar a base de dados, e para isto precisamos utilizar uma migration. Vá na raiz do projeto e execute o comando:

$>rails generate migration add_column_email_contatos

Então, dentro da pasta ‘app/db/migrate’ será criado um arquivo com um timestamp seguido da descrição que adicionamos. No meu caso ficou assim: ‘20120217133753_add_column_email_contatos.rb’. Abra o arquivo e você verá que dois métodos estão criados, o ‘up’ e o ‘down’. O método ‘up’ é chamado para alterar a base de dados, já o método ‘down’ é chamado para desfazer a alteração na base de dados. Como queremos adicionar uma coluna, insira o código dentro da classe:

  def up
    add_column :contatos, :email, :string
  end

  def down
    remove_column :contatos, :email
  end

No método ‘up’ adicionamos na tabela contatos a coluna email que é uma string. Já no método ‘down’ removemos da tabela contatos a coluna email. Execute agora a migration, com o seguinte comando:

%>rake db:migrate

Se vocẽ acessar o banco de dados, verá que as mudanças foram feitas.

$> mysql -u root
mysql> use minha_agenda_development
mysql> describe contatos;
+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| id         | int(11)      | NO   | PRI | NULL    | auto_increment |
| nome       | varchar(255) | YES  |     | NULL    |                |
| telefone   | varchar(255) | YES  |     | NULL    |                |
| created_at | datetime     | NO   |     | NULL    |                |
| updated_at | datetime     | NO   |     | NULL    |                |
| email      | varchar(255) | YES  |     | NULL    |                |
+------------+--------------+------+-----+---------+----------------+
6 rows in set (0.00 sec)

No entanto, ao acessar as páginas, não existe nada sobre o campo ‘email’. Precisamos então alterar as views! Abra o aquivo ‘index.html.erb’ na pasta ‘app/views/contatos’ e adicione um ‘th’ com o nome ‘Email’ e um ‘td’ para exibir ‘contato.email’:

...
    <th>Nome</th>
    <th>Telefone</th>
    <th>Email</th>
...
    <td><%= contato.nome %></td>
    <td><%= formata_telefone(contato.telefone) %></td>
    <td><%= contato.email %></td>
...

Pronto, na view index será exibido o campo email dos contatos. Agora abra o arquivo ‘show.html.erb’ e adicione um ‘p’ para exibir o email, seguindo o modelo dos outros atributos:

...
<p>
  <b>Email:</b>
  <%= @contato.email %>
</p>
...

Pronto, agora a view show também exibe o email. No entanto, as views que contém formulários (new e edit) ainda não foram alteradas. Vamos ver então um pouco sobre partial.

Partial

Partial são fragmentos de códigos ‘.html.erb’ que podem ser incluídos na view. Assim é possível reutilizar visualizações. Todo partial começa com um ‘_’ e se você observar, na pasta ‘app/views/contatos’, existe um arquivo chamado ‘_form.html.erb’. Este arquivo é um partial que contém a visualização de um formulário de cadastro da entidade Contato e é chamado nas views new e edit.

Abra o arquivo ‘_form.html.erb’ e note que o campos são exibidos dentro de divs com a classe ‘field’. Adicione então uma nova div para exibir no formulário o campo email, seguindo o modelo dos outros atributos:

...
  <div class="field">
    <%= f.label :email %><br />
    <%= f.text_field :email %>
  </div>
...

Agora abra o arquivo ‘new.html.erb’ e veja que ele chama o método render, passando como parâmetro ‘form’ que é o nome do partial, sem o ‘_’. Este método vai então renderizar este partial dentro da página. A view edit também faz a mesma chamada. Portanto, ao alterar o partial ‘_form.html.erb’ será exibido o campo ‘email’ em ambas as views.

Fica como exercício agora aplicar as validações do campo e-mail. Um dica é procurar por expressões regulares (regex) pois facilita bastante o trabalho!

A partir deste pequeno exemplo é possível ver quão rápido é o desenvolvimento WEB com Rails. O foco aqui foi o lado servidor, por isso não fizemos nenhuma customização com CSS ou JavaScript nas views, no entanto este trabalho também é bem facilitado pelo Rails, basta pesquisar um pouco para encontrar várias Gems que oferecem recursos poderosos com JS, como validação no lado cliente, máscaras, etc.

Se gostou do post compartilhe com seus amigos e colegas, senão, comente o que pode ser melhorado. Encontrou algum erro no código? Comente também. Possui alguma outra opinião ou alguma informação adicional? Comenta ai! 😀

Rails básico: MVC, scaffold e migrations

Neste post vamos implementar um aplicativo de agenda de contatos pessoal bem simples, mas vamos conseguir explorar algumas funcionalidades interessantes deste framework. Caso tenha dúvidas ou problemas sobre a instalação do Rails, dê uma olhada no post anterior Rails: instalando e executando! (Linux).

Só para avisar que este post é um tutorial bem básico sobre Rails, então quem não sabe nada ainda sobre o framework vai aproveitar bastante.

Definindo as funcionaldiades

Como o nosso aplicativo é bem simples, vamos definir algumas poucas funcionalidades: como dono da agenda eu preciso cadastrar, editar, ver e remover contatos da agenda, ou seja um CRUD (Create, Retrieve, Update e Delete) de contatos. Cada contato deve possuir, por enquanto, apenas um Nome e um Número de Telefone. Para simplificar vamos tratar os dois como string.

O primeiro passo é criar a aplicação Rails, para tanto vá na pasta do seu workspace e execute o comando:

$>rails new minha_agenda -d=mysql
$>cd minha_agenda/

A opção ‘-d=mysql’ diz para utilizar como banco de dados o MySQL, caso não queira utilizá-lo, basta não adicionar a opção que será utilizado o banco SQLite padrão de aplicações Rails.

Após a criação do app execute ‘rails server’ para verificar se tudo está funcionando. Acesse http://localhost:3000/ e você deverá ver a página de boas vindas do Rails.

Caso tenha algum problema durante a execução de algum comando, verifique no arquivo ‘Gemfile’ na raiz do projeto se as gems ‘therubyracer’ e ‘execjs’ estão incluídas, caso contrário inclua:

gem 'execjs'
gem 'therubyracer'

Certo, agora que tudo está funcionando, vamos criar o nosso contato. Para isto vamos utilizar o comando ‘scaffold’, que como a palavra diz, serve como um andaime para a nossa aplicação. Este comando gera os arquivos seguindo a arquitetura de aplicativos Rails, ou seja, ele cria um arquivo de modelo, controlador, helper e as views necessárias. Para entender melhor, vá na raiz do projeto e execute o comando:

$>rails generate scaffold Contato nome:string telefone:string

O comando completo é ‘rails generate scaffold’, em seguida temos o nome da entidade, no caso o ‘Contato’ e em seguida os atributos seguidos dos seus tipos ‘nome:string telefone:string’.

Vamos entender um pouco sobre a arquitetura da aplicação Rails, observe a imagem a seguir:

A organização do aplicativo segue o padrão MVC, ou seja, separa a entidade em Modelo (na pasta ‘app/models’), Visão (na pasta ‘app/views’) e Controlador (na pasta ‘app/controllers’). O usuário interage através do browser, enviando uma requisição, geralmente HTTP. Esta requisição será tratado no controlador, que vai interagir com os dados do modelo para então gerar a visualização com as informações. Um vez pronta, a visualização poderá ser renderizada pelo browser, como HTML por exemplo.

Criando o banco de dados

Vamos botar o aplicativo para funcionar e entender melhor. Primeiro precisamos criar os bancos de dados, execute, na raiz do projeto, o comando:

$>rake db:create:all

Esta tarefa rake vai criar as bases de dados necessários para o aplicativo, ou seja a base de desenvolvimento, testes e produção. Agora precisamos criar a tabela que vai armazenar os Contatos, para isso vamos criar uma migração. No Rails, uma migração é uma modificação na base de dados. Desta maneira você não precisa sair alterando manualmente as tabelas de todas as bases de dados, ou escrever consultas diretamente.

Ao executar o comando scaffold, a migração já será criada, verifique a pasta ‘db/migrate’, nela ficam salvas todas as migrações. Cada migração possui um timestamp na frente do arquivo (para indicar quando a migração foi criada) e depois um ‘_’ seguido da descrição da migração, no meu caso o arquivo ficou ‘20120216141302_create_contatos.rb’.

Abra o arquivo e veja que ele consiste de uma classe que herda de ActiveRecord::Migration e define um método chamado ‘change’. Neste método encontram-se as modificações a serem feitas. Para os Contatos, o arquivo deve estar assim:

class CreateContatos < ActiveRecord::Migration   def change     create_table :contatos do |t|       t.string :nome       t.string :telefone       t.timestamps     end   end end 

Criamos então a tabela contatos com as colunas nome e telefone do tipo string. Além disso o Rails utiliza internamente um timestamp em todas as tabelas. Não é necessário inserir explicitamente um id para as tabelas, o rails fará isto para você automaticamente. Vamos então executar a migração para adicionar os dados ao banco:

 $>rake db:migrate
==  CreateContatos: migrating =================================================
-- create_table(:contatos)
   -> 0.1304s
==  CreateContatos: migrated (0.1306s) ========================================

Pronto, o banco de dados já possui espaço para as informações, agora podemos ver o aplicativo funcionando, rode o server e acesse a página http://localhost:3000/contatos.

$>rails server

Esta página é gerada automaticamente pelo comando scaffold, veremos mais detalhes quando chegar na parte da view, por enquanto, basta ver que tudo está funcionando. É possível adicionar, listar, editar e apagar contatos, ou seja, todo o CRUD de Contatos é gerado automaticamente pelo scaffold.

Model

Vamos entender melhor como tratar o modelo, abra o arquivo de modelo dos contatos ‘app/models/contato.rb’. Neste arquivo vamos adicionar as regras do nosso modelo, por exemplo, podemos garantir que os campos Nome e Telefone sejam preenchidos obrigatoriamente.

class Contato < ActiveRecord::Base   validates_presence_of :nome, :message => " - Deve ser preenchido"
  validates_presence_of :telefone, :message => " - Deve ser preenchido"
end

Utilizando os validadores no modelo fica bem fácil garantir a integridade dos dados. Antes poderíamos criar um contato totalmente vazio, agora, ao tentar submeter o formulário de criação, será exibido as mensagens de validação. Volte em http://localhost:3000/contatos e tente criar um contato vazio para verificar que a validação realmente ocorreu.

Existem vários tipos de validadores, inclusive você pode criar seu próprio validador, mas por enquanto vamos deixar assim.

Controller

O controlador recebe a requisição HTTP do browser e direciona para a view específica. Ao abrir o arquivo ‘contatos_controller.rb’ na pasta ‘app/controllers’ você verá que existem sete métodos, e acima de cada um está um comentário explicando o que cada um faz, analisando o método ‘index’ por exemplo:

  # GET /contatos
  # GET /contatos.json
  def index
    @contatos = Contato.all

    respond_to do |format|
      format.html # index.html.erb
      format.json { render json: @contatos }
    end
  end

Ao receber um ‘GET /contatos’, o controlador vai executar o método ‘index’, ou seja, quando acessamos http://localhost:3000/contatos, este método é que será executado. Aqui é criada uma variável ‘@contatos’ que vai armazenar a lista de todos os contatos, através da chamada do método ‘all’ de ‘Contato’. Em seguida o método executa a resposta, dependendo do formato, se acessar através de HTML, com o ‘GET /contatos’ devolve um HTML, como o comentário indica, o index.html.erb. Caso acesse ‘GET /contatos.json’ será retornado um json.

Todos os outros métodos do controlador seguem a mesma ideia e possuem comentários que ajudam a entender cada um deles. O importante aqui é notar a variável de instância @contatos (variáveis sem o ‘@’ na frente são variáveis apenas locais), ela estará disponível na view index, por isso ela precisa armazenar a lista de contatos.

View

Abra então o arquivo ‘index.html.erb’ na pasta ‘app/views/contatos’ note que ele é um arquivo com marcações HTML e pedaços de código Ruby, por isso o formato .erb, ou embedded ruby. As tags <% %> indicam código ruby que deve ser apenas executado, já a tag <%= %> indica que o retorno deste código ruby deve ser renderizado na página.

A view index possui uma tabela com a listagem de contatos, como mostra o código a seguir:

<h1>Listing contatos</h1>

<%= hello %>

<table>
  <tr>
    <th>Nome</th>
    <th>Telefone</th>
    <th></th>
    <th></th>
    <th></th>
  </tr>

<% @contatos.each do |contato| %>
  <tr>
    <td><%= contato.nome %></td>
    <td><%= contato.telefone %></td>
    <td><%= link_to 'Show', contato %></td>
    <td><%= link_to 'Edit', edit_contato_path(contato) %></td>
    <td><%= link_to 'Destroy', contato, confirm: 'Are you sure?', method: :delete %></td>
  </tr>
<% end %>
</table>

<br />

<%= link_to 'New Contato', new_contato_path %>

A parte ‘<% @contatos.each do |contato| %>’ é semelhante ao foreach de outras linguagens, mas devido aos blocos funcionais do Ruby, não é necessário utilizar o foreach. Aqui, todos os contatos são percorridos, utilizando a variável definida no controller, e mostrados numa tabela, utilizando a variável local ‘contato’, definida no ”. Ao lado dos dados são também exibidos os botões para exibir (‘Show’), editar (‘Edit’) e remover (‘Destroy’) o contato da linha. No final do arquivo é exibido o botão para criar um novo contato (‘New Contato’).

Os botões utilizam o método ‘link_to’ que adiciona um link para uma ação, por exemplo ‘link_to ‘Show’, contato’ é um link com nome ‘Show’ que redireciona para a página de exibição da variável ‘contato’. Os outros links utilizam outros parâmetros para realizar as operações, mas a ideia é a mesma.

Helper

O Rails utiliza também os helpers, que não estão descritos na imagem da arquitetura MVC. Helpers são módulos que auxiliam as views. De maneira prática, nos helpers são definidos métodos que poderão ser invocados na view. Para exemplificar, abra o arquivo ‘contatos_helper.rb’ na pasta ‘app/helpers’ e adicione o seguinte método:

module ContatosHelper

  def hello
    "Hello World"
  end

end

Lembre que em Ruby a última linha é considerada o retorno do método. Agora, abra a view index (arquivo ‘index.html.erb’ na pasta ‘app/views/contatos’) e adicione:

<h1>Listing contatos</h1>

<%= hello %>

Ao recarregar a view, você verá a mensagem Hello World no local onde você adicionou o código. Geralmente os métodos dos helpers ajudam na formatação da página, por exemplo converter um float em unidade monetária.

Nos próximos posts vamos analisar outros pontos básicos do Rails que permitem um desenvolvimento rápido para WEB. Se gostou do post compartilhe com seus amigos e colegas, senão, comente o que pode ser melhorado. Encontrou algum erro no código? Comente também. Possui alguma outra opinião ou alguma informação adicional? Comenta ai! 😀

[Livro] Rails: Instalando e Executando

Ruby on Rails: Instalando e Executando

Ruby on Rails: Instalando e Executando

Rails de uma maneira prática

O livro possui uma ideia muito boa: ensinar Rails utilizando um projeto de exemplo, de uma maneira bem prática. Eu particularmente prefiro muito esta abordagem e o livro realmente cumpre o que promete. Durante os capítulos são introduzidos os conceitos sempre acompanhados de códigos e imagens.

No entanto, o livro não fica muito extenso, já no primeiro capítulo é abordado desde a organização de um projeto Rails até criação de Controllers e Views. Ao todo, o livro possui menos de 200 páginas (contando índices, contra capa, etc.), ou seja, é um livro bem prático que fala sobre o necessário, mas não se aprofunda muito.

O projeto utilizado como exemplo permite um bom entendimento do framework, explorando principalmente a parte dos dados do projeto, modelagem de banco, relacionamentos entre entidades, entre outros fatores. No entanto, apesar de toda essa discussão sobre modelagem, o livro não propõe um modelo único que dura todo o tempo, em outros capítulos são exploradas também as ‘Migrations’, justamento para simular um projeto real onde ocorrem mudanças.

Sem enrolação

Todo o texto do livro é escrito de uma forma bem enxuta (se você só consegue entender alguma coisa lendo um livro da série Use a Cabeça! desista, esse livro não é para você) . Muita das vezes é interessante procurar outras fontes de informação para complementar e para dar uma maior compreensão sobre o assunto.

Neste ponto eu indico fortemente a apostila ‘RR-71 Desenv. Ágil para Web com Ruby on Rails 3’ da Caelum (caelum.com.br) onde são explorados mais afundo alguns conceitos, como a Convenção ao invés de Configuração, Rotas, Bases de Dados, entre outros. Além disso a apostila da Caelum oferece também um projeto base para os estudos e que pode ser utilizado como outro exercício.

O livro é sobre Rails!

Se você não conhece nada de Ruby, é melhor dar uma estudada antes, pois o livro não tem uma parte introdutória para explicar a linguagem. Mais uma vez indico a apostila da Caelum, pois os primeiros capítulos dão uma ótima visão para começar com Rails entendendo todos os detalhes da linguagem Ruby, como metaprogramação, blocos funcionais, hashes e outros pontos que são extensivamente utilizados no desenvolvimento com rails.

Problemas sérios com tradução

Agora vem um ponto muito negativo contra o livro: a tradução. Como todas as pessoas ligadas a área da tecnologia, eu também prefiro ler livros que foram publicados em inglês na língua original, no entanto me iludi achando que, por ser um livro técnico, haveria um cuidado especial com a tradução.

A tradução do livro tem problemas sérios, como comandos utilizados no terminal estarem traduzidos, código fonte (ou parte do código) traduzido, entre outros. Algumas falhas chegam até a tornar a frase totalmente sem sentido, como uma que diz: “[…] mas a compartilhação do leão deste aplicativo como é construido.” (???)

No entanto, como eu falei antes, se você utilizar um outro material para acompanhar, dá pra contornar esses problemas.

“Instalando”

Quem leu o post ‘Rails: instalando e executando! (Linux)‘ viu que lá eu comentei sobre um livro que prometia ensinar a instalar o Rails, pois bem, este é o livro. Comentei também que o livro manda procurar no Google sobre como instalar no Linux. Tudo bem, existem várias distros e seria muito difícil explicar tudo sobre todas as distribuições, então não é um ponto assim tão negativo. Para quem utiliza Mac, ou Windows o livro mostra muito bem como instalar tudo necessário.

Conclusão

Apesar dos problemas, no final das contas o livro vale a pena. A abordagem proposta realmente funciona, o livro cobre muitos tópicos de uma maneira bem prática e o preço do livro é barato, ainda mais comparado com outros livros de tecnologia.

Então se quiser aprender Rails e entender um pouco sobre os bastidores, recomendo este livro (se possível a versão original em inglês).

Rails: instalando e executando! (Linux)

Assim como eu, você já deve ter ouvido falar em Rails, muito provavelmente em Ruby on Rails, e talvez em Ruby. Eu também ouvi falar bastante deste assunto algum tempo atrás e resolvi estudá-lo melhor. Logo de cara encontrei vários problemas para instalar o Ruby e o Rails no linux (Mint/Ubuntu e derivados). Utilizar ‘sudo apt-get’ não funcionava, erros aconteciam ao executar comandos simples, tutoriais não indicavam o caminho completo… enfim, quase desisti.

Como no linux ou é extremamente fácil de instalar, ou então é extremamente difícil, acabei procurando informações de várias fontes, até comprei um livro que prometia ensinar a instalar o Rails, mas que mandava buscar no Google! (é sério) Por fim, acabei encontrando uma solução para o problema. E esse é o objetivo deste post, mostrar como instalar Ruby e Rails no seu Ubuntu (também testei no Mint).

Sobre Ruby e Rails

“Ruby é uma linguagem dinâmica, open source com foco na simplicidade e na produtividade.” [1] Ou seja, com ruby você faz muito com pouco código. Para saber mais sobre Ruby, basta acessar [1] ou então ficar ligado aqui nos próximos post.

“Ruby on Rails é um framework de desenvolvimento web (gratuito e de código aberto) otimizado para a produtividade sustentável e diversão do programador.” [2] Assim como o Ruby, Rails também é voltado para produtividade, utilizando conceitos como Convenção ao invés de configuração (Convention over Configuration – CoC) [3], Não repita a si mesmo (Don’t Repeat Yourself – DRY) [4], entre outros.

Nos próximos posts eu vou procurar falar um pouco mais sobre a fundamentação do Ruby e do Rails, por hora vamos instalar tudo que precisamos.

Começando antes do começo

Antes de instalar o Ruby propriamente dito precisamos pegar alguns pacotes que serão necessários. Por tanto, abra o terminal e faça o procedimento padrão para instalação dos pacotes:

  • zlib1g
  • zlib1g-dev
  • build-essential
  • openssl
  • libssl-dev
  • libmysqlclient16-dev
  • $>sudo apt-get install zlib1g zlib1g-dev build-essential openssl libssl-dev libmysqlclient16-dev
    

    Pronto, após baixar todos os pacotes, vamos ao Ruby!

    Instalando o Ruby

    Neste passo existem duas opções, uma delas é baixar o ruby do repositório da distribuição Linux, com ‘sudo apt-get install’. A outra é baixar o código fonte, compilar e instalar. Vamos optar pela segunda, pois assim utilizaremos a versão mais recente e evitaremos uma série de problemas. Vocês vão ver o quão difícil é fazer isso 😀

    Acesse http://www.ruby-lang.org/pt/ e clique no botão “Download Ruby”. Na próxima página, na seção “Código-Fonte do Ruby”, será possível ver a última versão estável com o link para download, no meu caso ‘Ruby 1.9.2-p290’. Baixe o arquivo em qualquer lugar e extraia o conteúdo.

    Agora vá no terminal e acesse a página recém criada pela extração. Aqui eu salvei o arquivo na pasta de downloads do meu usuário, então fica assim:

    $>cd /home/marcos/Downloads/ruby-1.9.2-p290/
    

    Dentro da pasta, execute os seguintes comandos, nessa ordem:

    $>./configure
    $>sudo make
    $>sudo make install
    

    Vai demorar um pouco…

    Pronto! Você compilou e instalou um programa no seu computador! Eu falei que ia ser difícil.

    Para testar se deu tudo certo, vá no terminal e verifique a versão do ruby, no meu caso:

    $>ruby -v
    ruby 1.9.2p290 (2011-07-09 revision 32553) [i686-linux]
    

    Hora das Gems!

    Com o ruby instalado, precisamos instalar o RubyGems. “Rubygems é o serviço de hosting de gem da comunidade Ruby” [5] O Rubygems é como um repositório de gems do Ruby. “Gem é uma aplicação ou biblioteca Ruby empacotada” [6] Ou seja, é como as bibliotecas e APIs de Ruby são utilizadas, como exemplo o Rails. Assim, o Rubygem fornece uma maneira muito fácil de baixar e atualizar as suas Gems.

    Para instalá-lo, precisamos mais uma vez baixar o código e compilar, mas agora será bem mais fácil. Acesse http://rubygems.org/ e clique em ‘Install RubyGems 1.8.15’ (a versão pode ser diferente). Na próxima página clique no botão ‘TGZ’ ou ‘ZIP’ para baixar o código do RubyGems. Após o download, extraia o pacote e vá no diretório recém criado novamente, no meu caso:

    $>cd /home/marcos/Downloads/rubygems-1.8.15/
    

    Agora vamos instalar o RubyGems, mas desta vez utilizando o seu novo interpretador Ruby! Dentro da pasta execute:

    $>sudo ruby setup.rb
    

    Espere terminar e pronto! Os programas ruby geralmente são instalados assim, a partir de um arquivo setup.rb, de maneira semelhante aos do python, que utilizam um setup.py.

    Depois de instalar, verifique a versão para saber que está tudo ok:

    $>gem -v
    1.8.15
    

    Agora sim o Rails!

    Agora podemos tranquilamente instalar o Rails, basta utilizar o RubyGems! No terminal, execute:

    $>sudo gem install rails
    

    Vai demorar um pouco, você vai achar que travou, mas é assim mesmo. Depois de um tempo teremos o incrível Rails instalado!

    Para testar, verifique a versão (de novo):

    $>rails -v
    Rails 3.2.1
    

    Tá quase lá!

    O Rails utiliza como banco de dados padrão o SQLite3, por tanto precisamos baixar e instalar mais alguns pacotes, no terminal execute:

    $>sudo apt-get install sqlite3 libsqlite3-dev
    ...
    $>sudo gem install sqlite3
    ...
    

    Caso queira utilizar o MySql basta fazer o seguinte:

    $>sudo apt-get install mysql-client-5.1 mysql-server-5.1
    ...
    $>sudo gem install mysql2
    ...
    

    Outros BDs seguem a mesma ideia, basta verificar quais são os pacotes necessários e qual a gem trabalha com o BD.

    Algumas outras Gems são necessárias em projetos Rails para que seja executado o código JavaScript, portanto instale também as gems ‘execjs’ e ‘therubyracer’:

    $>sudo gem install execjs
    ...
    $>sudo gem install therubyracer
    ...
    

    Pronto! Tudo certo. Vamos então botar o servidor no ar?

    Executando o Rails!

    Criar um novo projeto com rails é muito fácil, no terminal vá para o diretório do seu workspace e execute:

    $>rails new app -d=mysql
    

    Esse comando vai criar uma nova pasta, chamada ‘app’, contendo o seu aplicativo. Note a opção ‘-d=mysql’, nela indicamos que o banco a ser utilizado é o mysql, caso não coloque esta opção será utilizado SQLite.

    Vai demorar também, mas não travou, pelo menos não deveria… Se der alguma mensagem de erro basta ver o que causou o erro e verificar se você instalou tudo certinho (Nos testes que fiz não aconteceu nada, mas vai saber né :)).

    Após todo o processo, o Rails vai ter criado pra você um projeto completo, com pastas para agrupar testes, migrações de banco, etc. Vamos então continuar o processo. Pelo terminal entre na pasta ‘app’ e execute o comando:

    $>cd app/
    $>sudo bundle install
    

    Esse comando vai instalar alguma coisa que tiver faltando, ou atualizar as dependências do seu projeto. Se você quiser utilizar alguma gem, mas ainda não baixou, basta editar o arquivo ‘Gemfile’ (um arquivo com as dependências do projeto), na raiz do projeto, que o comando ‘bundle install’ vai instalar ela pra você. Por exemplo, caso você não tenha instalado o ‘execjs’ e o ‘therubyracer’ bastaria alterar o arquivo e adicionar as seguintes linhas:

    gem 'execjs'
    gem 'therubyracer'
    

    Depois disso, ao executar ‘bundle install’ as gems serão instaladas e atualizadas. Bem útil não?

    Após este processo, vamos finalmente botar o servidor pra funcionar! Não, ainda não…

    Configurando o BD

    Antes de ligar o servidor, precisamos configurar o seu bd. Caso tenha utilizado o SQLite não precisa fazer nada. No caso o MYSql precisamos dar a senha do banco para a aplicação. Para tanto edite o arquivo app/config/database.yml:

    $>gedit config/database.yml
    

    O Rails utiliza três base de dados para a aplicação, uma para desenvolvimento, uma para testes e outra para produção (nos próximos posts eu procuro explicar melhor isso). Então neste arquivo tem ‘development:’, ‘test:’ e ‘production:’, abaixo deles tem a configuração do banco em cada ambiente. Precisamos então dar a senha para a aplicação, como exemplo, veja a minha configuração de ‘development:’

    development:
      adapter: mysql2
      encoding: utf8
      reconnect: false
      database: myapp_development
      pool: 5
      username: root
      password: senha
      socket: /var/run/mysqld/mysqld.sock
    

    Basta colocar a senha ao lado do campo ‘password:’, lembrando de deixar o espaço na frente!

    Feito isso vamos criar os bancos de dados. O Rails possui uma ferramente chamada Rake, que automatiza tarefas [7], no nosso caso vamos utilizar a tarefa de criação do banco, vá na pasta do projeto e execute:

    $>rake db:create
    

    Pronto, tudo certo com o banco. Se quiser verifique as databases criadas no seu banco (mysql> show databases;), deve ter ‘app_test’, ‘app_development’ e ‘app_production’.

    Agora sim! Executando o Rails!

    Pronto, chega de instalar, configurar, e sei lá mais o que. Pois é, lembre que tudo isso só é feito uma vez, depois você pode criar quantas aplicações quiser. Agora vá na pasta do projeto e execute o servidor!

    $>rails server
    

    Pronto, agora basta abrir o browser e ir em http://localhost:3000 (3000 é a porta padrão que o rails utiliza). Se deu tudo certo você verá uma mensagem ‘Welcome aboard’ na página com algumas figurinhas e links interessantes.

    Nos próximos posts eu vou tentar explicar o projeto Rails, banco de dados, entre outros assuntos, sempre com exemplos, pra não ficar muito chato. Se quiser ir treinando antes, basta dar uma olhada nas referências ai em baixo e fuçar na internet.

    Não perca os próximos posts!

    Se gostou do post compartilhe com seus amigos e colegas, senão, comente o que pode ser melhorado. Encontrou algum erro no código? Comente também. Possui alguma outra opinião ou alguma informação adicional? Comenta ai! 😀

    Referências:

    [1] http://www.ruby-lang.org/pt/
    [2] http://rubyonrails.com.br/
    [3] http://en.wikipedia.org/wiki/Convention_over_configuration
    [4] http://en.wikipedia.org/wiki/Don’t_repeat_yourself
    [5] http://rubygems.org/
    [6] http://docs.rubygems.org/read/chapter/1
    [7] http://www.akitaonrails.com/2009/02/16/automatizando-tarefas-com-ruby-e-rake