Tudo que quero saber!

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.

Acabou a RejectConf SP’07 e sobram elogios para todos participantes e organizadores, o ambiente estava muito colaborativos e com um ar underground como é o estilo Ruby.

Corri bastante com a minha apresentação mas espero ter passado a importância de manter um código saudável e de conhecer a estrutura do Rails para se manter DRY.

Coloquei explicações no meu keynote, você pode baixar e deixar seu feedback.

Pena que não consegui entrar em contato com todas as pessoas/blogueiros. Foi bom conhecer Carlos Brando, Arthur Geek, Danilo Sato, George Guimarães, Akita, o time da Improve It que eu só conhecia on-line e o pessoal que esqueci o nome(deixem um comentário com o blog aqui para mim não esquecer).

Fiquei muito surpreso com a apresentação do Fabio Kung sobre o Jruby e como ele pode ser usado com Java, realmente está muito fácil.

Impressionante saber através do Carlos Villela como é o ambiente da thoughtworks e sua estrutura enorme em cima do Ruby.

Todas palestras foram ótimas e valeu a pena ir e voltar no mesmo dia para Sampa.

Que venha a RailsConf Brasil’ 08, o que acham?

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. ;)”

Fico feliz em ver que a comunidade Rails do Brasil está cada vez mais engajada em promover encontros interessantes para que outros desenvolvedores possam conhecer Ruby e Rails.

Agora o Carlos Eduardo da e-Genial está promovendo um encontro beneficente através do treina tom sobre Rails, para ajudar a instituição Cotolengo MS que cuida de portadores de necessidades especiais, será cobrado uma pequena taxa no valor de R$ 25,00.

Em breve estará no ar um site sobre o evento, mas você você pode encontrar maiores informações no blog da e-genial.

O evento contará com os seguintes palestrantes:

• Carl Younblood - Surgeworks LLC (EUA)
• Demetrius Nunes
• Eduardo Fiorezi
• Fabio Akita
• Rodrigo Urubatan
• Ronaldo Ferraz
• Shairon Toledo
• Vinicius Manhães Teles

O encontro será no dia 15 de Dezembro a partir das 9 horas.

Mãos a obra.

O Akita publicou a lista de palestras confirmadas até o momento. O Brasil possui cerca de 250 railers cadastrados no working with rails e já estava na hora de acontecer um evento voltado para os desenvolvedores, onde a própria comunidade pudesse mostrar suas experiências.

Pretendo falar sobre refactoring, sua importância e como ele é fundamental em qualquer projeto de desenvolvimento de software, inclusive em projetos ruby/ruby on rails. Já estou com algumas idéias interessantes para não deixar ninguém dormir na cadeira.

Espero poder conversar pessoalmente com todos blogueiros que assino e aqueles que entrevistei nos meus podcasts.

Deixando a dica aqui de vários outros encontros que vão acontecer no Brasil: Rio on Rails, RS, MG, SC, PE, online pelo treinatom e Brasilia.

Hoje no brasil, já existem alguns cases importantes unindo eXtreme Programming e Ruby on Rails. O mais divulgado é o do grupo Santa Isabel em parceria com a Improve It.

Cerca de 4 meses atrás, fui convidado por um amigo para entrar na empresa Inovare, com o objetivo de trabalhar com muita qualidade e dentro do contexto do desenvolvimento ágil. Comecei trazendo toda cultura ágil e o desenvolvimento web com Ruby on Rails.

Depois de ajeitar o novo espaço da empresa, os computadores e a sintonia com as práticas de XP, precisávamos ainda do nosso quadro branco, sem ele nosso planejamento ficava um pouco perdido. O Felipe a troca do quadro branco por um vidro na parede branca, o resultado foi excelente.

Nossa parede branca :)

Planejamento do projeto Gabarito.

Nossa iteração atual do projeto Gabarito.

Foram realizadas duas iterações até este momento, a primeira de 8 dias com a velocidade de 2 bolinhas por dia, na segunda 2 bolinhas e meia por dia. O tamanho da primeira iteração ficou maior porque uma parte da equipe estava começando com Rails e precisava entrar no clima de XP.

Aqui está um detalhamento de um cartão em desenvolvimento na iteração corrente. Dividimos em 12 passos uma funcionalidade.

Planejamento do nosso CMS(www.inovare.net).

Aqui estão as 4 palavras que regem todos nossos projetos e o meu desenho do mascote da empresa. :)

Aqui chegamos a um padrão das cores que utilizamos nos cartões, repare que tem até o cartão de firúla.

Aqui está uma dupla trabalhando, eu de amarelo e o Danilo. Trabalhem com 2 monitores, facilita muito.

Estamos trabalhando atualmente no projeto gabarito. Que deve durar mais 4 ou 5 iterações de uma semana.

Em breve vamos publicar algumas facilidades que surgiram com nossos projetos em Rails.

Estou começando a me aventurar na versão 2.0 do Rails, com a vontade de já ficar por dentro do que irá surgir nos próximos meses. Minha coragem está nos meus testes.

Foi adicionado os comandos:

rake notes                     # Enumerate all annotations
rake notes:fixme               # Enumerate all FIXME annotations
rake notes:optimize            # Enumerate all OPTIMIZE annotations
rake notes:todo                # Enumerate all TODO annotations

class Game < ActiveRecord::Base
  belongs_to :event
  has_many :results
 
  #TODO Fazer alguma coisa aqui
  #FIXME Um probleminha bla bla ;)
 
end

Quando você colocar algum comentário com essas 3 opções(FIXME, OPTIMIZE ou TODO), executando rake notes você receberá uma saída assim no seu console:

eduardo-ubuntu:~/AmbienteRails/Projetos/basketball$ rake notes
(in /home/eduardo/AmbienteRails/Projetos/basketball)
app/models/game.rb:
  * [  5] [TODO] Fazer alguma coisa aqui
  * [  6] [FIXME] Um probleminha bla bla ;)
 
app/models/player.rb:
  * [  5] [OPTIMIZE] Associação feia pra caramba..

O valor entre colchetes é o numero da linha que está a anotação.

Mais dicas em breve. ;)

Primeiramente acho que todo gerente de ti ou a pessoa que paga seu salário “DEVERIA” participar de uma competição como essa, para saber das dificuldades de ter tempo escasso e valorizar o salário dos seus desenvolvedores.

No rails rumble nós temos que fazer o papel de desenvolvedor, analista, admin linux, psicólogo, designer e ainda ter vida além das 48h de desenvolvimento.

A experiência é impagável. Assumir todas essas resposabilidades foi um aprendizado muito interessante. A colaboração entre os outros competidores brasucas atravéz do twitter(eu também tenho :) ) foi muito boa. Enfatizo os problemas descritos pelo urubatan e pelo nando.

Esta é minha aplicação rails: http://refactoringgame.railsrumble.com/

A idéia é compartilhar códigos e soluções de problemas com ruby, não preciso nem dizer que falta muita coisa da idéia que sonhei antes da competição. Já apareceram alguns doidos ajudando a limpar os códigos. :)

Procurei manter a cobertura de testes alta para não ter problemas futuros e continuar a desenvolver essa aplicação.

Durante o desenvolvimento encontrei alguns problemas e recebi dicas do Arthur, Nando Vieira e do George Guimarães. Fique sabendo também que na equipe do George tinha também o Hugo Barauna e o Jose Valim. Tinha mais algum brasileiro participando?

Vocês tem mais alguma dúvida? Quem sabe um podcast com os participantes? O que acham? Dependo do feedback de vocês.

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.