Module: Enumerable

Defined in:
lib/wukong/and_pig.rb,
lib/wukong/extensions/emittable.rb,
lib/wukong/extensions/enumerable.rb

Instance Method Summary collapse

Instance Method Details

#each_with_object(memo, &block) ⇒ Object

Iterates over a collection, passing the current element and the memo to the block. Handy for building up hashes or reducing collections down to one object. Examples:

%w(foo bar).each_with_object({}) { |str, hsh| hsh[str] = str.upcase } #=> {'foo' => 'FOO', 'bar' => 'BAR'}

Note that you can’t use immutable objects like numbers, true or false as the memo. You would think the following returns 120, but since the memo is never changed, it does not.

(1..5).each_with_object(1) { |value, memo| memo *= value } # => 1



42
43
44
45
46
47
48
 
# File 'lib/wukong/extensions/enumerable.rb', line 42

def each_with_object(memo, &block)
  returning memo do |m|
    each do |element|
      block.call(element, m)
    end
  end
end

#from_pig_bag ⇒ Object

Convert a string representing a pig bag into a nested array



27
28
29
 
# File 'lib/wukong/and_pig.rb', line 27

def from_pig_bag
  self.split("),(").map{|t| t.gsub(/[\{\}]/, '').from_pig_tuple} rescue []
end

#from_pig_tuple ⇒ Object

Convert a string representing a pig tuple into an array



34
35
36
 
# File 'lib/wukong/and_pig.rb', line 34

def from_pig_tuple
  self.gsub(/[\(\)]/, '').split(',')
end

#index_by ⇒ Object

Convert an enumerable to a hash. Examples:

people.index_by(&:login)
  => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
people.index_by { |person| "#{person.first_name} #{person.last_name}" }
  => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}



57
58
59
60
61
62
 
# File 'lib/wukong/extensions/enumerable.rb', line 57

def index_by
  inject({}) do |accum, elem|
    accum[yield(elem)] = elem
    accum
  end
end

#many?(&block) ⇒ Boolean

Returns true if the collection has more than 1 element. Functionally equivalent to collection.size > 1. Works with a block too ala any?, so people.many? { |p| p.age > 26 } # => returns true if more than 1 person is over 26.

Returns:



66
67
68
69
 
# File 'lib/wukong/extensions/enumerable.rb', line 66

def many?(&block)
  size = block_given? ? select(&block).size : self.size
  size > 1
end

#none?(&block) ⇒ Boolean

Returns true if none of the elements match the given block.

success = responses.none? {|r| r.status / 100 == 5 }

This is a builtin method in Ruby 1.8.7 and later.

Returns:



76
77
78
 
# File 'lib/wukong/extensions/enumerable.rb', line 76

def none?(&block)
  !any?(&block)
end

#sum(identity = 0, &block) ⇒ Object

Calculates a sum from the elements. Examples:

payments.sum { |p| p.price * p.tax_rate }
payments.sum(&:price)

The latter is a shortcut for:

payments.inject { |sum, p| sum + p.price }

It can also calculate the sum without the use of a block.

[5, 15, 10].sum # => 30
["foo", "bar"].sum # => "foobar"
[[1, 2], [3, 1, 5]].sum => [1, 2, 3, 1, 5]

The default sum of an empty list is zero. You can override this default:

[].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)



22
23
24
25
26
27
28
 
# File 'lib/wukong/extensions/enumerable.rb', line 22

def sum(identity = 0, &block)
  if block_given?
    map(&block).sum(identity)
  else
    inject { |sum, element| sum + element } || identity
  end
end

#to_pig(*args) ⇒ Object

Convert an array of values to a string pig format see also to_pig_bag



13
14
15
 
# File 'lib/wukong/and_pig.rb', line 13

def to_pig *args
  to_pig_tuple *args
end

#to_pig_bag ⇒ Object

Convert an array of values to a string representing it as a pig bag



20
21
22
 
# File 'lib/wukong/and_pig.rb', line 20

def to_pig_bag
  '{' + self.map{|*vals| vals.to_pig_tuple}.join(",") + '}'
end

#to_pig_tuple ⇒ Object

Convert an array of values to a string representing it as a pig tuple



5
6
7
 
# File 'lib/wukong/and_pig.rb', line 5

def to_pig_tuple
  '(' + self.join(',') + ')'
end