• Neste post vamos permitir que o usuário possa fazer o login usando nome de usuário ou email, usando a gem Devise com o Rails versão 3.2.1.
• Para demonstrar isso, vamos continuar a construir um app web, que iniciamos no artigo em Aplicação “mestre detalhe” em Rails 3.2.1 e depois em Autenticação em Ruby On Rails 3.2.1 com Devise.
• O código fonte gerado no artigo anterior, está hospedado no Github em https://github.com/sergiosouzalima/service_desk
• O código fonte gerado para este artigo, também está hospedado no Github em https://github.com/sergiosouzalima/service_desk_v03

II – Principais tecnologias usadas neste artigo

• Linux Ubuntu 11.10
• Ruby 1.9.2
• Rails 3.2.1
• gem Devise 2.0

III – O que não precisamos instalar

• Git, RVM, openssl, sqlite3 e outros pacotes necessários.
• Como dependemos de instalações e configurações anteriores, caso seu ambiente não esteja preparado, veja os posts:
  1. Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10
  2. Ruby On Rails 3.1.3 no Linux Ubuntu 11.10: Iniciando um novo projeto – versão 2.
  3. Ruby On Rails 3.1.3 com a gem Nifty Generators (compatibilizando) (opcional)
• Para instalar a versão do Rails 3.2.1, siga o tutorial acima (item 1 e 2). Apenas informe a versão do Rails 3.2.1 no lugar das versões anteriores.

IV – O que precisa ser feito antes

• Este post é continuação do trabalho que fizemos em: Aplicação “mestre detalhe” em Rails 3.2.1
• e depois em Autenticação em Ruby On Rails 3.2.1 com Devise.

V – Sequência de passos para implementação

Passo 01 – Entre na aplicação que criamos anteriormente

$ cd service_desk

Passo 02 – Corrigir mensagens

• Para que o app tenha menos código e fique mais DRY (Don’t repeat yourself), vamos corrigir duas views.
• Em app/views/tickets/show.html.erb, retire a seguinte linha

<p id="notice"><%= notice %></p>

• Em app/views/layouts/application.html.erb, modifique a “section main” para que fique da seguinte maneira:

<section id="main">
   <p class="notice"><%= notice %></p>
   <p class="alert"><%= alert %></p>
   <%= yield %>
</section>

Passo 03 – Inclua a coluna username na tabela de usuários (Users)

• A coluna username será única (uniq) na tabela Users.
• A migration irá gerar um índice na mesma tabela Users, para otimizar os acessos pela chave username.

$ rails g migration add_username_to_users username:string:uniq
$ bundle exec rake db:migrate

Passo 04 – Gere as views do Devise

• Para incluir o campo username, que terá a label “login” nas views do Devise, é necessário personalizar as mesmas views.
• Vamos, agora, gerar todas a views do Devise para que seja possível personalizar as telas de registro de usuário, de login de usuário, e tela de modificação de senha.

$ rails g devise:views

• Veja abaixo que foram criados a pasta “devise” e as pastas e arquivos (views) do Devise.

$ tree app/views/devise/
app/views/devise/
├── confirmations
│   └── new.html.erb
├── _links.erb
├── mailer
│   ├── confirmation_instructions.html.erb
│   ├── reset_password_instructions.html.erb
│   └── unlock_instructions.html.erb
├── passwords
│   ├── edit.html.erb
│   └── new.html.erb
├── registrations
│   ├── edit.html.erb
│   └── new.html.erb
├── sessions
│   └── new.html.erb
└── unlocks
    └── new.html.erb

6 directories, 11 files

Passo 05 – Modifique as views do Devise a seguir

• Na view app/views/devise/sessions/new.html.erb:

<div><%= f.label :email %><br /> # delete essa linha
<%= f.email_field :email %></div> # delete essa linha
<div><%= f.label :login %><br /> # insira essa linha
<%= f.text_field :login %></div>  # insira essa linha

• Na view app/views/devise/registrations/new.html.erb:

<div><%= f.label :username %><br /> # insira essa linha
<%= f.text_field :username %></div> # insira essa linha
<div><%= f.label :email %><br /> # mantenha essa linha
<%= f.email_field :email %></div> # mantenha essa linha

• Na view app/views/devise/registrations/edit.html.erb:

<div><%= f.label :username %><br /> # insira essa linha
<%= f.text_field :username %></div> # insira essa linha
<div><%= f.label :email %><br /> # mantenha essa linha
<%= f.email_field :email %></div> # mantenha essa linha

• Na view app/views/devise/passwords/new.html.erb:

<div><%= f.label :email %><br /> # delete essa linha
<%= f.email_field :email %></div> # delete essa linha
<div><%= f.label :login %><br /> # insira essa linha
<%= f.text_field :login %></div> # insira essa linha

Passo 06 – Modifique a label das views para que mostre “username or email” ao usuário

• Modifique o arquivo /config/locales/en.yml para que fique parecido com o trecho abaixo:

en:
  hello: "Hello world"            

  activerecord:
    attributes:
      user:
        login: "Username or email"

Passo 07 – Indique ao Devise para que use :login no authentication_keys

• Modifique o arquivo /config/initializers/devise.rb para que tenha:

config.authentication_keys = [ :login ]

Passo 08 – Agora várias alterações do model User serão necessárias

• Modifique o arquivo /app/model/user.rb para que tenha:

attr_accessible :username, :login

# Virtual attribute for authenticating by either username or email
# This is in addition to a real persisted field like 'username'
attr_accessor :login

# Overwrite Devise’s find_for_database_authentication method
def self.find_for_database_authentication(warden_conditions)
   conditions = warden_conditions.dup
   login = conditions.delete(:login)
   where(conditions).where(["lower(username) = :value OR lower(email) = :value", { :value =>
     login.strip.downcase }]).first
end

protected

 # Attempt to find a user by it's email. If a record is found, send new
 # password instructions to it. If not user is found, returns a new user
 # with an email not found error.
 def self.send_reset_password_instructions(attributes={})
   recoverable = find_recoverable_or_initialize_with_errors(reset_password_keys, attributes, :not_found)
   recoverable.send_reset_password_instructions if recoverable.persisted?
   recoverable
 end 

 def self.find_recoverable_or_initialize_with_errors(required_attributes, attributes, error=:invalid)
   (case_insensitive_keys || []).each { |k| attributes[k].try(:downcase!) }

   attributes = attributes.slice(*required_attributes)
   attributes.delete_if { |key, value| value.blank? }

   if attributes.size == required_attributes.size
     if attributes.has_key?(:login)
        login = attributes[:login]
        record = find_record(login)
     else
       record = where(attributes).first
     end
   end  

   unless record
     record = new

     required_attributes.each do |key|
       value = attributes[key]
       record.send("#{key}=", value)
       record.errors.add(key, value.present? ? error : :blank)
     end
   end
   record
 end

 def self.find_record(login)
   where(["username = :value OR email = :value", { :value => login }]).first
 end

Passo 09 – Alimentar dados automaticamente no sistema

• Vamos usar comandos de inserção de dados, dentro do arquivo “seed.rb”
• Cada vez que alguém iniciar este projeto do zero, será possível inicia-lo com esses dados de exemplo.
• Desta forma, teremos quatro usuários já cadastrados no sistema, todos com a senha 123456:
  • superuser
  • admin
  • user
  • user1
• Modifique o arquivo /db/migrate/seeds.rb para que tenha:

superuser_user = User.create!(:username => 'superuser',
                              :email => 'superuser@example.com',
                              :password => '123456',
                              :password_confirmation => '123456',
                              :confirmed_at => Time.now )
admin_user = User.create!(:username => 'admin',
                          :email => 'admin@example.com',
                          :password => '123456',
                          :password_confirmation => '123456',
                          :confirmed_at => Time.now )
user_user = User.create!(:username => 'user',
                         :email => 'user@example.com',
                         :password => '123456',
                         :password_confirmation => '123456',
                         :confirmed_at => Time.now )
user1_user = User.create!(:username => 'user1',
                          :email => 'user1@example.com',
                          :password => '123456',
                          :password_confirmation => '123456',
                          :confirmed_at => Time.now )                               

# create ticket #1
tkt1 = Ticket.create!( ticket_number: "00001", title: "ticket number 00001" )
Task.create!( description: "task 001 of ticket 00001", ticket_id: tkt1.id )         

# create ticket #2
tkt2 = Ticket.create!( ticket_number: "00002", title: "ticket number 00002" )
Task.create!( description: "task 001 of ticket 00002", ticket_id: tkt2.id )
Task.create!( description: "task 002 of ticket 00002", ticket_id: tkt2.id )         

# create ticket #3
tkt3 = Ticket.create!( ticket_number: "00003", title: "ticket number 00003" )
Task.create!( description: "task 001 of ticket 00003", ticket_id: tkt3.id )
Task.create!( description: "task 002 of ticket 00003", ticket_id: tkt3.id )
Task.create!( description: "task 003 of ticket 00003", ticket_id: tkt3.id )

• Para que o seed acima seja executado, execute o comando:

$ bundle exec rake db:seed

Passo 10 – Conferencia dos Models

• Agora o seu model Ticket (app/model/ticket.rb) terá que ficar assim:

 class Ticket < ActiveRecord::Base
  has_many :tasks    validates :ticket_number, presence: true
  accepts_nested_attributes_for :tasks, :reject_if => proc { |a| a[:description].blank? }, allow_destroy:
 ...true
   attr_accessible :ticket_number, :title
 end

• E seu model Task (app/model/task.rb) assim:

class Task < ActiveRecord::Base
  belongs_to :ticket
  attr_accessible :description, :ticket_id
end

Passo 11 – Execute a aplicação localmente

• Execute o servidor e carregue o browser e na linha de endereços digite http://localhost:3000

$ rails server

VI – Final Feliz

Pronto!
Fizemos o básico para que nosso app web aceite username ou o email do usuário.
Também criamos um arquivo “seed” que poderá ser usado para criar dados iniciais (inclusive usuários) de exemplo no sistema.

VII – Referências

1. Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10
2. Ruby On Rails 3.1.3 no Linux Ubuntu 11.10: Iniciando um novo projeto – versão 2
3. Aplicação “mestre detalhe” em Rails 3.2.1
4. Autenticação em Ruby On Rails 3.2.1 com Devise
5. How To: Allow users to sign in using their username or email address

• Neste post vamos mostrar como implementar a autenticação básica num app web usando a gem Devise com o Rails versão 3.2.1.
• Da autoria da Plataforma Tecnologia, a gem Devise é uma solução flexível para criar aplicações web com o recurso de autenticação.
• Além de permitir que usuários do app web realizem as operações de “sign in” e “sign up”, oferece recursos que são comuns para app que necessitam de gerenciamento de usuários.
• Neste artigo vamos continuar a construir um app web, que iniciamos anteriormente.
• O código fonte gerado neste artigo, está hospedado no Github em https://github.com/sergiosouzalima/service_desk

II – Principais tecnologias usadas neste artigo

• Linux Ubuntu 11.10
• Ruby 1.9.2
• Rails 3.2.1
• gem Devise 2.0

III – O que não precisamos instalar

• Git, RVM, openssl, sqlite3 e outros pacotes necessários.
• Como dependemos de instalações e configurações anteriores, caso seu ambiente não esteja preparado, veja os posts:
  1. Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10
  2. Ruby On Rails 3.1.3 no Linux Ubuntu 11.10: Iniciando um novo projeto – versão 2.
  3. Ruby On Rails 3.1.3 com a gem Nifty Generators (compatibilizando) (opcional)
• Para instalar a versão do Rails 3.2.1, siga o tutorial acima (item 1 e 2). Apenas informe a versão do Rails 3.2.1 no lugar das versões anteriores.

IV – O que precisa ser feito antes

• Este post é continuação do trabalho que fizemos em: Aplicação “mestre detalhe” em Rails 3.2.1

V – Sequência de passos para utilização

Passo 01 – Entre na aplicação que criamos anteriormente

$ cd service_desk

Passo 02 – Gemfile: adicione as gems necessárias

gem 'devise', '2.0.0'

$ bundle install

$ rails g controller Pages index
$ rm public/index.html

$ rails g devise:install
$ rails g devise user

class User < ActiveRecord::Base
  devise :database_authenticatable, :registerable,
    :recoverable, :rememberable, :trackable, :validatable,
    :token_authenticatable, :confirmable, :lockable, :timeoutable

  # Setup accessible (or protected) attributes for your model
  attr_accessible :email, :password, :password_confirmation, :remember_me, :confirmed_at
end

class DeviseCreateUsers < ActiveRecord::Migration   
  def change     create_table(:users) do |t|
      ## Database authenticatable
      t.string :email,              :null => false, :default => ""
      t.string :encrypted_password, :null => false, :default => ""

      ## Recoverable
      t.string   :reset_password_token
      t.datetime :reset_password_sent_at

      ## Rememberable
      t.datetime :remember_created_at

      ## Trackable
      t.integer  :sign_in_count, :default => 0
      t.datetime :current_sign_in_at
      t.datetime :last_sign_in_at
      t.string   :current_sign_in_ip
      t.string   :last_sign_in_ip

      ## Encryptable
      t.string :password_salt

      ## Confirmable
      t.string   :confirmation_token
      t.datetime :confirmed_at
      t.datetime :confirmation_sent_at
      t.string   :unconfirmed_email # Only if using reconfirmable

      ## Lockable
      t.integer  :failed_attempts, :default => 0 # Only if lock strategy is :failed_attempts
      t.string   :unlock_token # Only if unlock strategy is :email or :both
      t.datetime :locked_at

      ## Token authenticatable
      t.string :authentication_token

      t.timestamps
    end

    add_index :users, :email,                :unique => true
    add_index :users, :reset_password_token, :unique => true
    add_index :users, :confirmation_token,   :unique => true
    add_index :users, :unlock_token,         :unique => true
    add_index :users, :authentication_token, :unique => true
  end

$ bundle exec rake db:migrate

== DeviseCreateUsers: migrating ==============================================
-- create_table(:users)
-> 0.0469s
-- add_index(:users, :email, {:unique=>true})
-> 0.0012s
-- add_index(:users, :reset_password_token, {:unique=>true})
-> 0.0011s
== DeviseCreateUsers: migrated (0.0593s) =====================================

class PagesController < ApplicationController
  before_filter :authenticate_user!

  def index
  end

end

config.action_mailer.default_url_options = { :host => 'localhost:3000' }
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = {
:enable_starttls_auto => true,
:address => 'smtp.gmail.com',
:port => '587',
:authentication => :plain,
:domain => 'gmail.com',
:user_name => 'joao_da_silva',
:password => '123456'
}

<!DOCTYPE html>
<html>
  <head>
    <title>Service Desk</title>
    <%= stylesheet_link_tag "application", :media => "all"  %>
    <%= javascript_include_tag "application" %>
    <%= csrf_meta_tags %>
  </head>

  <body>
    <header>
      <h1>Service Desk | Tickets Controller</h1>
    </header>
    <nav>
      <% if user_signed_in? %>
        Signed in as <%= current_user.email %>
        <%= link_to "Sign out", destroy_user_session_path, :method => :delete %>
      <% else %>
        <%= link_to "Sign up", new_user_registration_path %>
        <%= link_to "Sign in", new_user_session_path %>
      <% end %>
    </nav>
    <section id="main">
      <div class="flash">
        <% flash.each do |type, message| -%>
          <div class="message <%= type %>">
            <p><%= message %></p>
          </div>
        <% end -%>
      </div>
      <%= yield %>
    </section>
    <footer>
      <sub>Service Desk | Ticket Controller Web Application</sub>
    </footer>
</body>
</html>

<h1>Home</h1>

<%= link_to 'Tickets', tickets_path %>

<%= link_to 'New Ticket', new_ticket_path %> |
<%= link_to 'Home', root_path %>

resources :tickets
devise_for :users
root :to => "pages#index"

$ rails server

http://localhost:3000

• Neste post vamos mostrar os pontos mais importantes, comumente usados ao criarmos um app web usando o formato “mestre detalhe”
• Vamos criar uma aplicação web para controle de chamados (tickets), muito comum em ambientes como um Service Desk, que será o nome de nossa aplicação.
• Para cada ticket, existem várias tarefas associadas, que chamamos aqui de tasks.
• A continuação deste artigo está em Autenticação em Ruby On Rails 3.2.1 com Devise.

II – Principais tecnologias usadas neste artigo

• Linux Ubuntu 11.10
• Ruby 1.9.2
• Rails 3.2.1

III – O que não precisamos instalar

• Git, RVM, openssl, sqlite3 e outros pacotes necessários.
• Como dependemos de instalações e configurações anteriores, caso seu ambiente não esteja preparado, veja os posts:
  1. Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10
  2. Ruby On Rails 3.1.3 no Linux Ubuntu 11.10: Iniciando um novo projeto – versão 2.
  3. Ruby On Rails 3.1.3 com a gem Nifty Generators (compatibilizando) (opcional)
• Para instalar a versão do Rails 3.2.1, siga o tutorial acima (item 1 e 2). Apenas informe a versão do Rails 3.2.1 no lugar das versões anteriores.

IV – Sequência de passos para criação

Passo 01 - Crie a aplicação 

$ rails new service_desk
$ cd service_desk

Passo 02 - Ajuste seu arquivo Gemfile

• Acrescente as linhas abaixo no arquivo Gemfile

gem 'execjs'    # necessário para Linux
gem 'therubyracer'  # necessário para Linux

• em seguida…

$ bundle install

Passo 03 – Crie os models da aplicação e execute as migrations

$ rails g scaffold ticket ticket_number:string:uniq title:string
$ rails g model task description:string ticket:belongs_to
$ bundle exec rake db:migrate

Passo 04 – Ajuste os models Ticket e Task conforme estão a seguir 

class Ticket
  has_many :tasks
  attr_accessible :ticket_number, :title, :tasks_attributes
  validates :ticket_number, presence: true
  accepts_nested_attributes_for :tasks, :reject_if => proc { |a| a[:description].blank? }, allow_destroy: true
end 

class Task
  belongs_to :ticket
  attr_accessible :description
end

Passo 05 – Copie e cole o arquivo application.html.erb, que está a seguir

• app/views/layouts/application.html.erb  

<!DOCTYPE html>
<html>
  <head>
    <title>Service Desk</title>
    <%= stylesheet_link_tag "application" %>
    <%= javascript_include_tag "application" %>
    <%= csrf_meta_tags %>
  </head>

  <body>
    <header>
      <h1>Service Desk | Tickets Controller</h1>
    </header>
    <section id="main">
      <%= yield %>
    </section>
    <footer>
      <sub>Service Desk | Ticket Controller Web Application</sub>
    </footer>
  </body>
</html>

Passo 06 – Ajustes para mostrar as tarefas (Tasks)

• Em app/views/tickets/_form.html.erb, adicione o trecho abaixo, antes do botão submit:

<hr/>
 <h2>Task</h2>
 <table>
   <tr><th>Task</th><th>destroy ?</th></tr>
   <% @ticket.tasks.each do |tsk| %>
     <%= f.fields_for :tasks, tsk do |tsk| %>
       <%= render :partial => 'task', locals: {t: tsk} %>
     <% end %>
   <% end %>
 </table>
 <hr/>

• Crie um arquivo: app/views/tickets/_task.html.erb
• Copie e cole o seguinte conteúdo

<tr>
   <td class="field">
     <%= t.text_field :description %>
   </td>
   <td>
     <%= t.check_box :_destroy %>
   </td>
 </tr>

Passo 07 – Ajustes para exibição de Ticket e Tasks

• Em app/views/tickets/show.html.erb
• Substitua o que estiver abaixo do campo title, pelo seguinte trecho de código

<hr/>
 <h2>Task</h2>
 <table>
   <tr>
     <th>Task
     </th>
   </tr>
   <% @ticket.tasks.each do |tsk| %>
     <tr>
       <td class="field">
         <%= tsk.description %>
       </td>
     </tr>
   <% end %>
 </table>
 <hr/>
<%= link_to 'New Ticket', new_ticket_path %> |
<%= link_to 'Edit', edit_ticket_path(@ticket) %> |
<%= link_to 'View All', tickets_path %>

Passo 08 – Ajuste as actions New e Edit 

• Em app/controllers/tickets_controller.rb
• Ajuste as actions New e Edit para que fiquem como a seguir

def new
 @ticket = Ticket.new
 @ticket.tasks.build
 respond_to do |format|
   format.html # new.html.erb
   format.json { render json: @ticket }
 end
end

def edit
 @ticket = Ticket.find(params[:id])
 @ticket.tasks.build
end

V – Executando a aplicação

• Para ver o resultado localmente. 

$ rails s

• Carregue o browser, e digite na linha de endereços: http://localhost:3000/tickets

VI – Final Feliz

Pronto! Fizemos o básico para iniciarmos um novo projeto usando Ruby On Rails 3.2.1 no Linux Ubuntu 11.10. A aplicação funciona mantendo dois Models: Ticket e Tasks, num formulário tipo mestre-detalhe.

VII – Referências

(1) Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10
(2) Ruby On Rails 3.1.3 no Linux Ubuntu 11.10: Iniciando um novo projeto – versão 2 

• Neste post vamos mostrar os pontos mais importantes comumente usados ao criarmos um app web usando o formato “mestre detalhe”.
• Vamos criar uma aplicação web para controle de chamados (tickets), muito comum em ambientes como um Service Desk, que será o nome de nossa aplicação.
• Para cada ticket, existem várias tarefas associadas, que chamamos aqui de tasks.
• Se preferir usar o Rails versão 3.2.1, vá para este post.

II – Principais tecnologias usadas neste artigo

• Linux Ubuntu 11.10
• Ruby 1.9.2
• Rails 3.1.3

III – O que não precisamos instalar

• Git, RVM, openssl, sqlite3 e outros pacotes necessários.
• Como dependemos de instalações e configurações anteriores, caso seu ambiente não esteja preparado, veja os posts:
  • Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10
  • Ruby On Rails 3.1.3 no Linux Ubuntu 11.10: Iniciando um novo projeto – versão 2.
  • Ruby On Rails 3.1.3 com a gem Nifty Generators (compatibilizando) (opcional)

IV – Sequência de passos para criação

Passo 01 - Crie a aplicação 

$ rails new service_desk
$ cd service_desk

Passo 02 - Ajuste seu arquivo Gemfile

• Acrescente as linhas abaixo no arquivo Gemfile

gem 'execjs'    # necessário para Linux
gem 'therubyracer'  # necessário para Linux

• em seguida…

$ bundle install

Passo 03 – Crie os models da aplicação e execute as migrations

$ rails g scaffold ticket ticket_number:string title:string
$ rails g model task description:string ticket:belongs_to
$ bundle exec rake db:migrate

Passo 04 – Ajuste os models Ticket e Task conforme estão a seguir 

class Ticket
  has_many :tasks
  attr_accessible :ticket_number, :title, :tasks_attributes
  validates :ticket_number, presence: true
  accepts_nested_attributes_for :tasks, :reject_if => proc { |a| a[:description].blank? }, allow_destroy: true
end 

class Task
  belongs_to :ticket
  attr_accessible :description
end

Passo 05 – Copie e cole o arquivo application.html.erb, que está a seguir

• app/views/layouts/application.html.erb  

<!DOCTYPE html>
<html>
  <head>
    <title>Service Desk</title>
    <%= stylesheet_link_tag "application" %>
    <%= javascript_include_tag "application" %>
    <%= csrf_meta_tags %>
  </head>

  <body>
    <header>
      <h1>Service Desk | Tickets Controller</h1>
    </header>
    <section id="main">
      <%= yield %>
    </section>
    <footer>
      <sub>Service Desk | Ticket Controller Web Application</sub>
    </footer>
  </body>
</html>

Passo 06 – Ajustes para mostrar as tarefas (Tasks)

• Em app/views/tickets/_form.html.erb, adicione o trecho abaixo, antes do botão submit:

<hr/>
 <h2>Task</h2>
 <table>
   <tr><th>Task</th><th>destroy ?</th></tr>
   <% @ticket.tasks.each do |tsk| %>
     <%= f.fields_for :tasks, tsk do |tsk| %>
       <%= render :partial => 'task', locals: {t: tsk} %>
     <% end %>
   <% end %>
 </table>
 <hr/>

• Crie um arquivo: app/views/tickets/_task.html.erb
• Copie e cole o seguinte conteúdo

<tr>
   <td class="field">
     <%= t.text_field :description %>
   </td>
   <td>
     <%= t.check_box :_destroy %>
   </td>
 </tr>

Passo 07 – Ajustes para exibição de Ticket e Tasks

• Em app/views/tickets/show.html.erb
• Substitua o que estiver abaixo do campo title, pelo seguinte trecho de código

<hr/>
 <h2>Task</h2>
 <table>
   <tr>
     <th>Task
     </th>
   </tr>
   <% @ticket.tasks.each do |tsk| %>
     <tr>
       <td class="field">
         <%= tsk.description %>
       </td>
     </tr>
   <% end %>
 </table>
 <hr/>
<%= link_to 'New Ticket', new_ticket_path %> |
<%= link_to 'Edit', edit_ticket_path(@ticket) %> |
<%= link_to 'View All', tickets_path %>

Passo 08 – Ajuste as actions New e Edit 

• Em app/controllers/tickets_controller.rb
• Ajuste as actions New e Edit para que fiquem como a seguir

def new
 @ticket = Ticket.new
 @ticket.tasks.build
 respond_to do |format|
   format.html # new.html.erb
   format.json { render json: @ticket }
 end
end

def edit
 @ticket = Ticket.find(params[:id])
 @ticket.tasks.build
end

V – Executando a aplicação

• Para ver o resultado localmente. 

$ rails s

• Carregue o browser, e digite na linha de endereços: http://localhost:3000/tickets

VI – Final Feliz

Pronto! Fizemos o básico para iniciarmos um novo projeto usando Ruby On Rails 3.1.3 no Linux Ubuntu 11.10. A aplicação funciona mantendo dois Models, Ticket e Tasks, num formulário tipo mestre-detalhe.

VII – Referências

(1) Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10
(2) Ruby On Rails 3.1.3 no Linux Ubuntu 11.10: Iniciando um novo projeto – versão 2
(3) Aplicação “mestre detalhe” em Rails 3.2.1

Neste post vamos mostrar como usar a gem Nifty Generators com o Rails versão 3.1.x.

Da autoria de Ryan Bates, a gem Nifty Generators, cria, entre outras coisas, um scaffold estilizado, muito útil para servir como base para uma aplicação.

Compatibilidade
A gem Nifty Generators ainda não está compatível com o Rails versão 3.1.x, então faremos alguns procedimentos temporários até que os dois estejam compatíveis.

II – Principais tecnologias usadas neste artigo

• Linux Ubuntu 11.10
• Ruby 1.9.2
• Rails 3.1.3
• gem Nifty Generators

III – O que não precisamos instalar

• Git, RVM, openssl, sqlite3 e outros pacotes necessários.
• Como dependemos de instalações e configurações anteriores, caso seu ambiente não esteja preparado, veja os posts:
  • Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10
  • Ruby On Rails 3.1.3 no Linux Ubuntu 11.10: Iniciando um novo projeto – versão 2.

IV – Sequência de passos para utilização

Passo 01 – Crie uma aplicação

$ rails new people
$ cd people

Passo 02 – Gemfile: adicione as gems necessárias

gem 'execjs'    # necessário para Linux
gem 'therubyracer'  # necessário para Linux

group :test do
  # Pretty printed test output
  gem 'turn', '0.8.2', :require => false
  gem "mocha"
end

group :development do
  gem "nifty-generators"
end

$ bundle install

$ rails generate nifty:layout
$ mv public/stylesheets/application.css app/assets/stylesheets
$ rm -r public/stylesheets/

<%= stylesheet_link_tag "application" %>
<%= javascript_include_tag "application" %>

$ rails generate nifty:scaffold person name:string
$ bundle exec rake db:migrate

root :to => "people#index"

$ rm public/index.html
$ rails server

Neste post vamos mostrar os pontos mais importantes comumente usados ao iniciar um novo projeto em Ruby On Rails, mas agora de maneira mais específica, pois já falamos sobre este assunto anteriormente neste post: Ruby On Rails 3.1.3 no Linux Ubuntu 11.10: Iniciando um novo projeto.

II – Principais tecnologias usadas neste artigo

• Linux Ubuntu 11.10
• Ruby 1.9.2
• Rails 3.1.3
• RVM
• BitBucket site de hosting de aplicações, onde vamos armazenar os fontes
• Webbynode site onde vamos distribuir  (deployment) o app que vamos criar.

III – O que não precisamos instalar

• Git, RVM, openssl, sqlite3 e outros pacotes necessários.
• Como dependemos de instalações e configurações anteriores, veja o post  Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10 para garantir que o ambiente está preparado.

IV – Sequência de passos para instalação

Passo 01 - Instalação do Ruby versão 1.9.2

• Para verificar a versão atual acesse: http://www.ruby-lang.org/en/downloads/
• Para verificar se a versão do Ruby 1.9.2 já está instalado em seu ambiente use:
  $ rvm list rubies
• Para instalar o Ruby vamos usar o RVM, o gerenciador de versões Ruby, instalado anteriormente.

$ rvm install 1.9.2 (vai demorar)
$ rvm list
$ rvm use 1.9.2 (ou “rvm –default use 1.9.2″ torna esta, a versão default neste ambiente)
$ rvm list
$ ruby –version (versão do Ruby que você está usando)

Passo 02 – Atualize Rake e RubyGems

• Vamos atualizar o Rake
• Para verificar a versão atual acesse: http://rubygems.org/gems/rake
  

$ rake –version (Para ver a versão do Rake. O Rake versão 0.9.2.2 vem com o Ruby 1.9.3)
$ gem update rake
$ rake –version

• Agora vamos atualizar o RubyGems
• O RubyGems é um gerenciador de pacotes padrão que vem como parte da instalação do Ruby.
• Para verificar a versão atual acesse: http://rubygems.org/pages/download

$ gem –version (versão do RubyGem que você está usando. Deve ser versão 1.8.11 ou mais atual)
$ gem update –system
$ gem –version

Passo 03 – Crie e use um novo gemset para cada um de seus projetos

• É uma boa idéia usar um gemset específico para cada um dos seus projetos, juntamente com o seu arquivo Gemfile específico.
• Desta forma, apesar de você atualizar as gems de um “ProjectA” através da atualização para gems mais recentes, as mesmas gems não mudarão para o “ProjectB” – eliminando a possibilidade de interferência de gems, entre os projetos.

$ rvm list gemsets (para ver uma lista das versões de Ruby e gemsets instalados)
$ rvm gemset create gemset_myproject  (crie um gemset para este projeto)
$ rvm use ruby-1.9.2-p290@gemset_myproject
$ rvm list gemsets
$ ls -l ~/.rvm/gems/ruby-1.9.2-p290@gemset_myproject (para consultar as gems instaladas nesse novo gemset. Por enquanto deve estar vazio)
$ gem list –local (traz a mesma informação anterior)

Passo 04 – Instalação do Rails.

• Finalmente instale o Rails 3.1.3 dentro da gemset criada anteriormente.
• Para verificar a versão atual acesse: http://rubygems.org/gems/rails

$ rails –version (Verifique versão do Rails. Vai retornar um erro: você ainda não instalou o Rails)
$ gem install rails –version 3.1.3 –no-rdoc –no-ri (ou “gem install rails”, instala a versão atual mais estável do Rails. Os parâmetros “–no-rdoc” e “–no-ri”, não instalam as documentações e são opcionais)
$ rails –version
$ ls -l ~/.rvm/gems/ruby-1.9.2-p290@gemset_myproject/gems (para consultar as gems instaladas nesse novo gemset. Agora não deve estar vazio)
$ gem list –local (traz a mesma informação anterior)

V – Criando uma aplicação

Itens específicos. 

• Esta parte “V – Criando uma aplicação”, é específica por conta dos seguintes itens que estaremos usando:
  • Hospedagem dos fontes:  BitBucket (você deve ter uma conta aqui)
  • Hospedagem do site que estamos criando:  Webbynode (você deve ter uma conta aqui).
  • O banco de dados em ambiente de produção: PostgreSQL.
  • Web server em ambiente de desenvolvimento: Unicorn.
• Você poderá seguir os passos abaixo, ou adaptá-los conforme sua necessidade.

Repositório para hospedar os fontes. 

• Crie um repositório no site Bitbucket, que você abriu uma conta para hospedar os fontes.
• Para seguir o exemplo o nome do respositório deverá ser “demo”.

Sequência de comandos. 

$ rails new demo
$ cd demo
$ gem install webbynode (gem da Webbynode para o deployment)
$ wn webbies  (consulte os lugares disponíveis na Webbynode – conhecidas como webbies)
$ webbynode init nome_da_webby  (nome_da_webby é o nome da webby escolhido anteriormente)

• Acrescente as linhas abaixo no arquivo Gemfile da aplicação demo.

gem ‘execjs’    # necessário para Linux
gem ‘therubyracer’  # necessário para Linux
group :production do
gem ‘pg’
end
# Use unicorn as the web server
gem ‘unicorn’

• Continuando, execute os comandos abaixo:

$ bundle install –without production
$ rails g scaffold user name:string age:integer
$ bundle exec rake db:migrate
$ bundle exec rake assets:precompile

• Você lembra qual a gemset que estamos trabalhando ?
• Para poupar o trabalho de ajustar a gemset e versão do Ruby cada vez que usar este projeto, podemos deixar que o próprio RVM ajuste isto para nós.
• Para isto crie um arquivo na raiz do projeto, chamado “.rvmrc”
• O conteúdo será:
  rvm use ruby-1.9.2-p290@gemset_myproject

• Continuando, execute os comandos abaixo:

$ git init
$ git remote add demo https://seu_nome_usuario@bitbucket.org/seu_nome_usuario/demo.git
$ git status
$ git add .
$ git commit -am “created user model, controller, view”
$ git push demo master:master

$ wn push  # deployment para a Webbynode

Para ver o resultado localmente. 

$ bundle exec unicorn   # roda na porta 8080

• Carregue o browser, e digite na linha de endereços:
  localhost:8080/users

Para ver o resultado em produção. 

• Carregue o browser, e digite na linha de endereços:

  http://demo.webbyapp.com/users

VI – Final Feliz

Pronto!
Fizemos o básico para iniciarmos um novo projeto usando Ruby On Rails 3.1.3 no Linux Ubuntu 11.10.
Agora a aplicação Demo,  funciona em seu browser, permitindo localmente, manipular registros de pessoas e consulta-las, e funciona na internet também, hospedado na Webbynode.

VII – Referências

(1) Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10
(2) Ruby On Rails 3.1.3 no Linux Ubuntu 11.10: Iniciando um novo projeto 

I – Introdução

Neste post vamos mostrar os pontos mais importantes comumente usados ao iniciar um novo projeto em Ruby On Rails.

Como dependemos de instalações e configurações anteriores, recomendamos analisar o post Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10 para garantir que o ambiente está preparado.

Vamos a sequência de comandos usando o terminal (prompt) do Linux.

II – Principais tecnologias usadas neste artigo

• Linux Ubuntu 11.10
• Ruby 1.9.3
• Rails 3.1.3
• RVM

III – O que não precisamos instalar

• ruby, rake e gem (RubyGems) não precisamos instalar, já que foram instaladas anteriormente. Ver post Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10
• Para verificar onde esses arquivos estão, faça:

$ ls -l  ~/.rvm/rubies/ruby-1.9.3-p0/bin/

• Outra verificação que pode ser feita.
• Execute abaixo o comando “rvm list rubies” para ver uma lista das versões de Ruby instaladas.

$ rvm list rubies

• Caso não apareça o Ruby “ruby-1.9.3-p0″ siga os passos do post Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10 – você deve ter o Ruby versão 1.9.3 instalado.

IV – Sequência de passos para instalação

Passo 01 – Mude (use) para o ruby 1.9.3

• Utilizando o gerenciador de versões Ruby, RVM, comece a usar agora o “ruby-1.9.3-p0″

$ rvm use ruby-1.9.3-p0

Passo 02 – Atualize Rake e RubyGems

• Vamos atualizar o Rake
• Para verificar a versão atual acesse: http://rubygems.org/gems/rake
  

$ rake –version (Para ver a versão do Rake. O Rake versão 0.9.2.2 vem com o Ruby 1.9.3)
$ gem update rake
$ rake –version

• Agora vamos atualizar o RubyGems
• O RubyGems é um gerenciador de pacotes padrão que vem como parte da instalação do Ruby.
• Para verificar a versão atual acesse: http://rubygems.org/pages/download

$ gem –version (versão do RubyGem que você está usando. Deve ser versão 1.8.11 ou mais atual)
$ gem update –system
$ gem –version

Passo 03 – Crie e use um novo gemset para cada um de seus projetos

• É uma boa idéia usar um gemset específico para cada um dos seus projetos, juntamente com o seu arquivo Gemfile específico.
• Desta forma, apesar de você atualizar as gems de um “ProjectA” através da atualização para gems mais recentes, as mesmas gems não mudarão para o “ProjectB” – eliminando a possibilidade de interferência de gems, entre os projetos.

$ rvm list gemsets (para ver uma lista das versões de Ruby e gemsets instalados.
$ rvm gemset create gemset_myproject  (crie um gemset para este projeto)
$ rvm use ruby-1.9.3-p0@gemset_myproject
$ rvm list gemsets
$ ls -l ~/.rvm/gems/ruby-1.9.3-p0@gemset_myproject (para consultar as gems instaladas nesse novo gemset. Por enquanto deve estar vazio)
$ gem list –local (traz a mesma informação anterior. Aqui só deve mostrar o bundler)

Passo 04 – Instalação do Rails.

• Finalmente instale o Rails 3.1.3 dentro da gemset criada anteriormente.
• Para verificar a versão atual acesse: http://rubygems.org/gems/rails

$ rails –version (Para verificar a versão do Rails)
$ gem install rails –version 3.1.3 –no-rdoc –no-ri (ou “gem install rails”, instala a versão atual mais estável do Rails. Os parâmetros “–no-rdoc” e “–no-ri”, não instalam as documentações e são opcionais)
$ rails –version
$ ls -l ~/.rvm/gems/ruby-1.9.3-p0@gemset_myproject/gems (para consultar as gems instaladas nesse novo gemset. Agora não deve estar vazio)
$ gem list –local (traz a mesma informação anterior)

V – Criando uma aplicação

$ cd ~
$ rails new people
$ cd people

• Caso você esteja usando Linux, acrescente as linhas abaixo no arquivo Gemfile da aplicação People:

gem ‘execjs’
gem ‘therubyracer’

• Execute os comandos abaixo:

$ bundle install
$ bundle list (para ter uma lista com as gems “empacotadas” no seu projeto)
$ rails generate scaffold person name:string
$ bundle exec rake db:migrate (*)
$ rails server

(*) Lembre-se, é uma boa prática executar “bundle exec rake …” em vez de simplesmente executar “rake …”.

• Carregue o browser, e digite na linha de endereços:

localhost:3000/people

VI – Final Feliz

Pronto!
Fizemos o básico para iniciarmos um novo projeto usando Ruby On Rails 3.1.3 no Linux Ubuntu 11.10.
Agora a aplicação People,  funciona em seu browser, permitindo localmente, manipular registros de pessoas e consulta-las.

VII – Referências

(1) Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10

I – Introdução

Neste post publico uma solução que tive que desenvolver para usar acentuação.

Eu tenho um Macbook Pro e tenho o Linux Ubuntu versão 11.10 virtualizado no equipamento.

Portanto, para quem é usuário de um Macbook, já sabe que o teclado é padrão americano, e no Linux Ubuntu 11.10, essa configuração para acentuação em português, não vem como padrão.

Vamos a sequência de comandos usando o terminal (prompt) do Linux.

II – Principais tecnologias usadas neste artigo

• Linux Ubuntu 11.10

III – Sequência de passos para configuração

Passo 01.

$ setxkbmap us -variant intl

• Apenas com o comando acima, já é possível verificar que o teclado já responde às acentuações.
• Tente o ç (cedilha) por exemplo: teclas ‘ (apóstrofe) + c (letra c)

Passo 02.

• Além disso temos que deixar esta solução de acentuação permanente.
• Quero dizer, se sairmos do Linux e entrarmos novamente, esta configuração será perdida.
• Para deixar a configuração de acentuação permanente:
  • Adicione a seguinte linha no arquivo “profile” que está na pasta “/etc” e salve o arquivo:
    • setxkbmap us -variant intl
  • Vamos ao passo a passo:
    • Para editar este arquivo você terá que usar o comando “sudo”.
    • Por exemplo, se você usar o editor “vi” para editar o arquivo, ficará assim:
      • $ sudo vi /etc/profile
      • Informe a senha que o comando “sudo” solicita
      • Vá para a última linha deste arquivo e acrescente a linha “setxkbmap us -variant intl”
      • Salve e saia do editor com o comando:
        • :wq (dois pontos + w + q)

IV – Testando a Acentuação

• Para testar, saia (shutdown) do Linux e carregue novamente.
• A acentuação deve permanecer.
• Este artigo foi escrito usando essa configuração

Pronto!
Configuramos o teclado no Linux Ubuntu versao 11.10 para aceitar o teclado de um Macbook, padrão americano e permitir acentuação em português.

V – Referências e Créditos

(1) http://blog.intermol.com.br/category/nix/

I – Introdução

Neste post vamos instalar o editor de programas Vim para desenvolvimento em Ruby On Rails no Linux Ubuntu versão 11.10.

Vamos a sequência de comandos usando o terminal (prompt) do Linux.

II – Principais tecnologias usadas neste artigo

• Linux Ubuntu 11.10
• Ruby 1.9.3
• Rails 3.1.1
• Vim

III – Sequência de passos para instalação

Passo 01.

$ vim –version
$ cd ~
$ sudo aptitude install vim
$ vim –version

Passo 02.

• Vamos usar a configuração que o Akita (1) criou, e está disponível no github (2):

$ git clone git://github.com/akitaonrails/vimfiles.git ~/.vim
$ cd ~/.vim
$ git submodule update –init

• Talvez o erro abaixo ocorra:

fatal: reference is not a tree: 5ac7bda6c8677639155bd9a267aa1a20cd4e7881
Unable to checkout ’5ac7bda6c8677639155bd9a267aa1a20cd4e7881′ in submodule path ‘bundle/Command-T’

• Caso aconteça o erro acima, execute os seguintes comandos:

$ git rm bundle/Command-T –cache
$ git submodule update –init

Passo 03.

• Agora você deverá criar os arquivos vimrc e gvimrc:

$ echo “source ~/.vim/vimrc” > ~/.vimrc
$ echo “source ~/.vim/gvimrc” > ~/.gvimrc

Passo 04.

• Execute o comando abaixo:

$ cd ~
$ sudo apt-get install exuberant-ctags ncurses-term

Passo 05.

• Este item é opcional.
• Faça este item caso queira que o gerenciador de arquivos (chamado Nerd Tree), abra automaticamente ao carregar o Vim.
• Para isto adicione as seguintes linhas ao arquivo “~/.vimrc”:autocmd VimEnter * NERDTree
  autocmd VimEnter * wincmd p

IV – Testando o Vim

• Crie ou use uma aplicação em Ruby On Rails para testar o editor Vim.
• Se você não tem o Rails instalado, siga o seguinte tutorial para instalação e configuração do Rails no Linux Ubuntu: Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10 (3)
• Para testar o Vim, entre numa aplicação.  Por exemplo, a aplicação People:

$ cd ~/people
$ vim

Pronto!
Instalamos e configuramos o editor Vim para ser usado para programação em Ruby On Rails no Linux Ubuntu.

V – Referências e Créditos

(1) http://www.akitaonrails.com/
(2) https://github.com/akitaonrails/vimfiles

(3) Instalação do Ruby On Rails 3.1.1 no Linux Ubuntu 11.10

I – Introdução

Neste post vamos instalar o ambiente mínimo necessário para o desenvolvimento de aplicações web usando o framework Ruby On Rails.

De maneira mais específica, o presente artigo trata da instalação do Ruby versão 1.9.3 e do Ruby On Rails versão 3.1.1 no Linux Ubuntu versão 11.10.

Também testei, com sucesso, o mesmo modelo de instalação usando o Linux Ubuntu versão 11.04. Vamos a sequência de comandos usando o terminal (prompt) do Linux.

II – Principais tecnologias usadas neste artigo

• Linux Ubuntu 11.10
• Ruby 1.9.3
• Rails 3.1.1

III – Sequência de passos para instalação

Passo 01.

• Neste artigo em especial vamos usar o instalador de pacotes aptitude.
• O instalador apt-get poderia ser usado, mas considero que o aptitude tem uma qualidade um pouco melhor.

$ cd /
$ aptitude –version (versão do aptitude que você está usando)
$ sudo apt-get update
$ sudo apt-get upgrade (aguarde)
$ sudo apt-get install aptitude
$ sudo aptitude update
$ sudo aptitude upgrade
$ aptitude –version (versão do aptitude que você está usando)

Passo 02.

• Instalação do git e do curl

$ sudo aptitude install build-essential git-core curl
$ git –version
$ curl –version

Passo 03.

• Instalação do RVM.
• O RVM é um gerenciador de versões. Ele permite que seja possível usar várias versões do Ruby.
• Permite instalar, gerenciar e trabalhar com múltiplos ambientes Ruby, e conjunto de gems.

$ bash -s stable < <(curl -s https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer)

• Se você já tem o RVM instalado, faça os passos abaixo para atualiza-lo:
  $ rvm -v (versão do RVM que você está usando)
  $ rvm get latest ## se aqui aparecer erro, execute “rvm update –head”
  $ rvm reload
  $ rvm -v (versão do RVM que você está usando)
• Mude o seu arquivo ~/.bashrc para que a ultima linha fique assim:
  [[ -s "$HOME/.rvm/scripts/rvm" ]] && source “$HOME/.rvm/scripts/rvm” # Load RVM into a shell session *as a function*

• Feche e abra a tela do terminal novamente.

$ cd /
$ rvm -v (versão do RVM que você está usando)

Passo 04.

• Agora vamos instalar vários pacotes necessários ao ambiente

$ sudo aptitude install build-essential openssl libreadline6 libreadline6-dev zlib1g zlib1g-dev zlib libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev automake libtool bison
$ rvm pkg install zlib
$ sudo aptitude install zlib1g-dev
$ sudo aptitude install libsqlite3-dev

Passo 05.

• Instalação do openssl

$ rvm pkg install openssl (vai demorar um pouco)

Passo 06.

• Instalação do Ruby versão 1.9.3
• Para verificar a versão atual acesse: http://www.ruby-lang.org/en/downloads/
• Para instalar o Ruby vamos usar o RVM, o gerenciador de versões Ruby, instalado anteriormente.

$ rvm install 1.9.3 (vai demorar)
$ rvm list
$ rvm –default use 1.9.3 (faz com que o Ruby 1.9.3 seja a versão default neste ambiente)
$ rvm list
$ ruby –version (versão do Ruby que você está usando)

Passo 07.

• Instalação do RubyGems.
• O RubyGems é um gerenciador de pacotes padrão que vem como parte da instalação do Ruby.
• Para verificar a versão atual acesse: http://rubygems.org/pages/download

$ gem –version (versão do RubyGem que você está usando. Deve ser versão 1.8.11 ou mais atual)
$ gem update –system
$ gem –version

Passo 08.

• Crie um gemset default.

$ rvm 1.9.3@rails311 –create –default (é uma boa ideia criar uma gemset específica por projeto)
$ rvm gemset list (para ver as gems que você tem nesta gemset)
$ rvm list gemsets (para ver uma lista das versões de Ruby e gemsets instaladas)
$ gem list (para ver uma lista das gems incluidas na instalação padrão do Ruby)

Passo 09.

• Atualize o Rake.
• Para verificar a versão atual acesse: http://rubygems.org/gems/rake

$ gem update rake
$ rake –version (Para ver a versão do Rake. O Rake versão 0.9.2.2 vem com o Ruby 1.9.3)

Passo 10.

• Finalmente instale o Rails 3.1.1.
• Para verificar a versão atual acesse: http://rubygems.org/gems/rails

$ rails –version (Para verificar a versão do Rails)
$ gem install rails –version 3.1.1 –no-rdoc –no-ri (ou “gem install rails”, instala a versão atual mais estável do Rails. Os parâmetros “–no-rdoc” e “–no-ri”, não instalam as documentações e são opcionais)
$ rails –version

IV – Criando uma aplicação para testar a instalação

$ cd ~
$ rails new people
$ cd people

• Acrescente as linhas abaixo no arquivo Gemfile da aplicação People:

gem ‘execjs’ gem ‘therubyracer’

• Execute os comandos abaixo:

$ bundle install
$ rails generate scaffold person name:string
$ bundle exec rake db:migrate (*)
$ rails server (*) Lembre-se, é uma boa prática executar “bundle exec rake …” em vez de simplesmente executar “rake”.

• Carregue o browser, e digite na linha de endereços:

localhost:3000/people

Pronto! Instalamos o ambiente de desenvolvimento Ruby On Rails no Linux Ubuntu. Agora a aplicação People,  funciona em seu browser, permitindo localmente, manipular registros de pessoas e consulta-las.

V – Referências

(1) http://www.compilando.org/wp/programacao/como-instalar-o-rvm-no-ubuntu-11-04-natty
(2) http://babinho.net/2011/05/rails-3-1-beta-on-ubuntu/
(3) http://railsapps.github.com/installing-rails-3-1.html