rubocop 1.42.0 → 1.45.1

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

@@ -218,11 +218,9 @@ module RuboCop
         VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
         LINE_LENGTH = 'Layout/LineLength'
-        INDENTATION_WIDTH = 'Layout/IndentationWidth'
         ENABLED = 'Enabled'
         MAX = 'Max'
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'
-        WIDTH = 'Width'
 
         # The shovel operator `<<` does not have its own type. It is a `send`
         # type.
@@ -428,10 +426,6 @@ module RuboCop
           config.for_cop(LINE_LENGTH)[MAX]
         end
 
-        def indentation_width
-          config.for_cop(INDENTATION_WIDTH)[WIDTH] || 2
-        end
-
         def single_line_conditions_only?
           cop_config[SINGLE_LINE_CONDITIONS_ONLY]
         end

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

@@ -145,7 +145,7 @@ module RuboCop
         end
 
         def compact_namespace?(node)
-          /::/.match?(node.loc.name.source)
+          node.loc.name.source.include?('::')
         end
 
         # First checks if the :nodoc: comment is associated with the

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

@@ -7,6 +7,10 @@ module RuboCop
       # It can optionally be configured to also require documentation for
       # non-public methods.
       #
+      # NOTE: This cop allows `initialize` method because `initialize` is
+      # a special method called from `new`. In some programming languages
+      # they are called constructor to distinguish it from method.
+      #
       # @example
       #
       #   # bad
@@ -103,6 +107,8 @@ module RuboCop
         PATTERN
 
         def on_def(node)
+          return if node.method?(:initialize)
+
           parent = node.parent
           module_function_node?(parent) ? check(parent) : check(node)
         end

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

@@ -118,11 +118,23 @@ module RuboCop
         end
 
         def allowed_receiver?(receiver)
-          receiver_name = receiver.send_type? ? receiver.method_name.to_s : receiver.source
+          receiver_name = receiver_name(receiver)
 
           allowed_receivers.include?(receiver_name)
         end
 
+        def receiver_name(receiver)
+          if receiver.send_type?
+            if receiver.receiver
+              "#{receiver_name(receiver.receiver)}.#{receiver.method_name}"
+            else
+              receiver.method_name.to_s
+            end
+          else
+            receiver.source
+          end
+        end
+
         def allowed_receivers
           cop_config.fetch('AllowedReceivers', [])
         end

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

@@ -254,6 +254,7 @@ module RuboCop
           op = pair_node.loc.operator
 
           key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
+          key_with_hash_rocket += pair_node.key.source if pair_node.value_omission?
           corrector.replace(pair_node.key, key_with_hash_rocket)
           corrector.remove(range_with_surrounding_space(op))
         end

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

@@ -21,6 +21,7 @@ module RuboCop
       #     work
       #   end
       class InfiniteLoop < Base
+        include Alignment
         extend AutoCorrector
 
         LEADING_SPACE = /\A(\s*)/.freeze
@@ -106,7 +107,7 @@ module RuboCop
           else
             indentation = body.source_range.source_line[LEADING_SPACE]
 
-            ['loop do', body.source.gsub(/^/, configured_indent), 'end'].join("\n#{indentation}")
+            ['loop do', body.source.gsub(/^/, indentation(node)), 'end'].join("\n#{indentation}")
           end
         end
 
@@ -120,10 +121,6 @@ module RuboCop
 
           start_range.join(end_range)
         end
-
-        def configured_indent
-          ' ' * config.for_cop('Layout/IndentationWidth')['Width']
-        end
       end
     end
   end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usages of `unless` which can be replaced by `if` with inverted condition.
+      # Code without `unless` is easier to read, but that is subjective, so this cop
+      # is disabled by default.
+      #
+      # Methods that can be inverted should be defined in `InverseMethods`. Note that
+      # the relationship of inverse methods needs to be defined in both directions.
+      # For example,
+      #   InverseMethods:
+      #     :!=: :==
+      #     :even?: :odd?
+      #     :odd?: :even?
+      #
+      #  will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`).
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the method
+      #   and its inverse method are both defined on receiver, and also are
+      #   actually inverse of each other.
+      #
+      # @example
+      #   # bad (simple condition)
+      #   foo unless !bar
+      #   foo unless x != y
+      #   foo unless x >= 10
+      #   foo unless x.even?
+      #
+      #   # good
+      #   foo if bar
+      #   foo if x == y
+      #   foo if x < 10
+      #   foo if x.odd?
+      #
+      #   # bad (complex condition)
+      #   foo unless x != y || x.even?
+      #
+      #   # good
+      #   foo if x == y && x.odd?
+      #
+      #   # good (if)
+      #   foo if !condition
+      #
+      class InvertibleUnlessCondition < Base
+        extend AutoCorrector
+
+        MSG = 'Favor `if` with inverted condition over `unless`.'
+
+        def on_if(node)
+          return unless node.unless?
+
+          condition = node.condition
+          return unless invertible?(condition)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node.loc.keyword, node.inverse_keyword)
+            autocorrect(corrector, condition)
+          end
+        end
+
+        private
+
+        def invertible?(node)
+          case node.type
+          when :begin
+            invertible?(node.children.first)
+          when :send
+            return if inheritance_check?(node)
+
+            node.method?(:!) || inverse_methods.key?(node.method_name)
+          when :or, :and
+            invertible?(node.lhs) && invertible?(node.rhs)
+          else
+            false
+          end
+        end
+
+        def inheritance_check?(node)
+          argument = node.first_argument
+          node.method?(:<) &&
+            (argument.const_type? && argument.short_name.to_s.upcase != argument.short_name.to_s)
+        end
+
+        def autocorrect(corrector, node)
+          case node.type
+          when :begin
+            autocorrect(corrector, node.children.first)
+          when :send
+            autocorrect_send_node(corrector, node)
+          when :or, :and
+            corrector.replace(node.loc.operator, node.inverse_operator)
+            autocorrect(corrector, node.lhs)
+            autocorrect(corrector, node.rhs)
+          end
+        end
+
+        def autocorrect_send_node(corrector, node)
+          if node.method?(:!)
+            corrector.remove(node.loc.selector)
+          else
+            corrector.replace(node.loc.selector, inverse_methods[node.method_name])
+          end
+        end
+
+        def inverse_methods
+          @inverse_methods ||= cop_config['InverseMethods']
+        end
+      end
+    end
+  end
+end

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

@@ -13,8 +13,7 @@ module RuboCop
 
           private
 
-          # rubocop:disable Metrics/PerceivedComplexity
-          def omit_parentheses(node)
+          def omit_parentheses(node) # rubocop:disable Metrics/PerceivedComplexity
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
             return if require_parentheses_for_hash_value_omission?(node)
@@ -28,7 +27,6 @@ module RuboCop
               autocorrect(corrector, node)
             end
           end
-          # rubocop:enable Metrics/PerceivedComplexity
 
           def autocorrect(corrector, node)
             if parentheses_at_the_end_of_multiline_call?(node)
@@ -90,7 +88,7 @@ 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) ||
               call_with_ambiguous_arguments?(node) ||
               call_in_logical_operators?(node) ||
@@ -98,24 +96,28 @@ module RuboCop
               call_in_single_line_inheritance?(node) ||
               allowed_multiline_call_with_parentheses?(node) ||
               allowed_chained_call_with_parentheses?(node) ||
-              assignment_in_condition?(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&.block_type? ? node.parent.parent : node.parent
+            return unless parent
+
+            parent.pair_type? ||
+              parent.array_type? ||
+              parent.range_type? ||
+              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) ||
+            return unless parent
+
+            logical_operator?(parent) ||
               (parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) }))
+              parent.arguments.any? { |argument| logical_operator?(argument) })
           end
 
           def call_in_optional_arguments?(node)
@@ -213,6 +215,13 @@ module RuboCop
 
             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.first&.forwarded_kwrestarg_type?
+          end
         end
         # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity
       end

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

@@ -62,6 +62,8 @@ module RuboCop
         end
 
         def same_name_assignment?(node)
+          return false if node.receiver
+
           any_assignment?(node) do |asgn_node|
             next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?
 

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

@@ -36,6 +36,7 @@ module RuboCop
       #
       class MinMaxComparison < Base
         extend AutoCorrector
+        include RangeHelp
 
         MSG = 'Use `%<prefer>s` instead.'
         GRATER_OPERATORS = %i[> >=].freeze
@@ -54,7 +55,7 @@ module RuboCop
           replacement = "[#{lhs.source}, #{rhs.source}].#{preferred_method}"
 
           add_offense(node, message: format(MSG, prefer: replacement)) do |corrector|
-            corrector.replace(node, replacement)
+            autocorrect(corrector, node, replacement)
           end
         end
 
@@ -67,6 +68,15 @@ module RuboCop
             LESS_OPERATORS.include?(operator) ? 'max' : 'min'
           end
         end
+
+        def autocorrect(corrector, node, replacement)
+          if node.elsif?
+            corrector.remove(range_between(node.parent.loc.else.begin_pos, node.loc.else.begin_pos))
+            corrector.replace(node.else_branch, replacement)
+          else
+            corrector.replace(node, replacement)
+          end
+        end
       end
     end
   end

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

@@ -99,6 +99,7 @@ module RuboCop
       class MissingElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = '`%<type>s` condition requires an `else`-clause.'
         MSG_NIL = '`%<type>s` condition requires an `else`-clause with `nil` in it.'
@@ -126,7 +127,9 @@ module RuboCop
         def check(node)
           return if node.else?
 
-          add_offense(node, message: format(message_template, type: node.type))
+          add_offense(node, message: format(message_template, type: node.type)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def message_template
@@ -140,6 +143,15 @@ module RuboCop
           end
         end
 
+        def autocorrect(corrector, node)
+          case empty_else_style
+          when :empty
+            corrector.insert_before(node.loc.end, 'else; nil; ')
+          when :nil
+            corrector.insert_before(node.loc.end, 'else; ')
+          end
+        end
+
         def if_style?
           style == :if
         end

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

@@ -40,10 +40,6 @@ module RuboCop
           [condition, indented_body, indented_end].join("\n")
         end
 
-        def configured_indentation_width
-          super || 2
-        end
-
         def indented_body(body, node)
           body_source = "#{offset(node)}#{body.source}"
           body_source.each_line.map do |line|

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

@@ -31,6 +31,7 @@ module RuboCop
       #     baz
       #   )
       class MultilineMemoization < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
@@ -75,11 +76,10 @@ module RuboCop
         end
 
         def keyword_begin_str(node, node_buf)
-          indent = config.for_cop('Layout/IndentationWidth')['Width'] || 2
           if node_buf.source[node.loc.begin.end_pos] == "\n"
             'begin'
           else
-            "begin\n#{' ' * (node.loc.column + indent)}"
+            "begin\n#{' ' * (node.loc.column + configured_indentation_width)}"
           end
         end
 

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

@@ -34,6 +34,7 @@ module RuboCop
       #   return cond ? b : c
       #
       class MultilineTernaryOperator < Base
+        include CommentsHelp
         extend AutoCorrector
 
         MSG_IF = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
@@ -46,9 +47,7 @@ module RuboCop
           message = enforce_single_line_ternary_operator?(node) ? MSG_SINGLE_LINE : MSG_IF
 
           add_offense(node, message: message) do |corrector|
-            next unless offense?(node)
-
-            corrector.replace(node, replacement(node))
+            autocorrect(corrector, node)
           end
         end
 
@@ -58,6 +57,16 @@ module RuboCop
           node.ternary? && node.multiline?
         end
 
+        def autocorrect(corrector, node)
+          return unless offense?(node)
+
+          corrector.replace(node, replacement(node))
+          return unless (parent = node.parent)
+          return unless (comments_in_condition = comments_in_condition(node))
+
+          corrector.insert_before(parent, comments_in_condition)
+        end
+
         def replacement(node)
           if enforce_single_line_ternary_operator?(node)
             "#{node.condition.source} ? #{node.if_branch.source} : #{node.else_branch.source}"
@@ -72,6 +81,12 @@ module RuboCop
           end
         end
 
+        def comments_in_condition(node)
+          comments_in_range(node).map do |comment|
+            "#{comment.loc.expression.source}\n"
+          end.join
+        end
+
         def enforce_single_line_ternary_operator?(node)
           SINGLE_LINE_TYPES.include?(node.parent&.type) && !use_assignment_method?(node.parent)
         end

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

@@ -103,11 +103,7 @@ module RuboCop
           if node.if_branch.nil?
             corrector.remove(range_by_whole_lines(node.loc.else, include_final_newline: true))
           else
-            if_range = if_range(node)
-            else_range = else_range(node)
-
-            corrector.replace(if_range, else_range.source)
-            corrector.replace(else_range, if_range.source)
+            corrector.swap(if_range(node), else_range(node))
           end
         end
 

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

@@ -12,10 +12,11 @@ module RuboCop
       #
       # @example Max: 1 (default)
       #   # bad
-      #   foo { _1.call(_2, _3, _4) }
+      #   use_multiple_numbered_parameters { _1.call(_2, _3, _4) }
       #
       #   # good
-      #   foo { do_something(_1) }
+      #   array.each { use_array_element_as_numbered_parameter(_1) }
+      #   hash.each { use_only_hash_value_as_numbered_parameter(_2) }
       class NumberedParametersLimit < Base
         extend TargetRubyVersion
         extend ExcludeLimit
@@ -26,9 +27,10 @@ module RuboCop
         exclude_limit 'Max'
 
         MSG = 'Avoid using more than %<max>i numbered %<parameter>s; %<count>i detected.'
+        NUMBERED_PARAMETER_PATTERN = /\A_[1-9]\z/.freeze
 
         def on_numblock(node)
-          _send_node, param_count, * = *node
+          param_count = numbered_parameter_nodes(node).uniq.count
           return if param_count <= max_count
 
           parameter = max_count > 1 ? 'parameters' : 'parameter'
@@ -38,6 +40,12 @@ module RuboCop
 
         private
 
+        def numbered_parameter_nodes(node)
+          node.each_descendant(:lvar).select do |lvar_node|
+            lvar_node.source.match?(NUMBERED_PARAMETER_PATTERN)
+          end
+        end
+
         def max_count
           max = cop_config.fetch('Max', DEFAULT_MAX_VALUE)
 

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

@@ -31,6 +31,7 @@ module RuboCop
       #     baz
       #   end
       class OneLineConditional < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         include OnNormalIfUnless
         extend AutoCorrector
@@ -57,7 +58,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           if always_multiline? || cannot_replace_to_ternary?(node)
-            IfThenCorrector.new(node, indentation: indentation_width).call(corrector)
+            IfThenCorrector.new(node, indentation: configured_indentation_width).call(corrector)
           else
             corrector.replace(node, ternary_correction(node))
           end
@@ -67,7 +68,7 @@ module RuboCop
           replaced_node = ternary_replacement(node)
 
           return replaced_node unless node.parent
-          return "(#{replaced_node})" if %i[and or].include?(node.parent.type)
+          return "(#{replaced_node})" if node.parent.operator_keyword?
           return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
 
           replaced_node
@@ -116,10 +117,6 @@ module RuboCop
 
           node.respond_to?(:arguments?) && node.arguments? && !node.parenthesized_call?
         end
-
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width']
-        end
       end
     end
   end

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

@@ -25,10 +25,10 @@ module RuboCop
 
         def on_send(node)
           return unless (dot = node.loc.dot)
-          return if node.receiver.const_type?
+          return if node.receiver.const_type? || !node.arguments.one?
 
           _lhs, _op, rhs = *node
-          return if rhs.nil? || rhs.children.first
+          return if !rhs || method_call_with_parenthesized_arg?(rhs) || anonymous_forwarding?(rhs)
 
           add_offense(dot) do |corrector|
             wrap_in_parentheses_if_chained(corrector, node)
@@ -38,6 +38,20 @@ module RuboCop
 
         private
 
+        # Checks for an acceptable case of `foo.+(bar).baz`.
+        def method_call_with_parenthesized_arg?(argument)
+          return false unless argument.parent.parent&.send_type?
+
+          argument.children.first && argument.parent.parenthesized?
+        end
+
+        def anonymous_forwarding?(argument)
+          return true if argument.forwarded_args_type? || argument.forwarded_restarg_type?
+          return true if argument.hash_type? && argument.children.first&.forwarded_kwrestarg_type?
+
+          argument.block_pass_type? && argument.source == '&'
+        end
+
         def wrap_in_parentheses_if_chained(corrector, node)
           return unless node.parent&.call_type?
 

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

@@ -172,7 +172,9 @@ module RuboCop
         end
 
         def modifier_statement?(node)
-          node && %i[if while until].include?(node.type) && node.modifier_form?
+          return false unless node
+
+          node.basic_conditional? && node.modifier_form?
         end
 
         # An internal class for correcting parallel assignment

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

@@ -36,6 +36,9 @@ module RuboCop
 
         MSG = 'Use double pipes `||` instead.'
         REDUNDANT_CONDITION = 'This condition is not needed.'
+        ARGUMENT_WITH_OPERATOR_TYPES = %i[
+          splat block_pass forwarded_restarg forwarded_kwrestarg forwarded_args
+        ].freeze
 
         def on_if(node)
           return if node.elsif_conditional?
@@ -150,13 +153,25 @@ module RuboCop
         end
 
         def single_argument_method?(node)
-          node.send_type? && !node.method?(:[]) && node.arguments.one?
+          return false if !node.send_type? || node.method?(:[]) || !node.arguments.one?
+
+          !argument_with_operator?(node.first_argument)
         end
 
         def same_method?(if_branch, else_branch)
           if_branch.method?(else_branch.method_name) && if_branch.receiver == else_branch.receiver
         end
 
+        # If the argument is using an operator, it is an invalid syntax.
+        # e.g. `foo || *bar`, `foo || **bar`, and `foo || &bar`.
+        def argument_with_operator?(argument)
+          return true if ARGUMENT_WITH_OPERATOR_TYPES.include?(argument.type)
+          return false unless argument.hash_type?
+          return false unless (node = argument.children.first)
+
+          node.kwsplat_type? || node.forwarded_kwrestarg_type?
+        end
+
         def if_source(if_branch, arithmetic_operation)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')

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

@@ -86,10 +86,6 @@ module RuboCop
         def indented_else_node(expression, node)
           "else\n#{indentation(node)}#{expression}"
         end
-
-        def configured_indentation_width
-          super || 2
-        end
       end
     end
   end