Class: Array

Inherits:
Object show all
Defined in:
lib/ruby_core_extensions/array.rb,
lib/ruby_core_extensions/compact/array.rb,
lib/ruby_core_extensions/recursive/array.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.first(object) ⇒ Object

Same effect as Array.wrap(object).first but no need to create new object in case of non-array



30
31
32
33
 
# File 'lib/ruby_core_extensions/array.rb', line 30

def self.first(object)
  return object.first if object.is_a?(Array)
  object
end

.last(object) ⇒ Object

Same effect as Array.wrap(object).last but no need to create new object in case of non-array



37
38
39
40
 
# File 'lib/ruby_core_extensions/array.rb', line 37

def self.last(object)
  return object.last if object.is_a?(Array)
  object
end

Instance Method Details

#compact_blank! ⇒ Object 



2
3
4
 
# File 'lib/ruby_core_extensions/compact/array.rb', line 2

def compact_blank!
  delete_if { |v| v.blank? }
end

#convert ⇒ Object 



2
3
4
 
# File 'lib/ruby_core_extensions/recursive/array.rb', line 2

def convert
  self
end

#convert_keys_recursively(&converter) ⇒ Object 



6
7
8
 
# File 'lib/ruby_core_extensions/recursive/array.rb', line 6

def convert_keys_recursively(&converter)
  map { |v| v.convert_keys_recursively(&converter) }
end

#convert_values_recursively(&converter) ⇒ Object 



10
11
12
 
# File 'lib/ruby_core_extensions/recursive/array.rb', line 10

def convert_values_recursively(&converter)
  map { |v| v.convert_values_recursively(&converter) }
end

#hash_by(key = nil, method = nil, &block) ⇒ Object

Key should be unique, or latest element with that key will override previous ones.



3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/ruby_core_extensions/array.rb', line 3

def hash_by(key = nil, method = nil, &block)
  self.inject({}) do |h, element|
    if key
      h[element.send(key)] = if block_given?
        yield(element)
      elsif method
        element.send(method)
      else
        element
      end
    else # key is block and value is element
      h[yield(element)] = element
    end
    h
  end
end

#hash_by_id(method = nil, &block) ⇒ Object 



20
21
22
 
# File 'lib/ruby_core_extensions/array.rb', line 20

def hash_by_id(method = nil, &block)
  hash_by(:id, method, &block)
end

#intersects?(other) ⇒ Boolean

Returns:

  • (Boolean) 


24
25
26
 
# File 'lib/ruby_core_extensions/array.rb', line 24

def intersects?(other)
  self.any? { |i| other.include?(i) }
end

#make_indifferent_access_recursively ⇒ Object 



22
23
24
 
# File 'lib/ruby_core_extensions/recursive/array.rb', line 22

def make_indifferent_access_recursively
  map(&:make_indifferent_access_recursively)
end

#recursive_blank? ⇒ Boolean

Returns:

  • (Boolean) 


26
27
28
29
30
31
32
33
34
35
 
# File 'lib/ruby_core_extensions/recursive/array.rb', line 26

def recursive_blank?
  each do |v|
    if v.respond_to?(:recursive_blank?)
      return false unless v.recursive_blank?
    else
      return false unless v.blank?
    end
  end
  true
end

#recursive_compact_blank! ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/ruby_core_extensions/compact/array.rb', line 6

def recursive_compact_blank!
  delete_if do |v|
    if v.is_a?(Hash)
      v.recursive_compact_blank!
      v.recursive_blank?
    elsif v.is_a?(Array)
      v.recursive_compact_blank!
      v.recursive_blank?
    else
      v.blank?
    end
  end
end

#recursively(&block) ⇒ Object 



37
38
39
40
41
42
 
# File 'lib/ruby_core_extensions/recursive/array.rb', line 37

def recursively(&block)
  each do |element|
    block.call(element)
    element.recursively(&block) if element.respond_to?(:recursively)
  end
end

#stringify_values_recursively ⇒ Object 



18
19
20
 
# File 'lib/ruby_core_extensions/recursive/array.rb', line 18

def stringify_values_recursively
  map(&:stringify_values_recursively)
end

#symbolize_keys_recursively ⇒ Object 



14
15
16
 
# File 'lib/ruby_core_extensions/recursive/array.rb', line 14

def symbolize_keys_recursively
  map(&:symbolize_keys_recursively)
end