Class: Array

Inherits:
Object
  • Object
show all
Includes:
Everythingrb::InspectQuotable
Defined in:
lib/everythingrb/array.rb

Overview

Extensions to Ruby’s core Array class

Provides:

  • #join_map: Combine filter_map and join operations in one step

  • #key_map, #dig_map: Extract values from arrays of hashes

  • #deep_freeze: Recursively freeze array and contents

  • #compact_prefix, #compact_suffix, #trim_nils: Clean up array boundaries

  • ActiveSupport integrations: #trim_blanks and more when ActiveSupport is loaded

Examples:

require "everythingrb/array"
["foo", nil, "bar"].join_map(", ") { |s| s&.upcase }  # => "FOO, BAR"
[{name: "Alice"}, {name: "Bob"}].key_map(:name)  # => ["Alice", "Bob"]

Instance Method Summary collapse

Methods included from Everythingrb::InspectQuotable

#in_quotes

Instance Method Details

#compact_blank_prefix ⇒ Array

Removes blank values from the beginning of an array

Examples:

With ActiveSupport loaded

[nil, "", 1, 2, "", 3].compact_blank_prefix
# => [1, 2, "", 3]

Returns:

  • (Array) —

    Array with leading blank values removed



156
157
158
 
# File 'lib/everythingrb/array.rb', line 156

def compact_blank_prefix
  drop_while(&:blank?)
end

#compact_blank_suffix ⇒ Array

Removes blank values from the end of an array

Examples:

With ActiveSupport loaded

[1, 2, "", 3, nil, ""].compact_blank_suffix
# => [1, 2, "", 3]

Returns:

  • (Array) —

    Array with trailing blank values removed



169
170
171
 
# File 'lib/everythingrb/array.rb', line 169

def compact_blank_suffix
  reverse.drop_while(&:blank?).reverse
end

#compact_prefix ⇒ Array

Removes nil values from the beginning of an array

Examples:

[nil, nil, 1, 2, nil, 3].compact_prefix
# => [1, 2, nil, 3]

Returns:

  • (Array) —

    Array with leading nil values removed



115
116
117
 
# File 'lib/everythingrb/array.rb', line 115

def compact_prefix
  drop_while(&:nil?)
end

#compact_suffix ⇒ Array

Removes nil values from the end of an array

Examples:

[1, 2, nil, 3, nil, nil].compact_suffix
# => [1, 2, nil, 3]

Returns:

  • (Array) —

    Array with trailing nil values removed



128
129
130
 
# File 'lib/everythingrb/array.rb', line 128

def compact_suffix
  reverse.drop_while(&:nil?).reverse
end

#deep_freeze ⇒ self

Note:

CAUTION: Be careful when freezing collections that contain class objects or singleton instances - this will freeze those classes/objects globally! Only use deep_freeze on pure data structures you want to make immutable.

Recursively freezes self and all of its contents

Examples:

Freeze an array with nested structures

["hello", { name: "Alice" }, [1, 2, 3]].deep_freeze
# => All elements and nested structures are now frozen

Returns:

  • (self) —

    Returns the frozen array



101
102
103
104
 
# File 'lib/everythingrb/array.rb', line 101

def deep_freeze
  each { |v| v.respond_to?(:deep_freeze) ? v.deep_freeze : v.freeze }
  freeze
end

#dig_map(*keys) ⇒ Array

Maps over hash keys to extract nested values using dig

Examples:

[
  {user: {profile: {name: "Alice"}}},
  {user: {profile: {name: "Bob"}}}
].dig_map(:user, :profile, :name)
# => ["Alice", "Bob"]

Parameters:

Returns:

  • (Array) —

    Array of nested values



84
85
86
 
# File 'lib/everythingrb/array.rb', line 84

def dig_map(*keys)
  map { |v| v.dig(*keys) }
end

#join_map(join_with = "", with_index: false) {|element, index| ... } ⇒ String

Combines filter_map and join operations

Examples:

Without index

[1, 2, nil, 3].join_map(" ") { |n| n&.to_s if n&.odd? }
# => "1 3"

With index

["a", "b", "c"].join_map(", ", with_index: true) { |char, i| "#{i}:#{char}" }
# => "0:a, 1:b, 2:c"

Default behavior without block

[1, 2, nil, 3].join_map(", ")
# => "1, 2, 3"

Parameters:

  • join_with (String) (defaults to: "") —

    The delimiter to join elements with (defaults to empty string)

  • with_index (Boolean) (defaults to: false) —

    Whether to include the index in the block (defaults to false)

Yields:

  • (element, index) —

    Block that filters and transforms array elements

Yield Parameters:

  • element (Object) —

    The current element

  • index (Integer) —

    The index of the current element (only if with_index: true)

Returns:

  • (String) —

    Joined string of filtered and transformed elements



45
46
47
48
49
50
51
52
53
 
# File 'lib/everythingrb/array.rb', line 45

def join_map(join_with = "", with_index: false, &block)
  block = ->(i) { i } if block.nil?

  if with_index
    filter_map.with_index(&block).join(join_with)
  else
    filter_map(&block).join(join_with)
  end
end

#key_map(key) ⇒ Array

Maps over hash keys to extract values for a specific key

Examples:

[{name: "Alice", age: 30}, {name: "Bob", age: 25}].key_map(:name)
# => ["Alice", "Bob"]

Parameters:

Returns:

  • (Array) —

    Array of values extracted from each hash



66
67
68
 
# File 'lib/everythingrb/array.rb', line 66

def key_map(key)
  map { |v| v[key] }
end

#to_deep_h ⇒ Array

Recursively converts all elements that respond to #to_h

Maps over the array and calls #to_deep_h on any Hash/String elements, #to_h on any objects that respond to it, and handles nested arrays.

Examples:

Converting arrays with mixed object types

users = [
  {name: "Alice", roles: ["admin"]},
  OpenStruct.new(name: "Bob", active: true),
  Data.define(:name).new(name: "Carol")
]
users.to_deep_h
# => [
#      {name: "Alice", roles: ["admin"]},
#      {name: "Bob", active: true},
#      {name: "Carol"}
#    ]

With nested arrays and JSON strings

data = [
  {profile: '{"level":"expert"}'},
  [OpenStruct.new(id: 1), OpenStruct.new(id: 2)]
]
data.to_deep_h
# => [{profile: {level: "expert"}}, [{id: 1}, {id: 2}]]

Returns:

  • (Array) —

    A new array with all convertible elements deeply converted



239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/everythingrb/array.rb', line 239

def to_deep_h
  map do |value|
    case value
    when Hash
      value.to_deep_h
    when Array
      value.to_deep_h
    when String
      # If the string is not valid JSON, #to_deep_h will return `nil`
      value.to_deep_h || value
    else
      value.respond_to?(:to_h) ? value.to_h : value
    end
  end
end

#to_or_sentence(options = {}) ⇒ String

Joins array elements into a sentence with “or” connector

Similar to ActiveSupport’s #to_sentence but uses “or” instead of “and” as the joining word between elements.

Examples:

Basic usage

["red", "blue", "green"].to_or_sentence
# => "red, blue, or green"

With only two elements

["yes", "no"].to_or_sentence
# => "yes or no"

Parameters:

  • options (Hash) (defaults to: {}) —

    Options to pass to #to_sentence

Returns:

  • (String) —

    Array elements joined in sentence form with “or” connector



204
205
206
207
 
# File 'lib/everythingrb/array.rb', line 204

def to_or_sentence(options = {})
  options = options.reverse_merge(last_word_connector: ", or ", two_words_connector: " or ")
  to_sentence(options)
end

#trim_blanks ⇒ Array

Removes blank values from both the beginning and end of an array

Examples:

With ActiveSupport loaded

[nil, "", 1, 2, "", 3, nil, ""].trim_blanks
# => [1, 2, "", 3]

Returns:

  • (Array) —

    Array with leading and trailing blank values removed



182
183
184
 
# File 'lib/everythingrb/array.rb', line 182

def trim_blanks
  compact_blank_prefix.compact_blank_suffix
end

#trim_nils ⇒ Array

Removes nil values from both the beginning and end of an array

Examples:

[nil, nil, 1, 2, nil, 3, nil, nil].trim_nils
# => [1, 2, nil, 3]

Returns:

  • (Array) —

    Array with leading and trailing nil values removed



141
142
143
 
# File 'lib/everythingrb/array.rb', line 141

def trim_nils
  compact_prefix.compact_suffix
end