Module: Enumerable

Defined in:
lib/active_support/core_ext/enumerable.rb,
lib/active_support/json/encoders/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



79
80
81
82
83
84
85
 
# File 'lib/active_support/core_ext/enumerable.rb', line 79

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

#group_by ⇒ Object

Collect an enumerable into sets, grouped by the result of a block. Useful, for example, for grouping records by date.

Example:

latest_transcripts.group_by(&:day).each do |day, transcripts| 
  p "#{day} -> #{transcripts.map(&:class).join(', ')}"
end
"2006-03-01 -> Transcript"
"2006-02-28 -> Transcript"
"2006-02-27 -> Transcript, Transcript"
"2006-02-26 -> Transcript, Transcript"
"2006-02-25 -> Transcript"
"2006-02-24 -> Transcript, Transcript"
"2006-02-23 -> Transcript"



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/active_support/core_ext/enumerable.rb', line 22

def group_by
  assoc = ActiveSupport::OrderedHash.new

  each do |element|
    key = yield(element)

    if assoc.has_key?(key)
      assoc[key] << element
    else
      assoc[key] = [element]
    end
  end

  assoc
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 ...>, ...}



94
95
96
97
98
99
 
# File 'lib/active_support/core_ext/enumerable.rb', line 94

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:

  • (Boolean) 


103
104
105
106
 
# File 'lib/active_support/core_ext/enumerable.rb', line 103

def many?(&block)
  size = block_given? ? select(&block).size : self.size
  size > 1
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)



57
58
59
60
61
62
63
64
65
 
# File 'lib/active_support/core_ext/enumerable.rb', line 57

def sum(identity = 0, &block)
  return identity unless size > 0

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

#to_json(options = {}) ⇒ Object

Returns a JSON string representing the enumerable. Any options given will be passed on to its elements. For example:

users = User.find(:all)
# => users.to_json(:only => :name)

will pass the :only => :name option to each user.



9
10
11
 
# File 'lib/active_support/json/encoders/enumerable.rb', line 9

def to_json(options = {}) #:nodoc:
  "[#{map { |value| ActiveSupport::JSON.encode(value, options) } * ', '}]"
end