Netbeans 7.1 e Rails

A minha opção preferida para trabalhar com Rails é o NetBeans, mas a partir da versão 6.9 a não há mais suporte oficial para da Oracle para Ruby on Rails,  desde então o suporte é mantido pela comunidade com um plugin não oficial.

Então mãos a obra:

Vamos começar instalando o NetBeans, há várias opções de instalação escolheremos a mais leve que é o NetBeans for PHP.

http://netbeans.org/downloads/index.html

Depois de baixado o seguinte comando na pasta do arquivo:

sh netbeans-7.1-ml-php-linux.sh

Siga as orientações da tela de instalação. Após a conclusão da instalação abra o netbenas clieque e:

Ferramentas >> Plug-ins na aba “Configuração” clique em adicionar

Preenchas os campos da seguinte forma:

Nome: Rails

URL: http://deadlock.netbeans.org/hudson/job/ruby/lastSuccessfulBuild/artifact/build/updates/updates.xml

Confirme, em seguida na aba “Plug-ins disponíveis” clique em “Recarregar catálogo” procure por rails e instale o plug-in.

Reinicie o NetBeans e a sua IDE já estará configurada.

Anúncios

Como customizar (editar) as views geradas pelo scaffold no Rails

Durante um bom tempo quis saber como customizar os arquivos gerados pelo scaffold, na verdade isso é mais simple do que parece. Quando o este comando é executado o Rails verifica se há algum modelo definido pelo usuário, caso não encontre o Rails utiliza o modelo padrão consta nas libs da própria framework.
Então o que temos que fazer é definir estes modelos customizados e colocá-los no local correto.

Então vamos começar acessando o repossitório do Rails no GitHub mais especificamente na pasta /railties/lib/rails/generators/erb/scaffold/templates acesse-a neste link:
https://github.com/rails/rails/tree/master/railties/lib/rails/generators/erb/scaffold/templates.

Neste diretório você encontrar o modelos utilizados para os arquivos:

_form.html.erb
edit.html.erb
index.html.erb
new.html.erb
show.html.erb

Copie os 5 arquivos para o diretório /libs/templates/erb/scaffold

Provavelmente você não vai encontrar esse diretório, então crie-o corforme o esquema acima.

Neste tutorial vamos editar o index.html.erb, mas você pode alterar qualquer um desses arquivos.

Abrindo o arquivo, vamos econtrar o seguinte conteudo.


<h1>Listing <%= plural_table_name %></h1>

<table>
 <tr>
 <% attributes.each do |attribute| -%>
 <th><%= attribute.human_name %></th>
 <% end -%>
 <th></th>
 <th></th>
 <th></th>
 </tr>

<%%= content_tag_for(:tr, @<%= plural_table_name %>) do |<%= singular_table_name %>| %>
 <% attributes.each do |attribute| -%>
 <td><%%= <%= singular_table_name %>.<%= attribute.name %> %></td>
 <% end -%>
 <td><%%= link_to 'Show', <%= singular_table_name %> %></td>
 <td><%%= link_to 'Edit', edit_<%= singular_table_name %>_path(<%= singular_table_name %>) %></td>
 <td><%%= link_to 'Destroy', <%= singular_table_name %>, <%= key_value :confirm, "'Are you sure?'" %>, <%= key_value :method, ":delete" %> %></td>
 <%% end %>
 </table>

<br />

<%%= link_to 'New <%= human_name %>', new_<%= singular_table_name %>_path %>

Vamos fazer uma alteração simples traduzindo o que as informações do index para o portugues:


<h1>Lista de <%= plural_table_name %></h1>

<table>
 <tr>
 <% attributes.each do |attribute| -%>
 <th><%= attribute.human_name %></th>
 <% end -%>
 <th></th>
 <th></th>
 <th></th>
 </tr>

<%%= content_tag_for(:tr, @<%= plural_table_name %>) do |<%= singular_table_name %>| %>
 <% attributes.each do |attribute| -%>
 <td><%%= <%= singular_table_name %>.<%= attribute.name %> %></td>
 <% end -%>
 <td><%%= link_to 'Exibir', <%= singular_table_name %> %></td>
 <td><%%= link_to 'Editar', edit_<%= singular_table_name %>_path(<%= singular_table_name %>) %></td>
 <td><%%= link_to 'Apagar', <%= singular_table_name %>, <%= key_value :confirm, "'Você está certo disso?'" %>, <%= key_value :method, ":delete" %> %></td>
 <%% end %>
 </table>

<br />

<%%= link_to 'Novo(a) <%= human_name %>', new_<%= singular_table_name %>_path %>

Salve e execute um scaffold como teste.

Você irá verificar que o index foi criado a partir do modelo que acabamos de definir. Portanto podemos alterar da maneira que quisermos esses arquivos para que eles fiquem mais adequados à nossa aplicação, isso com certeza vai aumentar a produtividade do nosso trabalho com o rails.

#Rails01 – Começando com Rails do zero (Vídeo aula)

Olá pessoal, hoje eu tomei coragem e fiz uma coisa que há muito tempo tinha vontade de fazer, uma vídeo aula!

Não sei se levo muito jeito para a coisa, mas espero que vocês gostem.

Nesse vídeo eu compartinho com vocês como iniciar com rails para quem está começando agora, como instalar e quais são as melhores fontes de informação para quem quer aprender Rails.

 

De acordo com a receptividade do público eu vou preparando outros vídeos.

Seguem links utilizados neste vídeo tutorial:

http://rubyonrails.org

http://railscasts.com

https://groups.google.com/forum/?hl=pt#!forum/rails-br

http://compare.buscape.com.br/proc_unico?id=3482&kw=rails

 

Até a próxima.

Como formatar data e hora na linguagem Ruby

Para para formatar uma data ou hora no Ruby podemos utilizar o método strftime().

 %a - A abreviatura do dia da semana ("Sun'')
 %A - O nome completo do dia da semana ("Sunday'')
 %b - A abreviatura do nome do mês  ("Jan'')
 %B - O nome completo do mês ("January'')
 %d - Dia do mês  (01..31)
 %H - Horas do dia  (00..23)
 %I - Horas do dia (01..12)
 %j - Dia do ano (001..366)
 %m - Mês em número (01..12)
 %M - Minutos das horas (00..59)
 %p - Indicador de meridiam (``AM'' or ``PM'')
 %S - Segundos do minuito (00..60)
 %U - Número da semana no ano corrente, iniciando do primeiro domingo da primeira semana do ano (00..53)
 %W - Número da semana no ano corrente, iniciando da primeira segunda da primeira semana do ano (00..53)
 %w - Dia da semana (Domingo é 0, 0..6)
 %x - Representação para a data somente, sem hora.
 %X - Representação para a hora somente, sem data.
 %y - Ano em dezena 00..99)
 %Y - Ano literal ex: 2011
 %Z - Nome do "Time zone"
 %% - Literal ``%'' catacter

Exemplo de uso.

t = Time.now
 t.strftime("Data %m/%d/%Y") #=> "Data 04/09/2011"
 t.strftime("at %I:%M%p") #=> "08:56AM"

Faça as combinações conforme a sua necessidade.

Até a próxima.

Novo site em Ruby on Rails – Booksérie.com.br

Olá pessoal, é com muito prazer com que venho anunciar o lançamento do site BookSérie.  Foram 6 meses de trabalho mas valeu a pena pelo aprendizado e pela satisfação de desenvolver mais uma ferramenta de entretenimento para o público.

O BookSérie é um site que exibe livros inéditos no formato de seriados, ou seja, os episódios são lançados semanalmente e o leitor ainda pode interagir com o texto através de vídeos que complementam o assunto que está sendo abordado no episódio.

Nós estamos iniciando nossas atividades com a série Heróis Meninos, e em breve adicionaremos outras.

O site foi desenvolvido em Rails, Html, Jquery e outras tecnologias.

Conto com a visita e sugestões de vocês.

www.bookserie.com.br

Tutorial Rails 3 Part.2: Controller, RESTful e scaffold.

Vamos dar continuidade ao nosso tutorial sobre Rails 3, se você não leu a primeira parte clique aqui.

Hoje nós faremos algumas customizações na parte visual do nosso sistema para deixá-lo mais amigável. Mas antes temos que conhecer um pouco mais sobre a estrutura do Rails.

Quando usamos o scaffold, o Rails criou automaticamente uma estrutura composta por um conceito chamado de REST, que determina que um model deve ser composto por 7 ações básicas. Estas ações podem ser visulizadas no arquivo de controller. O controler é responsável por fazer a interface entre as views e os models na arquitetura MVC, realizando o processamento das requisições vindas do navegador web.

Os controllers ficam localizados na pasta app/controller/, e por uma convenção da framework, o nome dos controllers que estiverem vinculados a um model sempre deve estar no plural, diferente dos models que devem estar no singular. Mais adiante veremos neste como criar um controller independentemente de um model.

Vamos abrir um arquivo de controller que já criamos para visualizar a sua estrutura:

app/controller/centro_de_custos_controller.rb


class CentroDeCustosController < ApplicationController

 def index
  ...
 end

 def show
  ...
 end

 def new
  ...
 end

 def edit
  ...
 end

 def create
  ...
 end

 def update
  ...
 end

 def destroy
  ...
 end
end

Notamos que a classe CentroDeCustosController possui 7 métodos, na estrutura do Rails nós podemos chamar esses métodos de actions, pois eles representam de certa forma ações relacionadas ao model:

index : Responsável por visualizar todos os elementos de um model, é a action padrão do controller. Portanto quando acessamos a url http://localhost:3000/nome_do_controller/, na verdade estamos acessando esta action.

show: Responsável por visualizar um elemento específico determinado por um ID, a url funciona desta forma: http://localhost:3000/nome_do_controller/id_do_elemento

new: Formulário de cadastro de um novo redgistro, a url fica desta forma: http://localhost:3000/nome_do_controller/new

edit: Formulário de edição de um registro, acessado desta forma: http://localhost:3000/nome_do_controller/edit/id_do_elemento

Cada uma destas actions possuem um arquivo de visualização correspondente na pasta app/views/nome_do_controller, as views são responsáveis por exibir o conteúdo de forma amigável para o usuário final. Nela podemos utilizar tags html, css, javascript, flash etc.

Lista de relação entre as actions do controller e os arquivos da view.

Action — View

index — app/views/nome_do_controller/index.html.erb

show — app/views/nome_do_controller/show.html.erb

new — app/views/nome_do_controller/new.html.erb

new — app/views/nome_do_controller/edit.html.erb

Porém, para o RESTful nem todas as actions precisam de uma view, pois elas apenas executam uma tarefa requisitada por uma outra action e depois enviam uma mensagem de confirmação de execussão, é o caso das actions:

create — executa a tarefa solicitada pela action new — manda uma mensagem de confirmação para a view show.

update — executa a tarefa solicitada pela action edit — manda uma mensagem de confirmação para a view show.

destroy — executar a tarefa solicitada pela na view index quando um usuário clica na opção de destroir alguma elemento — manda uma mensagem de confirmação para a view index.

Há uma questão técnica interessante relacionadas ao método de requisição quando nós trabalhamos com RESTful no Rails. Para quem já está familiarizado com o desenvolvimento web, sabe o que são requisições do tipo GET ou POST, o Rails utiliza estas e outras duas PUT e DELETE.

Action — Tipo de Requisição

index — GET

new — GET

edit — GET

show — GET

create — POST

update — PUT

destroy — DELETE

Uma forma de visualizar toda essa estrutura é executando o seguinte comando na diretório da sua aplicação:


rake routes

Resultado:

Agora vamos criar um controller para tratar da página inicial da nossa aplicação executando o seguinte comando:


rails g controller home index

Quando usamos rails g equivale a usarmos rails generate, eu prefiro usar a forma abreviada mas ambas funcionam da mesma forma. Portanto, esse comando gera um controller chamado home, o ultimo parâmetro é o nome da action que usaramos.

Após executar esse comando o Rails automaticamente criará para você uma série de arquivos, em especial para o nosso propósito o controller e a view.

app/controller/home_controller.rb

app/view/home/index.html.erb

Se você der uma olhadinha no home_controller.rb perceberá que a action index já está lá.

Agora precisamos editar a view app/view/home/index.html.erb desta forma:


<h2>Seja bem vindo<h2>
<p>Aogra você pode fazer o controle sobre os seus gastos e economizar uma grana.</p>

Agora se você iniciar o seu servidor com o comando


rails s

e acessar o endereço o endereço  http://localhost:3000/home/index você visualizará a página que acabamos e editar.

Nota: o comando rails s é a abreviatura do rails server ambos tem a mesma função, como já disse, eu prefiro sempre usar a forma reduzida. Para sair do servidor é pressionar as teclas CTRL + C.

Para definirmos ela como a nossa página inicial faremos o seguinte:

Vamos deletar o arquivo padrão da página inicial do rails:

public/index.html

Em seguida vamos abrir o arquivo:

config/routes.rb

E editá-lo da seguinte forma:

ControleGastos::Application.routes.draw do

 root :to=> "home#index"

 resources :centro_de_custos

 resources :lancamentos

 # The priority is based upon order of creation:
 # first created -> highest priority.
...

Pois bem, acabamos de definir a página inicial da nossa aplicação.

Vamos fazer um teste acessando

http://localhost:3000

Bem pessoal, por enquanto é isso, esse tutorial foi bem teórico, mas muito importante para entendermos alguns conceitos importantes do Rails.

Tutorial: Criando uma aplicação em Rails 3 e Mysql (Parte 1)

Olá pessoal, hoje nós vamos dar início a um tutorial básico de Rails, com a ideia de criar um sistema básico de controle de gastos.

A minha intenção com este post é fugir daquele tradicional tutorial para construir um blog ou alguma coisa parecida, e também utilizar os recursos da versão 3 do Rails. Vou tentar abordar aqui técnicas importantes no desenvolvimento de qualquer aplicação em Rails, como: Relacionamento, validação, edição de layout, utilização de plugins entre outros.

Por se tratar de um conteúdo um pouco extenso vou colocá-lo aqui no blog por partes.

O problema a ser abordado será o seguinte:

  • O usuário deve poder lançar seu gastos informando a data, descrição, valor e categoria dos gasto (centro de custo).
  • O usuário poderá incluir quantas categorias quiser.
  • O usuário poderá excluir um lançamento errado.
  • O usuário terá acesso a alguns relatórios (Relatório detalhado, Total gasto por mês, Total gasto por centro de custo)

Agora que temos os requisitos do usuário vamos dar início a modelagem no nosso banco de dados.

Este é um modelo bem simples mas o importante aqui é visualizarmos o relacionamento entre as entidades CentroDeCustos e Lancamentos, assim definimos que:
Um CentroDeCustos tem muitos Lançamentos e um Lançamento pertence a um CentroDeCusto, ou seja, um relacionamento de 1:N (1 para muitos).

Agora que definimos o nosso modelo de relacionamento vamos começar com o desenvolvimento do sistema.

Abra o seu prompt de comando para criar a sua aplicação Rails. (Caso você ainda não tenha configurado um ambiente de produção para Rails siga meu tutorial de instalação de um ambiente de desenvolvimento no Ubuntu)

Vamos criar a aplicação com o comando:

rails new controle_gastos -d mysql

O controle_gastos é o nome da nossa aplicação.

A diretiva -d mysql define qual banco de dados será utilizado. Caso você queira utilizar outro por exemplo -d postgresql.

Ao executar esse comando, o Rails criará para você um diretório /controle_gastos contendo os arquivos da nossa aplicação, acesse esse diretório para começarmos o desenvolvimento.

O primeiro passo é configurar a conexão com o banco de dados editando o arquivo

/config/database.yml

Se o seu ambiente estiver configurado corretamente a única coisa a fazer é inserir o nome do usuário e senha de acesso do banco de dados.

Edite os itens username e password de todos os ambientes (development, test, production), no meu caso o username é root e o password é 123, desta forma, o arquivo ficou assim:

# MySQL.  Versions 4.1 and 5.0 are recommended.
#
# Install the MySQL driver:
#   gem install mysql2
#
# And be sure to use new-style password hashing:
#   http://dev.mysql.com/doc/refman/5.0/en/old-client.html
development:
 adapter: mysql2
 encoding: utf8
 reconnect: false
 database: controle_gastos_development
 pool: 5
 username: root
 password: '123'
 socket: /var/run/mysqld/mysqld.sock

# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
test:
 adapter: mysql2
 encoding: utf8
 reconnect: false
 database: controle_gastos_test
 pool: 5
 username: root
 password: '123'
 socket: /var/run/mysqld/mysqld.sock

production:
 adapter: mysql2
 encoding: utf8
 reconnect: false
 database: controle_gastos_production
 pool: 5
 username: root
 password: '123'
 socket: /var/run/mysqld/mysqld.sock

Depois de configurada a conexão vamos criar os bancos de dados de desenvolvimento e teste executando o seguinte comando.

rake db:create

Vamos criar os arquivos relacionados a entidade centro de custos.

rails g scaffold CentroDeCusto nome:string

O scaffold um é comando do Rails que monta um esqueleto da aplicação com o famoso CRUD, que nada mais é do que inserir, visualizar, alterar e deletar elementos de um model com o intuito de acelerar o desenvolvimento evitando o retrabalho.

O scaffold é baseado em um model, o model é uma abstração que a do rails faz da informação (dados) e a manipulação dessa informação dentro da nossa aplicação. Para o nosso exemplo podemos entender que o model representa uma entidade (tabela) do banco de dados e as suas regras de interações.

O nome do model deve sempre estar no singular, no nosso caso, CentroDeCusto. Quanto se trata se uma palavra composta por mais de um termo deve se usar uma letra maiúscula no início de cada termo.

Um dos arquivos criados pelo scaffold é o de migração. Os arquivos de migração compõe a estrutura das tabelas do banco.

Os arquivos de migração ficam no diretório

/db/migrate

Os nomes dos arquivos de migração são compostos pela data e hora de criação do arquivo e o nome da ação que que ele vai realizar. Por exemplo:

20110222153321_create_centro_de_custos.rb

Abra o seu arquivo migração e edite-o da seguinte forma:

class CreateCentroDeCustos  45, :null => false

 t.timestamps
 end
 end

 def self.down
 drop_table :cento_de_custos
 end
end

Inserimos na linha 4 o parâmetro :null=> false que equivale ao not null quando nós estamos criando uma tabela no mysql, ou seja, o campo nome não aceita valores em nulos. O parâmetro :limit => 45 determina que este campo receberá no máximo 45 caracteres.

Para que a migração seja executada use:

rake db:migrate

Para a entidade lancamentos você executará no prompt o seguinte comando:

rails g scaffold Lancamento descricao:string valor:decimal date:date centro_de_custo:references

Editando o arquivo de migração ele ficará assim:

class CreateLancamentos < ActiveRecord::Migration
 def self.up
 create_table :lancamentos do |t|
 t.string :descricao, :null => false
 t.decimal :valor, :precision => 2, :null => false
 t.date :date, :null => false
 t.references :centro_de_custo

 t.timestamps
 end
 end

 def self.down
 drop_table :lancamentos
 end
end

Na linha 5 para o campo valor nós usamos o tipo decimal com o parâmetro :precision => 2 que se refere a quantas casas decimais o campo vai conter, como estamos trabalhando com moeda vamos usar 2 casas.

Notamos também que o campo t.references :centro_de_custo faz referência ao model centro de custo, isso significa que cada registro do lançamento fará referência a um centro de custo, assim como foi explicado com o diagrama de entidade relacional do início deste tutorial.

Vamos rodar a migração com o comando:

rake db:migrate

Vamos dar uma olhadinha nos nossos models que estão no diretório:

/app/model/

Primeiro o lancamento.rb

class Lancamento > ActiveRecord::Base
belongs_to :centro_de_custo
end

Percebemos que existe uma linha dentro da classe, essa linha representa justamente o relacionamento que o model Lancamento tem com CentroDeCusto, um lançamento pertence a um centro de custo belongs_to :centro_de_custo. Esse comando foi inserido no model quando definimos no scaffold centro_de_custo:references.

Agora precisamos inserir no model centro_de_custo.rb a linha que garante o relacionamento com o model lançamento, o mesmo ficará desta forma:

class CentroDeCusto > ActiveRecord::Base
has_many :lancamentos
end

O detalhe quando estamos falando de um para muitos has_many o parâmetro do model de referencia deve estar no plural, em português ficaria assim, o Centro de Custos tem muitos lançamentos, no Rails has_many :lancamentos.

Ao que se refere a relacionamento ainda temos:

has_one – tem um

has_and_belongs_to_many – tem a pertence a muitos.

Para que a gente possa testar a nossa aplicação vamos fazer mais uma mudança, dessa vez no seguinte arquivo

/app/view/lancamentos/_form.html.rb

Este é o arquivo do formulário de inclusão e edição de lançamentos.

Vamos localizar a as linhas:

<%= f.label :centro_de_custo %><br />
<%= f.text_field :centro_de_custo %>

E alterá-las para:

<%= f.label :centro_de_custo_id %><br />
<%= f.text_field :centro_de_custo_id %>

Vamos dar uma olhada na nossa aplicação. para que o rails rode em um servidor local é necessário rodar o seguinte comando:

rails s

Acesse o endereço http://localhost:3000/centro_de_custos/ e castre um novo centro de custo conforme a imagem abaixo.

Com isso acabamos de fazer um inserção na tabela do banco, e ,por padrão, o Rails atribui automáticamente 3 valores adicionais ao elemento que foi criado.

id – O identifcador único e sequencial do elemento.

created_at – Data e hora de criação.

updated_at – Data e hora da última edição.

Em seguida cadastre um lançamento em http://localhost:3000/lacamentos

Quando colocamos o valor 1 no campo centro de custos, na verdade o que estamos fazendo, é colocar o id do centro de custo ao qual o lancamento irá pertencer.

Bem, por hoje foi isso, aguardem o próximos posts, e sugestões podem ser enviadas aqui pelos comentários.

Veja a continuação deste tuturial.