AkitaOnRails

>> "Finally, something useful!".at(6)
=> "y"

>> "Chris the Person".from(6)
=> "the Person" 
>> "Chris the Person".to(4)
=> "Chris"

>> "Christmas Time".first
=> "C" 
>> "Christmas Time".first(5)
=> "Chris" 
>> "Christmas Time".last
=> "e" 
>> "Christmas Time".last(4)
=> "Time"

>> "Snow".each_char { |i| print i.upcase }
SNOW

>> "Peanut Butter".starts_with? 'Peanut'
=> true
>> "Peanut Butter".ends_with? 'Nutter'
=> false

*Dia 7: transformations!* (String)

Oh, quantos. Você ainda está usando <code>Inflector.pluralize(string)</code>? Esqueça isso. Tente alguns desses métodos:

<code>pluralize, singularize, camelize, titleize, underscore, dasherize, demodulize, tableize, classify, humanize, foreign_key, e constantize</code>

-- ruby
>> "reindeer".pluralize
=> "reindeers" 
>> "elves".singularize
=> "elf" 
>> "christmas_carol".camelize
=> "ChristmasCarol" 
>> "christmas_carol".camelize(:lower)
=> "christmasCarol" 
>> "holiday_cheer".titleize
=> "Holiday Cheer" 
>> "AdventCalendar-2006".underscore
=> "advent_calendar_2006" 
>> "santa_Claus".dasherize
=> "santa-Claus" 
>> "Holiday::December::Christmas".demodulize
=> "Christmas" 
>> "SnowStorm".tableize
=> "snow_storms" 
>> "snow_storms".classify
=> "SnowStorm" 
>> "present_id".humanize
=> "Present" 
>> "Present".foreign_key
=> "present_id" 
>> "Cheer".constantize
NameError: uninitialized constant Cheer
>> "Christmas".constantize
=> Christmas

Você pode passar duas opções: <code>:connector</code> e <code>:skip_last_comma</code>. Eles funcionam assim:

-- ruby
>> %w[Soap Mocha Chocolate].to_sentence(:connector => '&')
=> "Soap, Mocha, & Chocolate" 
>> %w[Ratatat Interpol Beirut].to_sentence(:skip_last_comma => true)
=> "Ratatat, Interpol and Beirut" 

Agora, digamos que nós queremos sobrescrever o método de instância <code>to_param</code> do <code>User</code> para retornar <code>name</code>:

-- ruby
>> user = User.find(:first)
=> #<User:0x28fe31c ... >  
>> helper.url_for :controller => 'users', :action => 'show', :id => user
=> "/users/chris"

(Isso está _escaped_, claro). Isso é de tal maneira que você possa enviar e lidar facilmente com rotas que pegam qualquer coisa. "Essa discussão":https://railsforum.com/viewtopic.php?pid=3723 no RailsForum fala sobre esse tipo de rota. Você pode ou não achar isso útil.

*Dia 10: to_s* (Array)

Claro, você sabe que o <code>Array</code> tem um <code>to_s</code>, mas sabia que Rails o sobrescreve para aceitar um parâmetro de formato (:db)? Isso mesmo! Veja isso:

-- ruby
>> array_of_posts = Post.find(:all, :limit => 3)
=> [#<Post:0x28c1ef8 ... >, #<Post:0x28c1de0 ... >, #<Post:0x28c1d54 ... >]
>> array_of_posts.to_s(:db)
=> "1,2,3" 
>> [].to_s
=> "" 
>> [].to_s(:db)
=> "null"

Passe nele <code>:skip_instruct</code> para omitir a linha <code><?xml version ...</code>. Você também pode fornecer uma opção <code>:indent</code> (padrão: 2), um <code>:builder</code> (você provavelmente quer manter o padrão <code>Builder::XmlMarkup</code>), um <code>:root</code> (padrão o nome da classe, no plural e em caixa baixa, <code>posts</code> no caso), e um <code>:children</code> (nome da classe no singular - <code>post</code> para mim).

*Dia 12: in_groups_of* (Array)

A documentação tem isso coberto muito bem: _"Itere sobre um array em grupos de certo tamanho, preenchendo os espaços restantes com um valor especificado (<code>nil</code>, por padrão) a menos que seja <code>false</code>."_

E, três exemplos. Isso é quase trapacear. Mas aí vai:

<code><pre> >> %w[1 2 3 4 5 6 7].in_groups_of(3) { |g| p g }
["1", "2", "3"]
["4", "5", "6"]
["7", nil, nil]

>> %w[1 2 3].in_groups_of(2, '&nbsp;') { |g| p g }
["1", "2"]
["3", "&nbsp;"]

>> %w[1 2 3].in_groups_of(2, false) { |g| p g }
["1", "2"]
["3"]

>> %w[1 2 3 4 5 6 7].in_groups_of(3)
=> [["1", "2", "3"], ["4", "5", "6"], ["7", nil, nil]]
</pre></code>

*Dia 13: split* (Array)

Corte um array em arrays menores da mesma forma como <code>String.split</code> corta strings em arrays. Pode receber um parâmetro (um valor para cortar) ou um bloco (onde o resultado é o que vai ser usado para o corte).

-- ruby
>> %w[Tom Jerry and Mickey and Pluto].split('and')
=> [["Tom", "Jerry"], ["Mickey"], ["Pluto"]]  
>> %w[Chris Mark Adam Tommy Martin Oliver].split { |name| name.first == 'M' }
=> [["Chris"], ["Adam", "Tommy"], ["Oliver"]]

*Dia 15: assert_valid_keys* (Hash)

Já tentou "escorregar suas próprias chaves":https://tech.rufy.com/2006/11/fatal-flaw-in-opinionated-software.html dentro de um <code>ActiveRecord#find</code> ou parecido? Rails não vai aceitar nada disso graças a <code>assert_valid_keys</code>. Use esse bad boy para espirrar "vinagre":https://www.loudthinking.com/arc/000601.html sobre suas APIs.

-- ruby
>> about_me = { :height => 71, :weight => 160, :likes => 'monster trucks'
=> {:height=>71, :likes=>"monster trucks", :weight=>160}
>> about_me.assert_valid_keys(:height, :weight, :age)
ArgumentError: Unknown key(s): likes 

*Dia 16: diff* (Hash)

Meio estranho, mas útil. <code>Hash#diff</code> mostra quais partes do hash A mudaram ou foram removidas na transição para o hash B.

Aqui, vou colocar meu nome, então mudar meu nome do meio, então totalmente jogar meu nome do meio. Em ambas as vezes (alterado e jogado fora), posso ver exatamente o que mudou.

-- ruby
>> name = { :first => 'Chris', :last => 'Wanstrath', :middle => 'Jebediah' }
=> {:first=>"Chris", :last=>"Wanstrath", :middle=>"Jebediah"}
>> name.diff(:first => 'Chris', :last => 'Wanstrath', :middle => 'Jonesy')
=> {:middle=>"Jebediah"}
>> name.diff(:first => 'Chris', :last => 'Wanstrath')
=> {:middle=>"Jebediah"} 

<h4>Helpers Numericamente Élficos [ Métodos Numeric (Integer, Float, etc) ]</h4>

*Dia 19: bytes* (Numeric)

Peguei vocês, bytes! Talvez você tenha visto <code>2.days</code> ou <code>15.minutos</code> antes. Mesma coisa, mas em todos os sabores de comida de computador: bytes. (Eles vêm todos em versões no plural e singular)

<code>bytes, kilobytes, megabytes, gigabytes, terabytes, petabytes, e exabytes</code>

-- ruby
>> 100.bytes
=> 100
>> 5.kilobytes
=> 5120
>> 10.megabytes
=> 10485760
>> 100.gigabytes
=> 107374182400
>> 2.terabytes
=> 2199023255552
>> 1.petabytes
=> 1125899906842624
>> 2.exabytes
=> 2305843009213693952 

<div style="text-align: center">!/files/advent-elves.gif!</div>

<h4>Um Inty Ligeiro [ Métodos Integer ]</h4>

*Dia 21: ordinalize* (Integer)

Como <code>pluralize</code> do string, <code>ordinalize</code> faz um número parecer mais oficial:

-- ruby
>> 5.ordinalize
=> "5th"

<h4>Enumerando Suas Emoções [ Métodos Enumerable (Hash, Array, etc) ]</h4>

*Dia 23: group_by* (Enumerable)

Muito parecido com <code>GROUP BY</code> do SQL, esse método mão-na-roda o permite agrupar elementos dentro de um enumerador de qualquer maneira arbitrária que quiser. Aqui, vou agrupar um array de hashes por suas cores de preferência.

-- ruby
>> magical_people = [ { :name => "Santa Claus",     :color => "Red" }, 
                      { :name => "Mrs Claus",       :color => "Red" }, 
                      { :name => "Twinkle the Elf", :color => "Green "} ]
=> [{:name=>"Santa Claus", :color=>"Red"}, 
        {:name=>"Mrs Claus", :color=>"Red"}, 
        {:name=>"Twinkle the Elf", :color=>"green "}]

>> magical_people.group_by { |person| person[:color] }
=> {"Green "=>[{:name=>"Twinkle the Elf", :color=>"green "}],
   "Red"=>[{:name=>"Santa Claus", :color=>"Red"}, 
        {:name=>"Mrs Claus", :color=>"Red"}]} 

*Dia 25: sum* (Enumerable)

É muito simples. Chame diretamente ou passe um bloco. Realmente, um ótimo atalho para <code>inject</code>.

-- ruby
>> [1,2,3,4,5].sum
=> 15
>> Recipe.find(:all).sum { |recipe| recipe.total_time.to_i }
=> 1777