Module: WrapIt::ArgumentsArray

Defined in:
lib/wrap_it/arguments_array.rb

Overview

Adds #extract! and #extarct_first! methods to array. Theese methods are extracts items from array by some condirions and returns its as separate array for #extract! and as first item for #extract_first!.

Author:

Constant Summary collapse

REQUIRED_METHODS = 
%i(reject! find_index delete_at)

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(base) ⇒ Object 



12
13
14
15
16
17
18
19
20
 
# File 'lib/wrap_it/arguments_array.rb', line 12

def self.included(base)
  methods = base.methods
  # avoid including in classes thats doen't have methods, used in
  # inplementation
  REQUIRED_METHODS.all? { |m| methods.include?(m) } || fail(
    TypeError,
    "#{self.class.name} can't be included into #{base.class.name}"
  )
end

Instance Method Details

#extract!([condition, ..., options]) ⇒ Array #extract!(&block) ⇒ Array

Extracts elements from array by conditions, passed in arguments nad returns theese elements as new array.

Condition can be Regexp, class, Array and any other value. If condition is Regexp, all elements of array are tested for matching to this regexp, previously converted to String by their to_s method. If condition is an Array, all elements tested if it included in these array. If the condition is a class, then elements are tested via is_a? method for this class. For any other value, elements are tested with equality operator ‘==`.

You can provide a block. In this case, all arguments are ignored, and block yielded for each element of array. If block returns true, element extracted from array.

All conditions, passed as arguments are or-ed so ‘String, Symbol` means select Symbol or String elements.

Examples:

extract by class

arr = [1, 2, 3, 'and', 'string']
arr.extend WrapIt::ArgumentsArray
arr.extract(String) #=> ['and', 'string']
arr                 #=> [1, 2, 3]

extract by value

arr = [1, 2, 3, 'and', 'string']
arr.extend WrapIt::ArgumentsArray
arr.extract(1, 2) #=> [1, 2]
arr               #=> [3, 'and', 'string']

extract by Regexp

arr = [1, 2, 3, 'and', 'string', :str]
arr.extend WrapIt::ArgumentsArray
arr.extract(/^str/) #=> ['string', :str]
arr                 #=> [1, 2, 3, 'and']

extract by Array

arr = [1, 2, 3, 'and', 'string']
arr.extend WrapIt::ArgumentsArray
arr.extract([1, 10, 'and']) #=> [1, 'and']
arr                         #=> [2, 3, 'string']

extract by block

arr = [1, 2, 3, 'and', 'string']
arr.extend WrapIt::ArgumentsArray
arr.extract {|x| x < 3} #=> [1, 2]
arr                     #=> [3, 'and', 'string']

extract with and condition

arr = [1, 2, 3, 'and', 'string', :str]
arr.extend WrapIt::ArgumentsArray
arr.extract(String, and: [/^str/]) #=> ['string']
arr                                #=> [1, 2, 3, 'and', :str]

Parameters:

  • condition (Object) —

    one of or-ed conditions for comparing

  • options (Hash) —

    options for axtracting

Yields:

  • (element) —

    Gives each element of array to block. You should return true to extract this element or false to keep it in array.

Yield Parameters:

  • element (Object) —

    element of array to inspect

Yield Returns:

  • (Boolean) —

    whether exclude this element or not

Returns:

  • (Array) —

    array of extracted elements



88
89
90
91
92
93
94
 
# File 'lib/wrap_it/arguments_array.rb', line 88

def extract!(*args, &block)
  extracted = []
  reject! do |arg|
    do_compare(arg, *args, &block) && extracted << arg && true
  end
  extracted
end

#extract_first!(*args, &block) ⇒ Object

Extracts first element from array that is satisfy conditions, passed in arguments and returns these element.

See Also:



101
102
103
104
 
# File 'lib/wrap_it/arguments_array.rb', line 101

def extract_first!(*args, &block)
  index = find_index { |arg| do_compare(arg, *args, &block) }
  index.nil? ? nil : delete_at(index)
end