Pacote de Expansão No. 1.

O Colete do Tigre (com uma Básica Introdução ao Irb)

Tigre tem colete.  Tigre gosta de robô fêmea.  Terra colidindo com sol...

Vamos instalar a versão mais recente do Ruby no seu computador, assim você pode acompanhar todos os exemplos no (Comovente) Guia e realmente fazer as coisas corretamente agora! (Sim, coisas!)

  • Se você está usando Microsoft Windows, comece fazendo o download do Ruby Installer for Windows. Executar este instalador “one-click” irá instalar Ruby para você, bem como instalar um pacote de softwares úteis, como um pequeno editor de texto e algumas bibliotecas adicionais.
  • Se você está no Mac OS X da Apple, então Ruby já poderá estar instalado. As Versões desde 10.2 até 10.5 do OS X já vieram com Ruby. Ainda assim, quero encorajá-lo a atualizar o Ruby, para que todos os exemplos deste livro funcionem para você. Faça o download da versão estável da imagem de disco. Você vai precisar do OS X 10.3 (Panther) e do XCode Tools para utilizar esta imagem.
  • No FreeBSD, Ruby está disponivel no sistema ports. De fato, se você usa a ferramenta essencial portupgrade, então Ruby já está instalado. Akinori Musha, um dos desenvolvedores talentosos do núcleo do Ruby, escreveu o portupgrade, o que significa que você pode utilizar o seu conhecimento em Ruby para hackear o seu pkgtools.conf imediatamente.
    _*

    cd /usr/ports/lang/ruby18
    sudo make install
  • No RedHat ou Mandrake Linux, você pode encontrar as Ruby RPMs. Eu acredito que o Ruby também está disponível através do Ximian Red Carpet.
  • No Debian ou Ubuntu, use apt-get install ruby.
  • No Gentoo, emerge ruby.
  • No Archlinux, pacman -S ruby
  • Outras plataformas Linux e UNIX, até mesmo no OS X (se as imagens de disco não funcionarem para você): Faça o download do último código fonte. Por exemplo, Ruby 1.8.7. Para descompactar e compilar:
    _*

    tar -vxjpf ruby-1.8.7-p22.tar.bz2
    cd ruby-1.8.7-p22
    ./configure
    make
    make install

    _* (Novamente, os comandos acima são para instalar Ruby a partir do código fonte. Você pode precisar usar su ou sudo para dar permissão para rodar o make install.)

Para testar se o Ruby está instalado, abra um terminal e execute: ruby -v. Se o Ruby estiver instalado corretamente, você verá um pouco das informações sobre a versão.

 ruby 1.8.7 (2008-06-09 patchlevel 17) [i686-linux]     
  • Para abrir um terminal no Microsoft Windows, Clique no menu Iniciar e selecione Executar.... Digite: cmd. Pressione OK. Uma janela de prompt de comando irá aparecer.
  • Para abrir um terminal no Mac OS X, vá para Aplicações > Utilidades. Execute o programa Terminal.

OK, mantenha o terminal aberto caso nós precisarmos salvar a Terra de uma colisão com o Sol.

O tigre salva a terra com a arma de gelo.  A Garota robô gira em torno da loja de ternos...

O Ruby vem com uma ferramenta muito, muito, extremamente muito útil chamada Irb. Ruby Interativo. No seu terminal, digite: irb.

 irb(main):001:0>

Você deve ver o console acima. Essa linha de comando Irb permitirá que você entre com código Ruby e, pressionando Enter, o código irá executar.

Então, no console Irb, faça um: 3000 + 500.

 irb(main):001:0> 3000 + 500
 => 3500
 irb(main):002:0>      

Esse exemplo 3000 + 500 é código legítimo. Nós apenas não estamos atribuindo a resposta a uma variável. O que está correto no Irb, porque o Irb devolveu a resposta do código que você executou.

O Irb é uma ótima calculadora.

 irb(main):002:0> ( ( 220.00 + 34.15 ) * 1.08 ) / 12
 => 22.8735
 irb(main):003:0> "1011010".to_i( 2 )
 => 90
 irb(main):004:0> Time.now - Time.local( 2003, "Jul", 31, 8, 10, 0 )
 => 31119052.510118

O primeiro exemplo demonstra um pouco de matemática e é lido como: 220.00 mais 34.15 vezes 1.08 dividido por 12. O segundo exemplo pega um código binário e o converte em um número decimal. O terceiro exemplo calcula o número de segundos entre now (agora) e 31 de Julho de 2003 às 8:10 da manhã. As respostas para todos esses cálculos são impressas de volta para nós pelo Irb com uma pequena seta ASCII apontando.

Lendo o Console (Terminal)

Eu sei que o console (também conhecido como terminal ou prompt) com certeza parece desconcertante. Bem, vamos logo dissecá-lo. É muito simples. O console tem três partes, cada uma separada por dois pontos.

A primeira seção, onde está escrito irb(main), mostra o nome do programa que estamos rodando. A segunda seção mostra o número da linha, um contador de quantas linhas de Ruby nós digitamos. A terceira seção é um nível de profundidade. Toda vez que você abrir uma expressão que precisa ser fechada, o nível de profundidade vai aumentar uma unidade. E toda vez que o Irb detectar que seu código não está terminado, o fim do console vai virar um asterisco.

 irb(main):001:0> campainha = :apertada
 => :apertada
 irb(main):002:0> arma_de_gelo =
 irb(main):003:0*   if campainha == :apertada
 irb(main):004:1>     :ligar
 irb(main):005:1>   else
 irb(main):006:1*     :desligar
 irb(main):007:1>   end
 => :ligar

Veja como o nível de profundidade aumentou para 1 quando eu abri o if. E como o asterisco indica a continuação da linha.

Ajustando o Console

Você não tem que gostar da aparência do console, entretanto. Não estou forçando você a fazer nada e, se você quer hackeá-lo, estou ao seu lado.

O Irb tem mais alguns consoles que podem agradar seus sentidos. Tente irb --prompt simple. Desta vez o Irb vai lhe proporcionar um conjunto bem básico de setas, permitindo a você digitar seu código sem todo o relatório de status.

 >> %w(braço do meu melhor amigo)
 => ["braço", "do", "meu", "melhor", "amigo"]
 >> 

Ruby vem com alguns prompts. O prompt simple visto acima. O prompt xmp que não tem nenhum prompt e identa a seta de resposta. (Deve ficar bom para impressão.) Além disso, o prompt null, que elimina todos os prompts. Defina o prompt fornecendo o nome dele na opção --prompt. (Portanto, irb --prompt null.)

Você também pode fazer seu próprio prompt. O Irb é completamente customizável de dentro dele mesmo. O objeto conf contém todas as configurações do Irb. Algumas destas configurações são para o controle do prompt.

 >> conf.methods.grep /prompt/
 => ["prompting?", "prompt_s", "prompt_s=", "prompt_c", "prompt_c=", 
     "prompt_i", "prompt_mode", "prompt_i=", "prompt_mode="]

Vamos configurar nosso prompt para mostrar o número da linha com um pouquinho de decoração.

 >> conf.prompt_i = "%3n :> "           # o prompt normal
 >> conf.prompt_s = "%3n .%l "          # o prompt de continuação de string
 >> conf.prompt_c = "%3n .^ "           # o prompt de continuação de código
 >> conf.return_format = "    => %s\n"  # a seta de resposta

Acima estão as quatro partes de um prompt Irb. O prompt de continuação de string é mostrado quando uma string ainda está aberta quando você aperta Enter. O %3n descreve que o Irb deve reservar três caracteres para o número da linha. O %l guarda um lugar para mostrar o tipo da string que será continuada. (Se você está continuando uma string de aspas duplas, ele mostra aspas duplas. Se você está continuando uma expressão regular, ele mostra uma barra.)

O resto são apenas símbolos para decorar o prompt. Então, em caso de continuação de uma linha de código, eu mostro um acento circunflexo que aponta para a linha onde aquela linha de código começou.

Você pode ler mais sobre a customização do Irb e sobre salvar sua configuração num arquivo no completo guia para o Irb, disponível no Programming Ruby, grátis-para-seus-olhos-de-Internet-perambulantes.

Completar com tab

Uma característica do Irb raramente mencionada é a vantagem do recurso de auto-completar com a tecla TAB. Este tópico tem um pouco de tabu no momento, uma vez que trabalhar com ele no Windows é um tanto horroroso. (Não, não tenha medo. Agora, mais do que nunca, olhe à sua direita.)
Se você estiver no Linux ou no FreeBSD, o recurso de auto-completar com a tecla TAB deverá funcionar imediatamente. E se estiver usando OS X, você deverá ter certeza que está atualizado para a última versão 1.8 e quando executar o Irb, use:


irb —readline -r irb/completion

Basicamente, quando você teclar TAB, o Irb tentará adivinhar o que você está tentando digitar. Tente digitar: [].col e tecle TAB. o Irb finalizará isto. [].collect e isto levará seu cursor até o final então você pode adicionar mais conteúdo.

Se existem várias combinações, apenas teclar TAB não adiantará. Mas pressione duas vezes e o Ruby lhe dará uma lista completa de possíveis combinações.

Isto é ótimo se você quer apenas ver todos os métodos para um certo objeto. Digite em qualquer número, um ponto, e use TAB.

  >> 42.
                42.floor                   42.next                    42.step
  42.__id__     42.freeze                  42.nil?                    42.succ
  42.__send__   42.frozen?                 42.nonzero?                42.taint
  42.abs        42.hash                    42.object_id               42.tainted?
  42.between?   42.id                      42.prec                    42.times
  42.ceil       42.id2name                 42.prec_f                  42.to_f
  42.chr        42.inspect                 42.prec_i                  42.to_i
  42.class      42.instance_eval           42.private_methods         42.to_int
  42.clone      42.instance_of?            42.protected_methods       42.to_s
  42.coerce     42.instance_variable_get   42.public_methods          42.to_sym
  42.display    42.instance_variable_set   42.quo                     42.truncate
  42.div        42.instance_variables      42.remainder               42.type
  42.divmod     42.integer?                42.respond_to?             42.untaint
  42.downto     42.is_a?                   42.round                   42.upto
  42.dup        42.kind_of?                42.send                    42.zero?
  42.eql?       42.method                  42.singleton_method_added  
  42.equal?     42.methods                 42.singleton_methods       
  42.extend     42.modulo                  42.size  

Agora, tentando teclar Kernel:: e depois TAB. Todos os métodos do core. Nunca esqueça disto e use o tempo todo.

Todos fugiram com exceção da robô e a arma de gelo continuou e continuou...

Ok, uma última coisa então vou parar de incomodar com toda esta ótima tecnologia. Mas terei que falar isto alto, então tapem os ouvidos! Estou do outro lado do mundo, galera, mas o volume vem do céu - um negrito, vermelho e crescente -

((%{color:#A53}ri%))

(O próprio 102 do Ruby ou 555-1212 ou Sim, Operadora, Coloque Belgrado na Linha — Eu Estarei Bem Aqui — Apenas Batendo na Tecla do “Jogo da Velha” Até Que Alguém Atenda…

E o Ri atende. “Aqui é o Ri. Classe e dois pontos, por favor”

Você entra correndo, “Isto é a instância de um método, Operador. Enumerable#zip.”

 ri Enumerable#zip

Sem demora, corrija na sua tela (tão rápido que até o gato sentado na quina estica o pescoço, boceja e alcança a sua caneca real A coisa mais barulhenta desde Michael Dorn):

 --------------------------------------------------------- Enumerable#zip
      enum.zip(arg, ...)                   => array
      enum.zip(arg, ...) {|arr| block }    => nil
 ------------------------------------------------------------------------
      Converte qualquer argumento para arrays, então une elementos de _enum_
      com elementos correspondentes de cada argumento. Isto gera uma
      seqüência de +enum#size+ _n_-element arrays, onde _n_ é um a mais
      que a conta de argumentos. Se o tamanho de algum argumento é menor
      que +enum#size+, valores de +nil+ são providos. Se é dado um
      bloco, este é chamado para cada saída do array, caso contrário um
      array de arrays é retornado.

         a = [ 4, 5, 6 ]
         b = [ 7, 8, 9 ]

         (1..3).zip(a, b)      #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
         "cat\ndog".zip([1])   #=> [["cat\n", 1], ["dog", nil]]
         (1..3).zip            #=> [[1], [2], [3]]

Isto é um dicionário íntegro de Ruby em inglês (aqui aparece traduzido apenas como exemplo) — O poder de apenas perguntar está na ponta de seus dedos — não diga que nunca ouviu sobre este nenhum-dinheiro-supre-uma-vida-inteira-de explicações-apropriadas!_

Para ter uma explicação de qualquer classe em inglês, junto com diretório completo para todos seus métodos, todos com uma voz suave que serve para acalmar qualquer um de vocês cosmonautas em pânico aí lutando contra a atração de um raio trator de tolerância zero, apenas use no console: ri Class.

Mas para ajudar nos métodos da classe, você tira da manga: ri Class::method.

Apesar de métodos de instância usarem o cerquilha (jogo-da-velha) ao invés do ponto. (Uma vez que ponto pode significar classe ou métodos de instância.) Digo: ri Class#method.

A completa distribuição das classes, uma lista completa desde o mais alto topo até o centro da Terra, pode ser alcançada com ri -c.

e além do texto, você pode fazer HTML: ri -Tf html String#gsub > gsub.html.

Ou mostrar ANSI colorido: ri -Tf ansi String#gsub. E este é ultimo e o melhor.

Dentro do Painel de controle do Ri

Atrás do Ri canta um coro de vozes humanas, primeiramente Dave Thomas, um dos autores de Programming Ruby, e absolutamente o pai adotivo americano do Ruby. Muitos destes discursos elaborados do Ri são diretamente das referências de Programming Ruby. Não se esqueça de agradecer ao Dave periodicamente.

O Ri extrai seu exuberante conjunto de informações do mesmo código que o Ruby é construído. Em cada um dos arquivos de código contidos no armário de arquivos da chefia Ruby, comentários detalhados descrevem tudo claramente.

Na classe date de Ruby, aqui temos métodos bem comentados:

 # Obtenha o tempo desta data como [horas, minutos, segundos,
 # fração de segundos]       
 def time() self.class.day_fraction_to_time(day_fraction) end

 # Obtenha a hora desta data.       
 def hour() time[0] end

 # Obtenha o minuto desta data.
 def min() time[1] end

Os comentários surgem no Ri. Digitamos: ri Date#time.

 -------------------------------------------------------------- Date#time
      time()
 ------------------------------------------------------------------------
      Get the time of this date as [hours, minutes, seconds,
      fraction_of_a_second]

O Ri advinha muito de como um método funciona, embora espera-se que os codificadores escrevam uma breve descrição nos comentários, pouco antes da definição de um método ou classe. Eu sugeriria que sempre que for escrever um método, adicione uma breve descrição nos comentários antes daquele método. Em tempo, você pode gerar uma documentação Ri para aquele método.

Você também pode usar alguns caracteres especiais para aumentar sua descrição. Por exemplo, se você identar um parágrafo e usar um asterisco * ou um hífen - pouco antes das letras da primeira frase, o parágrafo será reconhecido como um item de lista. Então, se a sua descrição precisa ser convertida para HTML, você verá o item de lista aparecer como uma lista de HTML não-ordenada.

 # Obtenha o tempo desta data como um array de:      
 # * horas
 # * minutos
 # * segundos
 # * fração de segundos
 def time() self.class.day_fraction_to_time(day_fraction) end

Outra regras semelhantes: Listas que começam com dígitos seguidos de períodos são reconhecidas como listas numéricas. Palavras enfatizadas são cercadas por travessão (underscore), palavras em negrito por asteriscos, palavras em código por sinais de adição. Exemplos são simples blocos de texto identados por alguns espaços. Todas estas regras juntas são chamadas RDoc.

Aqui está um pedaço do RDoc do método initialize em um dos meus projetos chamado RedCloth. Observe o exemplo identado bem como a classe Ruby e nomes de métodos alinhados com sinais de soma.

 #
 # Retorna um novo objeto RedCloth, baseado em +String+ e
 # cumprindo todas as +restrições+ incluídas.       
 #
 #   r = RedCloth.new( "h1. A <b>bold</b> man", [:filter_html] )
 #   r.to_html
 #     #=>"<h1>A &lt;b&gt;bold&lt;/b&gt; man</h1>"
 #
 def initialize( string, restrictions = [] )
     @lite = false
     restrictions.each { |r| method( "#{ r }=" ).call( true ) }
     super( string )
 end

Para a série completa de regras RDoc veja a seção Markup (Marcação) do README.

Impulsionando seu próprio Ri

O Ri porém não lê automaticamente seus arquivos para você. Você tem que guiá-lo, mostrar o caminho. Mude para o diretório do código que você gostaria de examinar. Então, use a ferramenta RDoc para executar.

 cd ~/cvs/seu-codigo
 rdoc --ri-site

Agora, tente usar ri SuaClasse para assegurar que todas as suas descrições estão aparecendo apropriadamente. Se você quer fazer documentação HTML, tente isto:

 cd ~/cvs/seu-codigo
 rdoc

O diretório ~/cvs/seu-codigo deverá agora também possuir um diretório doc recente contendo documentação HTML para todas as suas classes. Veja index.html para as notícias agradáveis.

Pois então. Está tudo em suas mãos agora. Bem vindo ao Ruby.

O Tigre Encontra Uma Nova Casa e Eventualmente Aprende a Seguir Em Frente.

Virar a página.