Pacote de Expansão No. 1.

O Colete do Tigre (com uma Básica

Introdução ao Irb)
sidebar!
Sobre as versões do Ruby
Se você visitou qualquer site oferecendo download do Ruby, você provavelmente viu
um número de diferentes versões do Ruby disponíveis. Obviamente, quanto maior o
número da versão, mais recente a versão do Ruby. Mas isto não é exatamente verdade.
Números de versões possuem significado na Rubylândia e eu gostaria que você fizesse
uma escolha educada.

1.8.7 é a última versão estável do Ruby. Versões estáveis oferecem as últimas

características que foram amplamente testadas e são recomendadas para o uso geral.
Quando novas versões estáveis saírem, você seguramente poderá atualizar para estas
novas versões.

1.9.1 é o última lançamento de desenvolvimento do Ruby. A liberação de

desenvolvimento inclui mudanças experimentais para o Ruby e problemas não
corrigidos. Esta liberação é para qualquer pessoa que quiser dar uma espiada no futuro
do Ruby com o risco de encontrar alguns erros. A versão 1.9.1 (Release Candidate 1) é
a primeira versão de produção do Ruby 1.9.

Agora, você poderá notar que o número da versão inclui três números individuais, que
são: a versão maior, a versão menor, e a versão pequenina. A versão maior conta
cada regravação completa do Ruby. A versão menor é modificada baseada em
mudanças de varredura para o Ruby. A versão pequenina é incrementada a cada poucos
meses como mudanças menores e correções de erros são inseridas.

Todas as edições do Ruby até então tem a versão maior igual a 1. Quando vier Ruby 2,
você verá esta versão aumentar em um.

A versão menor indica se uma versão é estável ou não. Se a versão menor é um

número par, então aquela versão do Ruby é estável. Se é ímpar, então aquele Ruby
é uma versão de desenvolvimento. Depois de quase um ano, quando a versão de
desenvolvimento está pronta para o mundo, ambos os números são incrementados e a
versão pequenina volta a ser zero. Porém, o Ruby 1.9 alterou essa regra, visto que é uma
versão estável e tem em sua versão menor um número ímpar.

Oh, e se eu pudesse dar a você um gostinho do quão suave o Ruby se move! Eu não
posso contar com que freqüência uma idéia fresca surge na lista de e-mail do Ruby-
Core, onde os Imperadores do Ruby conversam, e aquela mesma idéia é trabalhada no
Ruby em poucos dias. Esta é uma máquina adorável eu digo.

sidebar!
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 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.

sidebar!
Soluços do Windows
Certo, aqui está o que você precisa para fazer funcionar no Windows o auto-completar
com o TAB. Baixe este arquivo. Um zip com dois arquivos. Copie para dentro do
instalação do seu Ruby. Coloque readline.dll na pasta bin. O arquivo readline.so vai na
pasta lib/ruby/1.8/i386-mswin32

Então, digite na sua linha de comando: irb --readline -r irb/completion.

E para os Europeus, você precisará disto. Salve como .inputrc e coloque-o no seu
diretório raiz. (Seu diretório pessoal que contém suas pastas Desktop e Meus
Documentos.)

sidebar!
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.
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}r
i%))
(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.