Module: Darthjee::CoreExt::Array

Included in:
Array
Defined in:
lib/darthjee/core_ext/array.rb,
lib/darthjee/core_ext/array/hash_builder.rb

Overview

Module containing new usefull methods to Ruby vanilla Array

Defined Under Namespace

Classes: HashBuilder

Instance Method Summary collapse

Instance Method Details

#as_hash(keys) ⇒ ::Hash

Returns a Hash where the values are the elements of the array

Examples:

Creation of hash with symbol keys

array = %w[each word one key]
array.as_hash(i[a b c d])
# returns
# { a: 'each', b: 'word', c: 'one', d: 'key' }

Parameters:

Returns:

  • (::Hash) —

    hash built pairing the keys and values



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

def as_hash(keys)
  Array::HashBuilder.new(self, keys).build
end

#average ⇒ ::Float

Calculate the average of all values in the array

Examples:

Average of array of integer values

array = [1, 2, 3, 4]
array.average # returns 2.5

An empty array

[].average # returns 0

Returns:

  • (::Float) —

    average of all numbers



34
35
36
37
 
# File 'lib/darthjee/core_ext/array.rb', line 34

def average
  return 0 if empty?
  sum * 1.0 / length
end

#chain_map(*methods) {|element| ... } ⇒ ::Array

Maps the array using the given methods on each element of the array

Examples:

Mapping to string out of float size of strings

words = %w(big_word tiny oh_my_god_such_a_big_word)
words.chain_map(:size, :to_f, :to_s) # returns ["8.0", "4.0", "25.0"]

Mapping with a block mapping at the end

words = %w(big_word tiny oh_my_god_such_a_big_word)

output = words.chain_map(:size) do |size|
  (size % 2).zero? ? 'even size' : 'odd size'
end  # returns ["even size", "even size", "odd size"]

Parameters:

  • methods (::String, ::Symbol) —

    List of methods to be called sequentially on each element of the array

Yields:

  • (element) —

    block to be called on each element performing a final mapping

Yield Parameters:

  • element (::Object) —

    element that will receive the method calls in chain

Returns:

  • (::Array) —

    Array with the result of all method calls in chain



62
63
64
65
66
67
68
69
 
# File 'lib/darthjee/core_ext/array.rb', line 62

def chain_map(*methods, &block)
  result = methods.inject(self) do |array, method|
    array.map(&method)
  end

  return result unless block_given?
  result.map(&block)
end

#mapk(*keys) ⇒ ::Array

Maps array chain fetching the keys of the hashes inside

fetched from hashes inside

Examples:

Multi level hash mapping

array = [
  { a: { b: 1 }, b: 2 },
  { a: { b: 3 }, b: 4 }
]
array,mapk(:a)     # returns [{ b: 1 }, { b: 3 }]
array.mapk(:a, :b) # returns [1, 3]

Key missing

array = [
  { a: { b: 1 }, b: 2 },
  { a: { b: 3 }, b: 4 }
]
array.mapk(:c)     # returns [nil, nil]
array.mapk(:c, :d) # returns [nil, nil]

Parameters:

  • keys (::String, ::Symbol) —

    list of keys to be

Returns:

  • (::Array) —

    Array resulting of chain fetch of keys



93
94
95
96
97
98
99
 
# File 'lib/darthjee/core_ext/array.rb', line 93

def mapk(*keys)
  keys.inject(self) do |enum, key|
    enum.map do |hash|
      hash&.[] key
    end
  end
end

#procedural_join(mapper = proc(&:to_s)) {|previous, nexte| ... } ⇒ Object

Joins elements in a string using a proc to convert elements to Strig and a block for joining

to string before joining

Examples:

Addition of positive and negative numbers

[1, 2, -3, -4, 5].procedural_join do |_previous, nexte|
  nexte.positive? ? '+' : ''
end     # returns '1+2-3-4+5'

Spaced addition of positive and negative numbers

mapper = proc { |value| value.to_f.to_s }
array.procedural_join(mapper) do |_previous, nexte|
  nexte.positive? ? ' +' : ' '
end     # returns '1.0 +2.0 -3.0 -4.0 +5.0'

Parameters:

  • mapper (Proc) (defaults to: proc(&:to_s)) —

    Proc that will be used to map values

Yields:

  • (previous, nexte) —

    defines the string to be used to join the previous and next element

Yield Parameters:

  • previous (::Object) —

    previous element that was joined

  • nexte (::Object) —

    next element that will be joined



123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/darthjee/core_ext/array.rb', line 123

def procedural_join(mapper = proc(&:to_s))
  return '' if empty?
  list =     dup
  previous = first
  list[0] = mapper.call(previous).to_s

  list.inject do |string, value|
    link =        yield(previous, value) if block_given?
    next_string = mapper.call(value)
    previous = value

    "#{string}#{link}#{next_string}"
  end
end

#random ⇒ Object

Reeturns a random element of the array without altering it

Examples:

Picking a random element of numeric array

array = [10, 20, 30]
array.random # might return 10, 20 or 30
array        # returns unchanged [10, 20, 30]



144
145
146
 
# File 'lib/darthjee/core_ext/array.rb', line 144

def random
  self[Random.rand(size)]
end

#random! ⇒ Object

Reeturns a random element of the array removing it from the array

Examples:

Slicing a random element of a numeric array

array = [10, 20, 30]
array.random! # might return 10, 20 or 30 ... lets say 20
array         # returns changed [20, 30]



154
155
156
 
# File 'lib/darthjee/core_ext/array.rb', line 154

def random!
  slice!(Random.rand(size))
end