rubocop 0.93.1 → 1.79.2

data/lib/rubocop/cop/style/map_into_array.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # 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:
+      # * a local variable initialized as an empty array and referred to only by the
+      # pushing operation;
+      # * or, if it is the single block argument to a `[].tap` block.
+      # 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
+      #
+      class MapIntoArray < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<new_method_name>s` instead of `each` to map elements into an array.'
+
+        # @!method suitable_argument_node?(node)
+        def_node_matcher :suitable_argument_node?, <<-PATTERN
+          !{splat forwarded-restarg forwarded-args (hash (forwarded-kwrestarg)) (block-pass nil?)}
+        PATTERN
+
+        # @!method each_block_with_push?(node)
+        def_node_matcher :each_block_with_push?, <<-PATTERN
+          [
+            ^({begin kwbegin block} ...)
+            (any_block (send !{nil? self} :each) _
+              (send (lvar _) {:<< :push :append} #suitable_argument_node?))
+          ]
+        PATTERN
+
+        # @!method empty_array_asgn?(node)
+        def_node_matcher :empty_array_asgn?, <<~PATTERN
+          (
+            lvasgn _ {
+              (array)
+              (send (const {nil? cbase} :Array) :[])
+              (send (const {nil? cbase} :Array) :new (array)?)
+              (send nil? :Array (array))
+            }
+          )
+        PATTERN
+
+        # @!method empty_array_tap(node)
+        def_node_matcher :empty_array_tap, <<~PATTERN
+          ^^$(
+            block
+              (send (array) :tap)
+              (args (arg _))
+              ...
+          )
+        PATTERN
+
+        # @!method lvar_ref?(node, name)
+        def_node_matcher :lvar_ref?, '(lvar %1)'
+
+        def self.joining_forces
+          VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          (@scopes ||= []) << scope
+        end
+
+        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
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        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
+
+        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
+
+        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
+
+        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
+
+        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
+
+        def new_method_name
+          default = 'map'
+          alternative = config.for_cop('Style/CollectionMethods').dig('PreferredMethods', default)
+          alternative || default
+        end
+
+        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
+
+        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
+
+        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
+
+        def correct_push_node(corrector, push_node)
+          arg_node = push_node.first_argument
+          range = push_node.source_range
+          arg_range = arg_node.source_range
+
+          corrector.wrap(arg_node, '{ ', ' }') if arg_node.hash_type? && !arg_node.braces?
+          corrector.remove(range_between(range.begin_pos, arg_range.begin_pos))
+          corrector.remove(range_between(arg_range.end_pos, range.end_pos))
+        end
+
+        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
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/map_to_hash.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for uses of `map.to_h` or `collect.to_h` that could be
+      # written with just `to_h` in Ruby >= 2.6.
+      #
+      # NOTE: `Style/HashTransformKeys` and `Style/HashTransformValues` will
+      # also change this pattern if only hash keys or hash values are being
+      # transformed.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Enumerable`.
+      #
+      # @example
+      #   # bad
+      #   something.map { |v| [v, v * 2] }.to_h
+      #
+      #   # good
+      #   something.to_h { |v| [v, v * 2] }
+      #
+      #   # bad
+      #   {foo: bar}.collect { |k, v| [k.to_s, v.do_something] }.to_h
+      #
+      #   # good
+      #   {foo: bar}.to_h { |k, v| [k.to_s, v.do_something] }
+      #
+      class MapToHash < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Pass a block to `to_h` instead of calling `%<method>s%<dot>sto_h`.'
+        RESTRICT_ON_SEND = %i[to_h].freeze
+
+        # @!method map_to_h(node)
+        def_node_matcher :map_to_h, <<~PATTERN
+          {
+            $(call (any_block $(call _ {:map :collect}) ...) :to_h)
+            $(call $(call _ {:map :collect} (block_pass sym)) :to_h)
+          }
+        PATTERN
+
+        # @!method destructuring_argument(node)
+        def_node_matcher :destructuring_argument, <<~PATTERN
+          (args $(mlhs (arg _)+))
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [Layout::SingleLineBlockChain]
+        end
+
+        def on_send(node)
+          return unless (to_h_node, map_node = map_to_h(node))
+          return if to_h_node.block_literal?
+
+          message = format(MSG, method: map_node.loc.selector.source, dot: to_h_node.loc.dot.source)
+          add_offense(map_node.loc.selector, message: message) do |corrector|
+            autocorrect(corrector, to_h_node, map_node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, to_h, map)
+          removal_range = range_between(to_h.loc.dot.begin_pos, to_h.loc.selector.end_pos)
+
+          corrector.remove(range_with_surrounding_space(removal_range, side: :left))
+          if (map_dot = map.loc.dot)
+            corrector.replace(map_dot, to_h.loc.dot.source)
+          end
+          corrector.replace(map.loc.selector, 'to_h')
+
+          return unless map.parent.block_type?
+
+          if (argument = destructuring_argument(map.parent.arguments))
+            corrector.replace(argument, argument.source[1..-2])
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/map_to_set.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for uses of `map.to_set` or `collect.to_set` that could be
+      # written with just `to_set`.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Enumerable`.
+      #
+      # @example
+      #   # bad
+      #   something.map { |i| i * 2 }.to_set
+      #
+      #   # good
+      #   something.to_set { |i| i * 2 }
+      #
+      #   # bad
+      #   [1, 2, 3].collect { |i| i.to_s }.to_set
+      #
+      #   # good
+      #   [1, 2, 3].to_set { |i| i.to_s }
+      #
+      class MapToSet < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Pass a block to `to_set` instead of calling `%<method>s.to_set`.'
+        RESTRICT_ON_SEND = %i[to_set].freeze
+
+        # @!method map_to_set?(node)
+        def_node_matcher :map_to_set?, <<~PATTERN
+          {
+            $(call (any_block $(call _ {:map :collect}) ...) :to_set)
+            $(call $(call _ {:map :collect} (block_pass sym)) :to_set)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (to_set_node, map_node = map_to_set?(node))
+          return if to_set_node.block_literal?
+
+          message = format(MSG, method: map_node.loc.selector.source)
+          add_offense(map_node.loc.selector, message: message) do |corrector|
+            autocorrect(corrector, to_set_node, map_node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def autocorrect(corrector, to_set, map)
+          removal_range = range_between(to_set.loc.dot.begin_pos, to_set.loc.selector.end_pos)
+
+          corrector.remove(range_with_surrounding_space(removal_range, side: :left))
+          corrector.replace(map.loc.selector, 'to_set')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -5,37 +5,72 @@ module RuboCop
     module Style
       class MethodCallWithArgsParentheses
         # Style omit_parentheses
+        # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
         module OmitParentheses
+          include RangeHelp
+
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
+          OMIT_MSG = 'Omit parentheses for method calls with arguments.'
+          private_constant :OMIT_MSG
+
+          private
 
-          def on_send(node)
+          def omit_parentheses(node) # rubocop:disable Metrics/PerceivedComplexity
             return unless node.parenthesized?
-            return if node.implicit_call?
+            return if inside_endless_method_def?(node)
+            return if require_parentheses_for_hash_value_omission?(node)
+            return if syntax_like_method_call?(node)
+            return if method_call_before_constant_resolution?(node)
             return if super_call_without_arguments?(node)
-            return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
+            return if allowed_camel_case_method_call?(node)
+            return if allowed_string_interpolation_method_call?(node)
 
-            add_offense(offense_range(node)) do |corrector|
-              if parentheses_at_the_end_of_multiline_call?(node)
-                corrector.replace(args_begin(node), ' \\')
-              else
-                corrector.replace(args_begin(node), ' ')
-              end
-              corrector.remove(node.loc.end)
+            add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
+              autocorrect(corrector, node)
             end
           end
-          alias on_csend on_send
-          alias on_super on_send
-          alias on_yield on_send
 
-          private
+          def autocorrect(corrector, node)
+            range = args_begin(node)
+            if parentheses_at_the_end_of_multiline_call?(node)
+              # Whitespace after line continuation (`\ `) is a syntax error
+              with_whitespace = range_with_surrounding_space(range, side: :right, newlines: false)
+              corrector.replace(with_whitespace, ' \\')
+            else
+              corrector.replace(range, ' ')
+            end
+            corrector.remove(node.loc.end)
+          end
 
           def offense_range(node)
             node.loc.begin.join(node.loc.end)
           end
 
-          def message(_range = nil)
-            'Omit parentheses for method calls with arguments.'
+          def inside_endless_method_def?(node)
+            # parens are required around arguments inside an endless method
+            node.each_ancestor(:any_def).any?(&:endless?) && node.arguments.any?
+          end
+
+          def require_parentheses_for_hash_value_omission?(node) # rubocop:disable Metrics/PerceivedComplexity
+            return false unless (last_argument = node.last_argument)
+            return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
+
+            node.parent&.conditional? || node.parent&.single_line? || !last_expression?(node)
+          end
+
+          # Require hash value omission be enclosed in parentheses to prevent the following issue:
+          # https://bugs.ruby-lang.org/issues/18396.
+          def last_expression?(node)
+            !(node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling)
+          end
+
+          def syntax_like_method_call?(node)
+            node.implicit_call? || node.operator_method?
+          end
+
+          def method_call_before_constant_resolution?(node)
+            node.parent&.const_type?
           end
 
           def super_call_without_arguments?(node)
@@ -44,8 +79,12 @@ module RuboCop
 
           def allowed_camel_case_method_call?(node)
             node.camel_case_method? &&
-              (node.arguments.none? ||
-              cop_config['AllowParenthesesInCamelCaseMethod'])
+              (node.arguments.none? || cop_config['AllowParenthesesInCamelCaseMethod'])
+          end
+
+          def allowed_string_interpolation_method_call?(node)
+            cop_config['AllowParenthesesInStringInterpolation'] &&
+              inside_string_interpolation?(node)
           end
 
           def parentheses_at_the_end_of_multiline_call?(node)
@@ -55,70 +94,96 @@ module RuboCop
                   .end_with?('(')
           end
 
-          def legitimate_call_with_parentheses?(node)
+          def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
             call_in_literals?(node) ||
+              node.parent&.when_type? ||
               call_with_ambiguous_arguments?(node) ||
               call_in_logical_operators?(node) ||
               call_in_optional_arguments?(node) ||
               call_in_single_line_inheritance?(node) ||
               allowed_multiline_call_with_parentheses?(node) ||
-              allowed_chained_call_with_parentheses?(node)
+              allowed_chained_call_with_parentheses?(node) ||
+              assignment_in_condition?(node) ||
+              forwards_anonymous_rest_arguments?(node)
           end
 
           def call_in_literals?(node)
-            node.parent &&
-              (node.parent.pair_type? ||
-              node.parent.array_type? ||
-              node.parent.range_type? ||
-              splat?(node.parent) ||
-              ternary_if?(node.parent))
+            parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
+            return false unless parent
+
+            parent.type?(:pair, :array, :range) ||
+              splat?(parent) ||
+              ternary_if?(parent)
           end
 
           def call_in_logical_operators?(node)
-            parent = node.parent&.block_type? ? node.parent.parent : node.parent
-            parent &&
-              (logical_operator?(parent) ||
-              parent.send_type? &&
-              parent.arguments.any?(&method(:logical_operator?)))
+            parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
+            return false unless parent
+
+            logical_operator?(parent) ||
+              (parent.send_type? &&
+              parent.arguments.any? { |argument| logical_operator?(argument) })
           end
 
           def call_in_optional_arguments?(node)
-            node.parent &&
-              (node.parent.optarg_type? || node.parent.kwoptarg_type?)
+            node.parent&.type?(:optarg, :kwoptarg)
           end
 
           def call_in_single_line_inheritance?(node)
-            node.parent&.class_type? && node.parent&.single_line?
+            node.parent&.class_type? && node.parent.single_line?
           end
 
+          # rubocop:disable Metrics/PerceivedComplexity
           def call_with_ambiguous_arguments?(node)
             call_with_braced_block?(node) ||
+              call_in_argument_with_block?(node) ||
               call_as_argument_or_chain?(node) ||
+              call_in_match_pattern?(node) ||
               hash_literal_in_arguments?(node) ||
+              ambiguous_range_argument?(node) ||
               node.descendants.any? do |n|
-                ambigious_literal?(n) || logical_operator?(n) ||
-                  call_with_braced_block?(n)
+                n.type?(:forwarded_args, :any_block) ||
+                  ambiguous_literal?(n) || logical_operator?(n)
               end
           end
+          # rubocop:enable Metrics/PerceivedComplexity
 
           def call_with_braced_block?(node)
-            (node.send_type? || node.super_type?) &&
-              node.block_node && node.block_node.braces?
+            node.type?(:call, :super) && node.block_node&.braces?
+          end
+
+          def call_in_argument_with_block?(node)
+            parent = node.parent&.any_block_type? && node.parent.parent
+            return false unless parent
+
+            parent.type?(:call, :super, :yield)
           end
 
           def call_as_argument_or_chain?(node)
-            node.parent &&
-              (node.parent.send_type? && !assigned_before?(node.parent, node) ||
-              node.parent.csend_type? || node.parent.super_type?)
+            node.parent&.type?(:call, :super, :yield) &&
+              !assigned_before?(node.parent, node)
+          end
+
+          def call_in_match_pattern?(node)
+            return false unless (parent = node.parent)
+
+            parent.any_match_pattern_type?
           end
 
           def hash_literal_in_arguments?(node)
             node.arguments.any? do |n|
               hash_literal?(n) ||
-                n.send_type? && node.descendants.any?(&method(:hash_literal?))
+                (n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) })
             end
           end
 
+          def ambiguous_range_argument?(node)
+            return true if (first_arg = node.first_argument)&.range_type? && first_arg.begin.nil?
+            return true if (last_arg = node.last_argument)&.range_type? && last_arg.end.nil?
+
+            false
+          end
+
           def allowed_multiline_call_with_parentheses?(node)
             cop_config['AllowParenthesesInMultilineCall'] && node.multiline?
           end
@@ -129,17 +194,15 @@ module RuboCop
             previous = node.descendants.first
             return false unless previous&.send_type?
 
-            previous.parenthesized? ||
-              allowed_chained_call_with_parentheses?(previous)
+            previous.parenthesized? || allowed_chained_call_with_parentheses?(previous)
           end
 
-          def ambigious_literal?(node)
-            splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) ||
-              unary_literal?(node)
+          def ambiguous_literal?(node)
+            splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) || unary_literal?(node)
           end
 
           def splat?(node)
-            node.splat_type? || node.kwsplat_type? || node.block_pass_type?
+            node.type?(:splat, :kwsplat, :block_pass)
           end
 
           def ternary_if?(node)
@@ -147,7 +210,7 @@ module RuboCop
           end
 
           def logical_operator?(node)
-            (node.and_type? || node.or_type?) && node.logical_operator?
+            node.operator_keyword? && node.logical_operator?
           end
 
           def hash_literal?(node)
@@ -159,15 +222,37 @@ module RuboCop
           end
 
           def unary_literal?(node)
-            node.numeric_type? && node.sign? ||
-              node.parent&.send_type? && node.parent&.unary_operation?
+            return true if node.numeric_type? && node.sign?
+
+            node.parent&.send_type? && node.parent.unary_operation?
           end
 
           def assigned_before?(node, target)
-            node.assignment? &&
-              node.loc.operator.begin < target.loc.begin
+            node.assignment? && node.loc.operator.begin < target.loc.begin
+          end
+
+          def inside_string_interpolation?(node)
+            node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
+          end
+
+          def assignment_in_condition?(node)
+            parent = node.parent
+            return false unless parent
+
+            grandparent = parent.parent
+            return false unless grandparent
+
+            parent.assignment? && (grandparent.conditional? || grandparent.when_type?)
+          end
+
+          def forwards_anonymous_rest_arguments?(node)
+            return false unless (last_argument = node.last_argument)
+            return true if last_argument.forwarded_restarg_type?
+
+            last_argument.hash_type? && last_argument.children.any?(&:forwarded_kwrestarg_type?)
           end
         end
+        # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity
       end
     end
   end