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



22
23
24
 
# File 'lib/darthjee/core_ext/array.rb', line 22

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



36
37
38
39
 
# File 'lib/darthjee/core_ext/array.rb', line 36

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



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

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



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

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| ... } ⇒ String

Joins elements in a string using a proc

Uses the proc given elements to Strig and a block for determinating the joining string

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

Returns:

  • (String) 


128
129
130
131
132
133
134
135
136
137
 
# File 'lib/darthjee/core_ext/array.rb', line 128

def procedural_join(mapper = proc(&:to_s))
  return '' if empty?
  map = map_to_hash(&mapper)

  map.inject do |(previous, string), (nexte, nexte_string)|
    link = yield(previous, nexte) if block_given?

    [nexte, "#{string}#{link}#{nexte_string}"]
  end.last.to_s
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]

Returns:

  • (Object) —

    random element of the array



147
148
149
 
# File 'lib/darthjee/core_ext/array.rb', line 147

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]

Returns:

  • (Object) —

    random element of the array



159
160
161
 
# File 'lib/darthjee/core_ext/array.rb', line 159

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