class RuboCop::Cop::Style::MapIntoArray

Checks for usages of ‘each` with `<<`, `push`, or `append` which can be replaced by `map`.

If ‘PreferredMethods` is configured for `map` in `Style/CollectionMethods`, this cop uses the specified method for replacement.

NOTE: The return value of ‘Enumerable#each` is `self`, whereas the return value of `Enumerable#map` is an `Array`. They are not autocorrected when a return value could be used because these types differ.

NOTE: It only detects when the mapping destination is either:

pushing operation;

This is because, if not, it’s challenging to statically guarantee that the mapping destination variable remains an empty array:

source,ruby

ret = [] src.each { |e| ret << e * 2 } # ‘<<` method may mutate `ret`

dest = [] src.each { |e| dest << transform(e, dest) } # ‘transform` method may mutate `dest`


@safety

This cop is unsafe because not all objects that have an `each`
method also have a `map` method (e.g. `ENV`). Additionally, for calls
with a block, not all objects that have a `map` method return an array
(e.g. `Enumerator::Lazy`).

@example

# bad
dest = []
src.each { |e| dest << e * 2 }
dest

# good
dest = src.map { |e| e * 2 }

# bad
[].tap do |dest|
  src.each { |e| dest << e * 2 }
end

# good
dest = src.map { |e| e * 2 }

# good - contains another operation
dest = []
src.each { |e| dest << e * 2; puts e }
dest

Constants

MSG

Public Class Methods

joining_forces() click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 105
def self.joining_forces
  VariableForce
end

Public Instance Methods

after_leaving_scope(scope, _variable_table) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 109
def after_leaving_scope(scope, _variable_table)
  (@scopes ||= []) << scope
end
on_block(node) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 113
def on_block(node)
  return unless each_block_with_push?(node)

  dest_var = find_dest_var(node)

  if offending_empty_array_tap?(node, dest_var)
    asgn = dest_var.declaration_node
  else
    return unless (asgn = find_closest_assignment(node, dest_var))
    return unless empty_array_asgn?(asgn)
    return unless dest_used_only_for_mapping?(node, dest_var, asgn)
  end

  register_offense(node, dest_var, asgn)
end
Also aliased as: on_numblock
on_numblock(node)
Alias for: on_block

Private Instance Methods

correct_push_node(corrector, push_node) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 213
def correct_push_node(corrector, push_node)
  range = push_node.source_range
  arg_range = push_node.first_argument.source_range

  corrector.remove(range_between(range.begin_pos, arg_range.begin_pos))
  corrector.remove(range_between(arg_range.end_pos, range.end_pos))
end
correct_return_value_handling(corrector, block, dest_var) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 221
def correct_return_value_handling(corrector, block, dest_var)
  next_node = block.right_sibling

  if lvar_ref?(next_node, dest_var.name)
    corrector.remove(range_with_surrounding_space(next_node.source_range, side: :left))
  end

  corrector.insert_before(block, "#{dest_var.name} = ")
end
dest_used_only_for_mapping?(block, dest_var, asgn) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 156
def dest_used_only_for_mapping?(block, dest_var, asgn)
  range = asgn.source_range.join(block.source_range)

  asgn.parent.equal?(block.parent) &&
    dest_var.references.one? { |r| range.contains?(r.node.source_range) } &&
    dest_var.assignments.one? { |a| range.contains?(a.node.source_range) }
end
find_closest_assignment(block, dest_var) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 150
def find_closest_assignment(block, dest_var)
  dest_var.assignments.reverse_each.lazy.map(&:node).find do |node|
    node.source_range.end_pos < block.source_range.begin_pos
  end
end
find_dest_var(block) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 133
def find_dest_var(block)
  node = block.body.receiver
  name = node.children.first

  candidates = @scopes.lazy.filter_map { |s| s.variables[name] }
  candidates.find { |v| v.references.any? { |n| n.node.equal?(node) } }
end
new_method_name() click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 181
def new_method_name
  default = 'map'
  alternative = config.for_cop('Style/CollectionMethods').dig('PreferredMethods', default)
  alternative || default
end
offending_empty_array_tap?(node, dest_var) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 141
def offending_empty_array_tap?(node, dest_var)
  return false unless (tap_block_node = empty_array_tap(dest_var.declaration_node))

  # A `tap` block only offends if the array push is the only thing in it;
  # otherwise we cannot guarantee that the block variable is still an empty
  # array when pushed to.
  tap_block_node.body == node
end
register_offense(block, dest_var, asgn) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 164
def register_offense(block, dest_var, asgn)
  add_offense(block, message: format(MSG, new_method_name: new_method_name)) do |corrector|
    next if return_value_used?(block)

    corrector.replace(block.send_node.selector, new_method_name)

    if (tap_block_node = empty_array_tap(dest_var.declaration_node))
      remove_tap(corrector, block, tap_block_node)
    else
      remove_assignment(corrector, asgn)
    end

    correct_push_node(corrector, block.body)
    correct_return_value_handling(corrector, block, dest_var)
  end
end
remove_assignment(corrector, asgn) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 200
def remove_assignment(corrector, asgn)
  range = range_with_surrounding_space(asgn.source_range, side: :right)
  range = range_with_surrounding_space(range, side: :right, newlines: false)

  corrector.remove(range)
end
remove_tap(corrector, node, block_node) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 207
def remove_tap(corrector, node, block_node)
  range = range_between(block_node.source_range.begin_pos, node.source_range.begin_pos)
  corrector.remove(range)
  corrector.remove(range_with_surrounding_space(block_node.loc.end, side: :left))
end
return_value_used?(node) click to toggle source
# File lib/rubocop/cop/style/map_into_array.rb, line 187
def return_value_used?(node)
  parent = node.parent

  case parent&.type
  when nil
    false
  when :begin, :kwbegin
    !node.right_sibling && return_value_used?(parent)
  else
    !parent.respond_to?(:void_context?) || !parent.void_context?
  end
end