Tudo que quero saber!

Jay Fields anunciou em seu blog que o livro Refactoring: Ruby Edition está a venda na loja virtual Safari. Para quem já leu a versão antiga em Java, esta obra dispensa apresentações, eu recomendo a todos que gostam de código bem escrito.

Os autores dos livros são Jay Fields, Shane Harvie, Martin Fowler e com a participação de Kent Beck.

Update 04/04/2008: Se encontrar algum problema ao instalar o primeiro script, retire o pacote openssl-ruby1.8.

Quem já se desligou da Microsoft seja para usar Mac ou qualquer outra distribuição Linux, sabe como é melhor estar em um ambiente livre.

Se você programa com TDD e seus testes demoram 15 segundos para serem executados, no linux eles vão demorar de 2 a 3 segundos. Alguém ainda tem tempo para perder?

Hoje eu uso o Mac osx mas não gosto de ver meus amigos usando o sistema do tio bill.

Vamos partir do princípio que você tem um HD novo e quer instalar Windows e Ubuntu. Eu gosto de fazer 3 partições. Uma para Windows, uma para o Ubuntu e outra para guardar os arquivos independente do sistema operacional.

Já gravou seu cd do Ubuntu? Você vai precisar, entre no http://www.ubuntu.com/getubuntu pegue a ultima versão e queime.

1. Instale o windows na primeira partição.
2. De um boot com o cd do Ubuntu na máquina e divirta-se enquanto ele faz todo trabalho para você, se você não sabe, durante a instalação sua conexão com a internet estará disponível, abuse do Firefox e vá ler seus feeds.
3. Você deverá formatar a terceira partição com o formato que quiser. Essa discussão é muito grande, então decida se irá usar FAT, NTFS, EXT3. Se você usar a EXT 3 seu windows não irá enxergar essa partição. Mas quem precisa de windows?

Feito isso você deverá ter os 2 sistemas operacionais bootando na sua máquina.

Vamos agora configurar seu ambiente ruby/rails. Para isso na Inovare desenvolvemos alguns scripts para ajudar neste ambiente inicial.

Abra seu terminal no Ubuntu.

Utilize o comando sudo passwd para definir uma senha de super usuário.

Entre em modo super usuário digitando su e apertando enter.

Agora você pode aplicar os scripts que estão no endereço http://inovare.svnrepository.com/svn/public/tools_inovare/linux/scripts/

Vamos utilizar apenas os 3 primeiros scripts(eles já salvaram muita dor de cabeça).

Vamos baixá-los e executar. Faça um comando de cada vez.

wget http://inovare.svnrepository.com/svn/public/tools_inovare/linux/scripts/01_install_packages
bash 01_install_packages

wget http://inovare.svnrepository.com/svn/public/tools_inovare/linux/scripts/02_install_rubygems
bash 02_install_rubygems

wget http://inovare.svnrepository.com/svn/public/tools_inovare/linux/scripts/03_install_all_gems
ruby 03_install_all_gems

Esse processo deve demorar um pouco, mas depois seu ambiente já estará 100%, com mongrel, RedCloth, sqlite3-ruby, ZenTest, rails, capistrano, termios, mocha, rmagick.

Espero que isso seja útil e se ocorrer algum erro no caminho ou quer dar alguma sugestão para melhorar esse processo, por favor deixe seu comentário. Não uso mais o Ubuntu mas à alguns dias precisei refazer uma instalação e usei este mesmo processo.

__________________ conteúdo dos arquivos:
01_install_packages

apt-get update

apt-get install ruby1.8-dev ruby1.8 ri1.8 rdoc1.8 irb1.8 libreadline-ruby1.8 libruby1.8 -y --force-yes

ln -s /usr/bin/ruby1.8 /usr/local/bin/ruby
ln -s /usr/bin/ri1.8 /usr/local/bin/ri
ln -s /usr/bin/rdoc1.8 /usr/local/bin/rdoc
ln -s /usr/bin/irb1.8 /usr/local/bin/irb

apt-get install mysql-server libmysql-ruby1.8 build-essential libopenssl-ruby1.8 subversion gparted unrar gnochm sqlite3 libsqlite3-dev libmagick9-dev -y --force-yes

02_install_rubygems

wget http://rubyforge.org/frs/download.php/29548/rubygems-1.0.1.tgz -c

tar -xzvf rubygems-1.0.1.tgz

cd rubygems-1.0.1

ruby setup.rb

cd ..

ln -s /usr/bin/gem1.8 /usr/local/bin/gem

03_install_all_gems

#!/usr/local/bin/ruby

if `whoami` == "rootn"
  %w(mongrel RedCloth sqlite3-ruby ZenTest rails capistrano termios mocha rmagick postgres-pr).each do |gem_name|
    puts "nnInstalling gem: #{gem_name}..."
    `gem install #{gem_name}`
  end
else
  puts 'Login as ROOT to install all gems'
end

Infelizmente não consegui levar para a Reject Conf SP`07 um gravador de voz que tinha em mente para gravar o podcast.

Convidei o Carlos Eduardo Brando do blog Nome do Jogo e dono do site carreiraTI para o próximo podcast.

Vamos conversar sobre seus projetos, saber como ele começou com Ruby/Rails e assuntos referentes ao mercado de trabalho hoje.

Deixe sua pergunta até o dia 04/12, ela é muito bem vinda.

Imagine que você tenha um padrão para seus forms, como o gerado pelo scaffold_resources:

<% form_for(:podcast, :url => podcast_path(@podcast), :html => { :method => :put }) do |f| %>
 
  <p>
    <b>Title</b><br />
    <%= f.text_field :title %>
  </p>
 
  <p>
    <b>Created by</b><br />
    <%= f.text_field :created_by %>
  </p>
 
  <p>
    <%= submit_tag "Update" %>
  </p>

Você deve criar uma nova classe que extende de ActionView::Helpers::FormBuilder, sobrescrevendo os campos que você quer, segue logo abaixo uma implementação para todos os campos, exceto o hidden_field:

class DefaultFormBuilder < ActionView::Helpers::FormBuilder
  (field_helpers - %w(hidden_field)).each do |selector|
    src = <<-END_SRC
      def #{selector}(field, options = {})
        @template.content_tag("p" ,
        @template.content_tag("b" , field.to_s.humanize) + "<br />" + super)
      end
    END_SRC
    class_eval src, __FILE__, __LINE__
  end
end

A aplicação é muito simples, veja:

<% form_for(:podcast, :url => podcast_path(@podcast), :html => { :method => :put },
                   :builder => DefaultFormBuilder) do |f| %>
 
    <%= f.text_field :title %>
    <%= f.text_field :created_by %>
 
  <p>
    <%= submit_tag "Update" %>
  </p>

O código fica mais limpo e padronizado.

Mas agora eu quero mudar o título que aparece entre a tag bold, posso então inventar uma nova propriedade para o text_field:

<% form_for(:podcast, :url => podcast_path(@podcast), :html => { :method => :put },
                   :builder => DefaultFormBuilder) do |f| %>
 
    <%= f.text_field :title,     :label => "Título" %>
    <%= f.text_field :created_by, :label => "Criado por" %>
 
  <p>
    <%= submit_tag "Update" %>
  </p>

A modificação é simples:

class DefaultFormBuilder < ActionView::Helpers::FormBuilder
  (field_helpers - %w(hidden_field)).each do |selector|
    src = <<-END_SRC
      def #{selector}(field, options = {})
        @template.content_tag("p" ,
        @template.content_tag("b" ,(options[:label] || field.to_s.humanize)) + "<br />" + super)
      end
    END_SRC
    class_eval src, __FILE__, __LINE__
  end
end

Pensamento interior: “Como é bom apagar código. ;)”

Nas minhas aplicações Rails eu costumo utilizar o plugin “Restful Authentication” que disponibiliza um código inicial para criar usuários e o esqueleto de autenticação. (Veja como utilizar)

O ponto principal na escolha deste plugin é a alta cobertura de testes de unidade e funcionais, assim posso inserir novas funcionalidades com segurança e mantendo a cobertura de testes.

Os testes gerados pelo plugin utilizam o helper assert_difference e o assert_no_difference presente somente no “edge rails”. Felizmente o plugin sofreu algumas alterações e já possui no seu helper de testes esses dois métodos. Então se você utilizou o plugin antes dessa modificação, ou já quer usar este helper antes do Rails 2.0 ser lançado, basta adicionar o seguinte código no test_helper:

  def assert_difference(expressions, difference = 1, message = nil, &block)
    expression_evaluations = [expressions].flatten.collect{|expression| lambda { eval(expression, block.binding) } } 
 
    original_values = expression_evaluations.inject([]) { |memo, expression| memo << expression.call }
    yield
    expression_evaluations.each_with_index do |expression, i|
      assert_equal original_values[i] + difference, expression.call, message
    end
  end
 
  def assert_no_difference(expressions, message = nil, &block)
    assert_difference expressions, 0, message, &block
  end

Sua utilização é simples, se antes você tinha esse código:

  def test_create_player
    old_count = Player.count
    post :create, :player => {:name => "Eduardo", :game => "Starcraft 2"}
    assert_response :redirect    
    assert_equal old_count + 1, Player.count
  end

Você agora pode utilizar este que é muito mais bonito:

  def test_create_player
    assert_difference 'Player.count' do
      post :create, :player => {:name => "Eduardo", :game => "Starcraft 2"}
      assert_response :redirect
    end
  end

O Artur publicou um artigo com mais alguns helpers que ele utiliza.

Fica ai a dica.

Aqui vai uma dica rápida para refatorar seu código. Nesta situação você precisa de um contador para ser utilizado ao iterar os elementos de um array.

Você tem este código:

contador = 1
["I", "love", "Ruby", "and", "Rails"].each do |item|
    puts "Item #{contador}: #{item}"
    contador += 1
end

Produz:
Item 1: I
Item 2: love
Item 3: Ruby
Item 4: and
Item 5: Rails

Lembrando que a refatoração não deve alterar o comportamento do seu código, ou seja, ele deve fazer a mesma coisa depois de aplicar uma refatoração.

A maneira mais “Ruby” de se fazer isso é:

["I", "love", "Ruby", "and", "Rails"].each_with_index do |item, contador|
    puts "Item #{contador.next}: #{item}"
end

Produz:
Item 1: I
Item 2: love
Item 3: Ruby
Item 4: and
Item 5: Rails

Estava utilizando a maneira feia até este artigo. :)