{:elf => "Blog"}

Olá pessoal vamos para o terceiro post da série de Ruby, este post irá ser um pouco mais pequeno porque
irá tratar apenas de um operador, esse operador é o Splat.

O Operador Splat é usado quando queremos em uma atribução fazer com que vários valores de um array se tornem
rvalues, como por exemplo:

a, b, c, d = 10, 11, *[12,13]

Como da para se notar o que mudou foi o último rvalue sendo precedido por um *.

No Ruby 1.8 Arrays e Rangs podem ser splatted, ele também fornece um método to_ary que retorna um array de valores.

Também podemos fazer ao contrário, fazer um ivalue ter um *, quando isso acontece os rvlues extras são postos em um array e são atribuidos a tal valor.

x, *y = 1, 2, 3

Aqui x = 1 e y = [2,3]

OBS: No Ruby 1.9, você pode ter quantos splats quizer, para ver mais sobre Splat no 1.9 veja esse link:
http://ruby.about.com/od/newinruby191/qt/MultipleSplats.htm

Bom pessoal esse post foi rápito espero que deu para aprender algo com ele

Até o Mais.

No último post foi visto como o Ruby trabalha com os 5 tipos de varíaveis, falamos bastante sobre atribuições também, então neste post iremos falar um pouco mais sobre isso.

Atribuições

Uma atribuição é um expressão que pode especificar um ou mais de um valor para uma dada varíavel ou mais corretamente
de um Ivalue.
IValue é um termo para indicar o que aparece antes de um operador de atribuição, por exemplo:

x = 10

Na expressão acima x é um ivalue e um rvalue que é 10.
No Ruby existem três tipos de expressões de atribuição, a mais simples vista acima e outras duas que vamos ver agora.

As atribuições abreviadas que são expressões que além de atualizar um valor ainda aplicam alguma matemática sobre o ivalue
certamente você já fez isso:

x *= 10

Também tempos as atribuições paralelas que são aquelas em que um rvalue é atribuido a n ivalues, por exemplo:

x, y, z = 10

Também é possivel tem n ivalues e n rvalues, assim:

x, y, z = 2, 4, 6

Aqui x recebe 2, t recebe 4 e z recebe 6.
O que um ivalue recebe como conteúdo é o valor ou array de valores que é à ela atribuido. Um operador de atribuição é righ-assiciative ou seja, a atribuição é avalidada da direita para a esquerda, com isso podemos fazer isso:

a = b = 4

Aqui b recebe 4 e a também recebe 4.

Efeitos colaterias – Idempotent.

Como vimos uma atribuição muda o estado de uma varíavel isso muda o estado de um programa por exemplo,
existem várias expressões que não tem efeitos colaterais algum, pois toda a vez que são avalidas irão retornar o mesmo valor ,por exemplo:

Dado um método para calcular a raiz quadrada de um número inteiro e positivo:

	def raiz(x)
	   return x * x
	end

Esse método não tem efeitos colaterais, esse tipo de expressão é chamado de idempotent, você pode
avaliar o método acima n vezes e ele sempre irá retornar o mesmo valor, já a seguinte expressão irá mudar a cada vez que for executada:

x += 1

Você pode ler mais sobre isso em: http://en.wikipedia.org/wiki/Idempotence
Bom pessoal, esse foi o segundo post da série Ruby. Até mais e Obrigado.

Irá sair no dia 12/09/2009 o Rails for Kids 2009,  se trata de uma série de palestras sobre assuntos relacionados com o mundo rails, as palestras irão ser mistradas por grandes nomes da comunidade Rails nacional e internacional, para participar do evento você deve fazer uma doação no  valor simbólico de R$ 30,00 , toda grana será destinada a Cotolengo de Mato Grosso do Sul. Para saber mais sobre a Cotolengo clique aqui.

Acesse o site Rails for Kids e de uma olhada nas palestras e palestrantes e realize sua inscrição.

Para se escrever clique nesse link.

É isso ai pessoal agente se encontra por lá… OPS, eh online tinha me esquecido

Estou necessitado de escrever posts melhores, eu sei, mas enquanto isso, tava brincando aqui com TDD + Ruby, então resolvi fazer um código para gerar a sequencia de Fibonacci fazendo o uso de TDD.

Para quem ainda não sabe, o numero de fibonacci e uma sequencia de numero, que é gerada começando com 1 e em seguida somando os dois anteriores para se conhecer o próximo, na prática:

Começamos com 1, então o proximo numero será : 0 + 1 = 1, o seguinte será 1 + 1 = 2 … 2 +1 = 3 … e assim vai… essa sequencia é defenida como sendo recursiva, a formula é:

Bom, o problema ta entendido(eu acho) rs.

Como vamos fazer o uso de TDD, vamos começar escrevendo nossos testes

Precisamos ter um método chamdo por exemplo fibo, esse método deve receber como argumento um inteiro, inicialmente se passarmos 0(zero) devemos ter como retorno 0(zero), entõa vamos criar o esqueleto do teste:

require "test/unit"

require "fibonacci.rb"

class Test < Test::Unit::TestCase
   def test_case_name

   end
end

Acima está o esquelete de um teste básico, na primeira linha fizemos a inclusão do framework de teste, no segundo require chamamos a nossa classe fibonacci(que ainda nao existe), e logo em seguida temos o primeiro método para teste, vamos mudar o nome dele e acresentar o comportamento que nossa classe fibonacci deve ter quando receber zero.

require "test/unit"
require "fibonacci.rb"
class TestFibonacci < Test::Unit::TestCase
	def test_fiboZero
		assert_equal(0, Fibonacci.seqfibo(0))
	end
end

Todo teste deve iniciar com o palavra test, logo em seguida vem nosso teste propriamente dito, é justamente o que falamos acima, se receber Zero, retorne Zero, vamos rodar nosso teste para ver o que acontece:

LoadError: no such file to load  fibonacci.rb

Ops, certamente teriamos um erro ai mesmo, pois ainda nao criamos nossa classe fibonacci, vamos cria-la,(sem nehum codigo ainda) e rodar novamente:

Ops, denov, so temos um arquivo e mais nada então recebemos o seguinte:

Started
E
Finished in 0.002 seconds.

1) Error:
test_fiboZero(TestFibonacci):
NameError: uninitialized constant TestFibonacci::Fibonacci
C:\Documents and Settings\casa\Desktop\Nova pasta\fibonacciTest:5:in `test_fiboZero’

1 tests, 0 assertions, 0 failures, 1 errors

Vamos criar essa classe, acresente o seguinte em fibonacci.rb:

class Fibonacci
    def self.seqfibo(num)
       return 0 if num == 0
    end
end

Bom, isso provavelmente irá fazer nosso teste passar, rodando recebemos o seguinte:

Started
.
Finished in 0.002 seconds.

1 tests, 1 assertions, 0 failures, 0 errors

Legal, tudo passou, nosso primeiro caso esta feito, agora, podemos pensar em outro comportamento para nossa classe. . . .bom testamos com zero agora vamos tentar passar um(1) para o método e ver o que acontece, incluindo mais método para teste (poderia ser feito no mesmo método, mas vou separar aqui), nosso código de teste agora fica assim:

require "test/unit"
require "fibonacci.rb"
class TestFibonacci < Test::Unit::TestCase
    def test_fiboZero
       assert_equal(0, Fibonacci.seqfibo(0))
    end
    def test_fiboUm
       assert_equal(1, Fibonacci.seqfibo(1))
    end
end

a lógica dos teste aqui, nao mudou nada, vamos rodar para ver:

Started
F.
Finished in 0.033 seconds.

1) Failure:
test_fiboUm(TestFibonacci) [C:\Documents and Settings\casa\Desktop\Nova pasta\fibonacciTest:8]:
<1> expected but was
<nil>.

2 tests, 2 assertions, 1 failures, 0 errors

Bom, vimos ali que o teste esperava 1 mas retornou nil, vamos implementar essa lógica na nossa classe, agora temos isso:

class Fibonacci
    def self.seqfibo(num)
       return 0 if num == 0
      return 1 if num == 1
    end
end

Exatamente igua ao anterior, agora não seria nada bom ficar acresentando todos essas asserts ai para testar cada um dos numero que esperamos obter,  para isso em nosso teste vamos criar um array de arrays contendo vários cassos de testes algo do tipo:

testes = [[0,0][1,1][2,1] . . .]

e logo interar por esse array passando esses valores para nosso teste, logo iremos ter um unico método, nossa classe teste fica +  – assim agora:

require "test/unit"
require "fibonacci.rb"
class TestFibonacci < Test::Unit::TestCase
    def test_fiboZero
       teste = [[0,0],[1,1],[2,2],[4,5],[3,2]]
       teste.each do |t|
          assert_equal(t[1], Fibonacci.seqfibo(t[0]))            
       end
    end
end

Bom, creie um array de array com alguns cassos, agora so falta implementar na classe fibonacci um funcao recursiva para fazer o calculo, então agora tempo:

class Fibonacci
     def self.seqfibo(num)
        return num unless num > 2
       seqfibo(num-1) + seqfibo(num-2)
   end

 #um metodo pra executar

   def execute
       for i in 1..10
          puts seqfibo(i)
       end 
  end
end

Agora rodamos o código de teste e recebemos:

Started
.
Finished in 0.002 seconds.

1 tests, 5 assertions, 0 failures, 0 errors

Bom, aqui acabamos nossa implementação, obviamente da para melhorar e fazer muitos outros teste, e melhorar o teste, e tudo mais, se alguem achar erros, ou quizer falar algo, porfavor deixe um comentário.

Se você é um usuário Windows e usa o E-textEditor e estiver tentando usar o comando ctrl+r para rodar seus codigos e está recebendo a seguinte mensagem:

ruby: no such file to load — ubygems (LoadError)
faça o seguinte para concertar esse problema:

1 – Baixe a ultima versao do RubyGems do site

2 – Descompacte-o dentro da sua pasta de usuario do Cygwin, no meu caso em:  C:\cygwin\home\edipo

3 – Abra o terminal do Cygwin e execute os seguintes comando:

$  unset RUBYOPT
$ ruby setup.rb

Pronto isso deve resolver.

Olá, não sou um cara que sabe tudo sobre testes,( não sei quase nada , mas vejo a importância que eles tem no bom desenvolvimento, tendo isso em mente começei a estudar testes não escolhi um framework específico para fazer isso como o Rspec, ou algum outro, optei por escolher o framework que vem junto com o Rails que é o Test::Unit, então resolvi escrever aqui um pouco sobre isso e compartilhar, isso é algo simples, sendo que é o primeiro post de um série que eu acredito que será, então fazam bom proveito, e me desculpem os erros( deixem comentários).

1 – Começando: Criando um CRUD simples para os exemplo

Criei apenas um pequeno projeto rails como um CRUD normal para realizar algumas demos aqui, criei um modelo product, contendo o titulo do produto e a quantidade.

2 – Testes de Unidade.

Teste de Unidade são testes realizados nos models.

class ProductTest < Test::Unit::TestCase

ProductTeste é uma subclasse da classe  Test::Unit::TestCase que é onde fica o framework Test::Unit que esta pré-instalado com o rails.

require File.dirname(__FILE__) + '/../test_helper' 

class ProductTest < Test::Unit::TestCase 
  fixtures :products 

  # Replace this with your real tests. 
  def test_truth 
    assert true 
  end 
end 

aqui está o codigo que o rails gerou para nós, então: (veremos fixtures no proximo post)

fixtures :products 

Permite pré-pencher o banco de dados apenas com os dados de testes corretos e o método test_truth,
tudo que começa com test quer dizer que ele irá ser executado como teste pelo framework  a linha assert
true que é de fato o teste, mas o que ela simplesmente faz aqui é um teste se true é verdadeiro 
______________________________________________________________

OBS 1: Definir um nome de teste como por exemplo:

	def teste_valide_empty_price
		# . . .
	end
isso gera um erro de sintaxe, pois testes devem começar com test e não teste
______________________________________________________________

Porque testar se true é verdaderiro?, Isso serve maior ou menos como um “verificador” para você se
assegurar que tudo está funcionando corretamente com o framework de testes. Bom você pode pensar o que
poderia dar errado mesmo antes de você começar a escrever os seus teste?

Bom tente executar então o teste de unidade:

Loaded suite test/unit/product_test
Started
EE
Finished in 0.014967 seconds.
1) Error:
test_truth(ProductTest):
Mysql::Error: Unknown database 'demo_test' 

2) Error:
test_truth(ProductTest):
Mysql::Error: Unknown database 'demo_test' 

1 tests, 0 assertions, 0 failures, 2 errors 

Viu?? Falhou, facilmente vimos que que ele não conseguiu localizar o banco de dados demo_test, e não
é de menos, não criamos esse banco ainda, como poderia achar?

mysql >> create database demo_test;

Agora rodando novamente o teste:

ruby test/unit/product_test.rb Loaded suite test/unit/product_test
Started
E
Finished in 0.599951 seconds. 

  1) Error:
test_truth(ProductTest):
ActiveRecord::StatementInvalid: Mysql::Error: Table 'demo_test.products' doesn't exist: DELETE FROM
products 

1 tests, 0 assertions, 0 failures, 1 errors 

E BUM, falhou de novo, agora vimos que a tebela não existe, então o rails tem uma tarefa rake que  faz isso:

rake db:test:prepare

Agora sim, rode novamente o teste e tudo deverá funcionar:

ruby test/unit/product_test.rb
Loaded suite test/unit/product_test
Started
.
Finished in 0.014913 seconds. 

1 tests, 1 assertions, 0 failures, 0 errors 

__________________________________________________________
Teste de Unidade são teste que testam models, o que testa uma acão em um controller são testes
funcionais, e o que testa o fluxo por um ou mais controllers são testes de integracão.
__________________________________________________________

o camando rake prenche o esquema de banco de dados igual a do de desevolvimento. 

Agora rodando o teste e vemos que tudo esta certo: 

ruby test/unit/product_test.rb
Loaded suite test/unit/product_test
Started
.
Finished in 0.017633 seconds. 

1 tests, 1 assertions, 0 failures, 0 errors

:) ok.

Agora que esta tudo OK, podemos começar a escrever uns pequenos testes.

O primeiro teste que vamos fazer é assegurar que esses dois campos não passem por um teste onde
seus atributos são vazios.

Como Fazer isso?

Caso um produto inválido( vazio ) seja criado, isso deve ser considerado inválido pelo nosso teste,
e por vez um erro deve ser associado ao campo em questão.

O rails possue um método chamado invalid? Para ver se o produto é valido, e usar o método invalid?
Para ver se existem erros associados a aquele atributo em questão.

Como dizemos para o teste se ele passou ou não ? A resposta para a pergunta são as assertivas(assert),
 elas informam ao framework o que esperamos ser verdade, caso for true nada ocorre, e se for false a
assert falha.

require File.dirname(__FILE__) + '/../test_helper' 

class ProductTest < Test::Unit::TestCase 
  fixtures :products 

  # Replace this with your real tests. 
  def test_truth 
    assert true 
  end 
  
  def test_invalid_empty 
     product = Product.new 
=>assert !product.valid? 
     assert product.errors.invalid?(:titulo) 
     assert product.errors.invalid?(:quantidade) 
  end 
end

Na linha em destaque, dizemos ao framework que  o modelo product não é valido, e usamos o método invalid?
Para verificar se contém algum erro asociado a tal atributo.
Tente executar esse teste e você irá ver que ele vai falhar, então vamos até o nosso model e coloquemos a
validação dos dois campos:

class Product < ActiveRecord::Base 
   validates_presence_of :titulo 
   validates_presence_of :quantidade 
end

Rode e teste e... passou, validação está certa.

Temos um campo chamado quantidade seria interessante que esse campo fosse maior que zero, entao eu me
faço a pergunta:

1 – Quantidade pode ser menor que 0? Não.

OBS 2: Essa dica de se fazer perguntas, é um jeito mais facil de descobrir como escrever seus testes,
ela foi dita pelo Tapájos, na excelente série sobre testes feita por ele.

  def test_quantidade_positiva 
  	   product = Product.new(:titulo => "TV LCD") 
  	   		                             
  	   product.quantidade = -1 
  	   assert !product.valid? 
  	   assert_equal "Should be at least 0", product.errors.on(:quantidade) 
  	   
  	   product.quantidade = 0 
  	   assert !product.valid? 
  	   assert_equal "Should be at least 0", product.errors.on(:quantidade) 
  	   
  	   product.quantidade = 1 
  	   assert product.valid? 
  end

Aqui há uma configuração de três possíveis valores que o campo quantidade pode receber, para ele ver
válido deve ter seu valor >  0, o que o teste faz é criar um novo produto, e configurar a quantidade em 0,
-1, e 1 respectivamente, os dois primeiros asserts são inválidos, pois os valores são 0 e -1, e o último
configurado como 1 dizemos que é valido.

Rode o teste, e BUM, falhou, não estamos fazendo a validacão correta para esse campo, entao no seu model
coloque algo do tipo:

protected 
   def validate 
      errors.add(:quantidade, "Deve ser maior que 0")  if quantidade.nil? || quantidade <= 0 
  end


Criei um método validate, com o conteúdo acima, ele é protected por que não pode ser chamado fora do
contesto do model.

Agora rode o teste novamente e... OK.

Vamos à mais um pergunta:

	A quantidade pode ser um valor quebrado(float)? - Não.

Então vamos ao teste, muito similar aos outros.

def test_inteiro_value
  	   product = Product.new(:titulo => "TV LCD",
  	                                        :quantidade => 1.2 )
  	   
  	   assert !product.valid?
  	   assert product.errors.invalid?(:quantidade)
end

Certo, sem problemas, rodando o teste vemos que o teste não passou, isso significa que temos uma falha
no nosso modelo de validação.

Vamos acresentar a seguinte validação:

	validates_numericality_of :quantidade,  nly_integer => true

Aqui dizemos que estamos aceitado apenas numero inteiros, para o campo quantidade.

Bom, esse é o fim do primeiro post sobre Testes usando Test Unit, espero que tenha ficado claro,
obviamente isso foi muito superficial, mas creio que deu para dar uma compreendida e ver o quão
importante são os teste( e legal ). Esse post falamos apenas de testes de unidade, no próximo post,
continuaremos falando de testes de unidade.... é isso ai, espero comentários com críticas e sugestões,
abraço a todos.

Referências:

	Agil Development With Rails  - 2 (Livro)

Olá, pessoal, uma forma de se gerar documentos PDF usando Ruby é utilizar o pdf-writer, é uma gem que pode ser usada tanto em Rails e Ruby, nessa primeira parte vamos conhecer o básico , criar alguns exemplos e ver como o negocio funciona, não iremos ver tudo da gem(é obvio) bem que para isso tem o manual no site(99 páginas em Inglês), nesse post não iremos interar com o Rails, somente Ruby.

1 – Instalação

Para instalar o pdf-writer temos dois caminhos, 1) Instalar via RubyGems(recomendo) e 2) Instalar manualmente usando o pacote. Recomendo via rubygems pois ele irá reconhecer as dependências que o pdf-writer tem, já a segunda você irá ter que instalar a dependencia, ou transaction-simple ou colors-tools.

Via RubyGems:

sudo gem install pdf-writer

Via “package”

wget http://rubyforge.org/frs/download.php/33972/pdf-writer.1.1.8.tar.gz
tar -xvzf pdf-writer.1.1.8.tar.gz
cd pdf_writer-1.1.8
sudo ruby setup.rb

agora instale o transaction-simple ou colors-tools da mesma forma.
Mas acho melhor a primeiro opção

2 – Criando um Exemplo Muito Simples.

Vamos criar um exemplo “Hello PDF::Writer” para não ficar “Hello World” , crie arquivo chamado teste_pdf1.pfd com o seguinte conteúdo:

require "rubygems"
require "pdf/writer"

pdf = PDF::Writer.new
pdf.text("Hello PDF::Writer", :font_size => 35)
pdf.save_as("file1.pdf")

Isto produz:

Fizemos dois requires ali no começo, com rubygems e pdf/writer, após fizemos a chamada de PDF::Writer, logo depois “escrevemos” no documento  o texto “Hello PDF::Writer” e definimos o tamanho da fonte para 35 pontos, então por ultimo salvamos o documento como file1.pdf.

3 – Fontes e Posições.

Para configurar  o tipo de fonte usada você pode usar  pdf.select_font “Times-Roman” por exemplo, opções de posição , :left, :right, :absolute_left, :absolute_right, vamos a um exemplo:

require "rubygems"
require "pdf/writer"

pdf = PDF::Writer.new
pdf.select_font "Courier-BoldOblique"
pdf.text("Hello PDF::Writer", :font_size => 35, :left => 100)
pdf.save_as("file2.pdf")

Isto produz:

Justificações:
Com as seguinte quatro formas de justificação:

pdf.text("Hello Ruby!", :justification => :left)
pdf.text("Hello Ruby!", :justification => :right)
pdf.text(“Hello Ruby!", :justification => :center)
pdf.text("Hello Ruby", :justification => :full)

4 – Espaçamento entre Linhas

Você pode configurar o espaço entre determindas linhas do texto por exemplo:

require "rubygems"
require "pdf/writer"

pdf = PDF::Writer.new
pdf.select_font "Courier-BoldOblique"
pdf.text("Hello PDF::Writer", :font_size => 35, :left => 100)
pdf.text("Ola Mundo Cruel!", :font_size => 35, :left => 100, :spacing => 5)
pdf.save_as("file3.pdf")

5 – Documento final

Para finalizar esse post vamos criar um “documento real” com um simples texto, usando o que vimos nesse post.

require "rubygems"
require "pdf/writer"

pdf = PDF::Writer.new

BODY = <<-'EOS'
Benjamin Franklin (January 17, 1706 [O.S. January 6, 1705]   April 17, 1790) was one of the Founding Fathers of the United States of America. A noted polymath, Franklin was a leading author and printer, satirist, political theorist, politician, scientist, inventor, civic activist, statesman, and diplomat. As a scientist, he was a major figure in the Enlightenment and the history of physics for his discoveries and theories regarding electricity. He invented the lightning rod, bifocals, the Franklin stove, a carriage odometer, and a musical instrument. He formed both the first public lending library in America and first fire department in Pennsylvania. He was an early proponent of colonial unity and as a political writer and activist he, more than anyone, invented the idea of an American nation[1] and as a diplomat during the American Revolution, he secured the French alliance that helped to make independence possible.
Franklin is credited as being foundational to the roots of American values and character, a marriage of the practical and democratic Puritan values of thrift, hard work, education, community spirit, self-governing institutions, and opposition to authoritarianism both political and religious, with the scientific and tolerant values of the Enlightenment. In the words of Henry Steele Commager, "In Franklin could be merged the virtues of Puritanism without its defects, the illumination of the Enlightenment without its heat."[2] To Walter Isaacson, this makes Franklin, "the most accomplished American of his age and the most influential in inventing the type of society America would become."
EOS

corpo = BODY.split($/).join(" ").squeeze(" ")

pdf.text("Benjamin Franklin", :font_size => 20, :justification => :center)
pdf.move_pointer(36)
pdf.text(corpo, :font_size => 12, :justification => :full)
pdf.move_pointer(50)
pdf.text("Fonte: Wikipedia", :font_size => 10, :left => 370)
pdf.save_as("final.pdf")

Bom para começo é isso, logo irei postar algo mais sobre o pdf-writer, obviamente isso é muito mas muito básico.

Pequena Intro.

Hashes é uma coleção de pares (chave-valor), cada elemento da lista é um par, que contém uma chave que representa um valor. São semelhantes aos Arrays, porém se diferem desses por terem atribuição arbritária, chaves são qualquer tipo de objeto e não um int(inteiro) igual os Array.
Hashes em outra linguagem também são chamados de dicionários, e logo você vai ver porque ?.
Hashes tem valor padrão que é retornado se tentar acessar chaves que não existam, esse valor é nil.
Com essa pequena teoria sobre hashes em mente vamos fazer alguns exemplo, como sempre abra o IRB.

1 – Criando um hashe

h = {"choice"=>"escolha", "cloak"=>"capa", "stuffy"=>"abafado"}
=> {"stuffy"=>"abafado", "cloak"=>"capa", "choice"=>"escolha"}

Acima criamos um hashe simples contendo três palavras em inglês que suas traduções.
Bom como visto acima aqui não temos índices e sim chaves, vamos acessar as chaves desse hashe.
Antes vamos ver todos os métodos para manipulação de hashes, então usamos h.methods( onde h é o hashe que criamos a cima).

1.1 – Métodos

irb(main):003:0> h.methods
=> ["select", "[]=", "inspect", "each_value", "fetch", "clone", "values_at", "public_methods", "partition
", "display", "empty?", "instance_variable_defined?", "update", "shift", "to_yaml_properties", "equal?",
"freeze", "has_value?", "clear", "grep", "rehash", "to_yaml", "taguri", "indices", "methods", "respond_to
?", "reject", "each_key", "taguri=", "dup", "delete", "instance_variables", "yaml_initialize", "member?",
 "__id__", "find", "method", "eql?", "value?", "to_hash", "each_with_index", "id", "to_yaml_style", "inde
x", "collect", "singleton_methods", "send", "each_pair", "all?", "taint", "delete_if", "length", "entries
", "merge!", "frozen?", "instance_variable_get", "include?", "__send__", "instance_of?", "merge", "detect
", "to_a", "store", "zip", "type", "protected_methods", "instance_eval", "object_id", "map", "any?", "=="
, "values", "===", "size", "sort", "instance_variable_set", "default", "min", "kind_of?", "extend", "find
_all", "to_s", "default=", "default_proc", "key?", "each", "hash", "class", "reject!", "replace", "inject
", "tainted?", "keys", "=~", "private_methods", "invert", "nil?", "untaint", "sort_by", "has_key?", "max"
, "[]", "is_a?", "indexes"]
irb(main):004:0>

Veremos algo assim, uma grande lista de métodos que estão disponíveis para o uso, ali no meio(coloquei em negrito) temos o método Keys, ele nos mostra todas as chaves do nosso hashe, então vamos usá-lo.

1.2 – Chaves

h.keys
=> ["stuffy", "cloak", "choice"]

E está ai as três chaves que nosso hashe contém.

1.3 – Acessando Valores.

h["choice"]
=> "escolha"

Acho que não precisa explicar né ?

Temos outro método chamado values, como o primeiro que agente viu era chamado keys e você viu o que ele retornou, imagino que você já saiba o que este retorna:

h.values
=> ["abafado", "capa", "escolha"]

OHHHH, retornou os valores.

Com esses dois conceitos de keys e valeus em mente vamos fazer um loop para acessar todos os valores:

h.keys.each do |chave|
 puts "#{chave}  = #{h[chave]}"
end

stuffy  = abafado
cloak  = capa
choice  = escolha

2 – Adicionando novos elementos

Podemos adicionar novos elementos em um hashe, para isso temos dois métodos o merge e o merge!, listados na lista acima, vamos fazer dois exemplo usando os dois métodos é ver o que acontece.

numeros = {"1"=>"um","2"=>"dois","3"=>"tres"}
=> {"1"=>"um", "2"=>"dois", "3"=>"tres"}

Com merge

numeros.merge( {"4"=>"quatro"} )
=> {"1"=>"um", "2"=>"dois", "3"=>"tres", "4"=>"quatro"}
numeros
=> {"1"=>"um", "2"=>"dois", "3"=>"tres"}

Com merge!

numeros.merge!( {"4"=>"quatro"} )
=> {"1"=>"um", "2"=>"dois", "3"=>"tres", "4"=>"quatro"}
numeros
=> {"1"=>"um", "2"=>"dois", "3"=>"tres", "4"=>"quatro"}

Viu? Podemos concluir então que o primeiro método( merge ) não altera o hashe original, e o segundo já faz as alterações diretamente no original “gravando” as mudanças.

3 – Melhorando um pouco.

Esses exemplo acima, como você pode notar as chaves e os valores são representados com strings, isso não é bom, isso é feio, existe um tipo no ruby chamado symbol(símbolos), eles são representando com dois-pontos( : ) antes do nome, por exemplo :home.
Então vamos mudar nosso modo de criar hashe e usar symbols.

nums = {:um=>"1", :dois=>"2"}
=> {:um=>"1", :dois=>"2"}

Se você já andou mexendo com o Rails muito provavelmente você encontrou símbolos para tudo quanto é lado.
Então porque usar símbolos?
• São mais bonitos que Strings.
• O código fica melhor para ler
• Você economizara memória
• São usadas muito no Rails

Bom chegamos ao final, obviamente isso não é tudo, recomendo olhar a documentação do Ruby, e ir testando todos os métodos no IRB, novamente se alguém vier a ler isso e achar erros, me informe através dos comentários, ficaria feliz se quem ler esse post deixar um comentário dizendo o que achou.
Abraço a todos.