rubocop 1.43.0 → 1.50.2

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

@@ -122,8 +122,8 @@ module RuboCop
         end
 
         def safe_to_register_offense?(block, except_key)
-          extracted = extract_body_if_nagated(block.body)
-          if extracted.method?('in?') || extracted.method?('include?') || \
+          extracted = extract_body_if_negated(block.body)
+          if extracted.method?('in?') || extracted.method?('include?') ||
              extracted.method?('exclude?')
             return true
           end
@@ -132,7 +132,7 @@ module RuboCop
           except_key.sym_type? || except_key.str_type?
         end
 
-        def extract_body_if_nagated(body)
+        def extract_body_if_negated(body)
           return body unless body.method?('!')
 
           body.receiver
@@ -161,7 +161,7 @@ module RuboCop
 
         def except_key(node)
           key_argument = node.argument_list.first.source
-          body = extract_body_if_nagated(node.body)
+          body = extract_body_if_negated(node.body)
           lhs, _method_name, rhs = *body
           return if [lhs, rhs].map(&:source).none?(key_argument)
 

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

@@ -37,6 +37,8 @@ module RuboCop
       #   end
       #
       class HashLikeCase < Base
+        include MinBranchesCount
+
         MSG = 'Consider replacing `case-when` with a hash lookup.'
 
         # @!method hash_like_case?(node)
@@ -49,7 +51,7 @@ module RuboCop
         PATTERN
 
         def on_case(node)
-          return if node.when_branches.size < min_branches_count
+          return unless min_branches_count?(node)
 
           hash_like_case?(node) do |condition_nodes, body_nodes|
             if nodes_of_same_type?(condition_nodes) && nodes_of_same_type?(body_nodes)
@@ -63,14 +65,6 @@ module RuboCop
         def nodes_of_same_type?(nodes)
           nodes.all? { |node| node.type == nodes.first.type }
         end
-
-        def min_branches_count
-          length = cop_config['MinBranchesCount'] || 3
-          return length if length.is_a?(Integer) && length.positive?
-
-          warn Rainbow('`MinBranchesCount` needs to be a positive integer!').red
-          exit!
-        end
       end
     end
   end

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

@@ -88,6 +88,9 @@ module RuboCop
       #   {foo: foo, bar: bar}
       #
       #   # good
+      #   {foo: foo, bar:}
+      #
+      #   # good
       #   {foo:, bar:}
       #
       # @example EnforcedShorthandSyntax: consistent
@@ -207,7 +210,7 @@ module RuboCop
           return true if /\A[_a-z]\w*[?!]?\z/i.match?(sym_name)
 
           # For more complicated hash keys, let the parser validate the syntax.
-          ProcessedSource.new("{ #{sym_name}: :foo }", target_ruby_version).valid_syntax?
+          parse("{ #{sym_name}: :foo }").valid_syntax?
         end
 
         def check(pairs, delim, msg)
@@ -247,7 +250,7 @@ module RuboCop
         end
 
         def argument_without_space?(node)
-          node.argument? && node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
+          node.argument? && node.source_range.begin_pos == node.parent.loc.selector.end_pos
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)

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

@@ -11,6 +11,32 @@ module RuboCop
       # cop. The tab size is configured in the `IndentationWidth` of the
       # `Layout/IndentationStyle` cop.
       #
+      # One-line pattern matching is always allowed. To ensure that there are few cases
+      # where the match variable is not used, and to prevent oversights. The variable `x`
+      # becomes undefined and raises `NameError` when the following example is changed to
+      # the modifier form:
+      #
+      # [source,ruby]
+      # ----
+      # if [42] in [x]
+      #   x # `x` is undefined when using modifier form.
+      # end
+      # ----
+      #
+      # NOTE: It is allowed when `defined?` argument has an undefined value,
+      # because using the modifier form causes the following incompatibility:
+      #
+      # [source,ruby]
+      # ----
+      # unless defined?(undefined_foo)
+      #   undefined_foo = 'default_value'
+      # end
+      # undefined_foo # => 'default_value'
+      #
+      # undefined_bar = 'default_value' unless defined?(undefined_bar)
+      # undefined_bar # => nil
+      # ----
+      #
       # @example
       #   # bad
       #   if condition
@@ -39,6 +65,7 @@ module RuboCop
         include LineLengthHelp
         include AllowedPattern
         include RangeHelp
+        include CommentsHelp
         extend AutoCorrector
 
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
@@ -51,12 +78,10 @@ module RuboCop
         end
 
         def on_if(node)
-          msg = if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
-                  MSG_USE_MODIFIER
-                elsif too_long_due_to_modifier?(node)
-                  MSG_USE_NORMAL
-                end
-          return unless msg
+          condition = node.condition
+          return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
+                    pattern_matching_nodes(condition).any?
+          return unless (msg = message(node))
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
             autocorrect(corrector, node)
@@ -65,28 +90,81 @@ module RuboCop
 
         private
 
+        def defined_nodes(condition)
+          if condition.defined_type?
+            [condition]
+          else
+            condition.each_descendant.select(&:defined_type?)
+          end
+        end
+
+        def defined_argument_is_undefined?(if_node, defined_node)
+          defined_argument = defined_node.first_argument
+          return false unless defined_argument.lvar_type? || defined_argument.send_type?
+
+          if_node.left_siblings.none? do |sibling|
+            sibling.respond_to?(:lvasgn_type?) && sibling.lvasgn_type? &&
+              sibling.name == defined_argument.node_parts[0]
+          end
+        end
+
+        def pattern_matching_nodes(condition)
+          if condition.match_pattern_type? || condition.match_pattern_p_type?
+            [condition]
+          else
+            condition.each_descendant.select do |node|
+              node.match_pattern_type? || node.match_pattern_p_type?
+            end
+          end
+        end
+
+        def message(node)
+          if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
+            MSG_USE_MODIFIER
+          elsif too_long_due_to_modifier?(node)
+            MSG_USE_NORMAL
+          end
+        end
+
         def autocorrect(corrector, node)
           replacement = if node.modifier_form?
-                          last_argument = node.if_branch.last_argument if node.if_branch.send_type?
-
-                          if last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
-                            heredoc = extract_heredoc_from(last_argument)
-                            remove_heredoc(corrector, heredoc)
-                            to_normal_form_with_heredoc(node, indent(node), heredoc)
-                          else
-                            to_normal_form(node, indent(node))
-                          end
+                          replacement_for_modifier_form(corrector, node)
                         else
                           to_modifier_form(node)
                         end
           corrector.replace(node, replacement)
         end
 
+        def replacement_for_modifier_form(corrector, node) # rubocop:disable Metrics/AbcSize
+          comment = comment_on_node_line(node)
+          if comment && too_long_due_to_comment_after_modifier?(node, comment)
+            remove_comment(corrector, node, comment)
+
+            return to_modifier_form_with_move_comment(node, indent(node), comment)
+          end
+
+          last_argument = node.if_branch.last_argument if node.if_branch.send_type?
+          if last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
+            heredoc = extract_heredoc_from(last_argument)
+            remove_heredoc(corrector, heredoc)
+
+            return to_normal_form_with_heredoc(node, indent(node), heredoc)
+          end
+
+          to_normal_form(node, indent(node))
+        end
+
         def too_long_due_to_modifier?(node)
           node.modifier_form? && too_long_single_line?(node) &&
             !another_statement_on_same_line?(node)
         end
 
+        def too_long_due_to_comment_after_modifier?(node, comment)
+          source_length = processed_source.lines[node.first_line - 1].length
+          source_length >= max_line_length &&
+            source_length - comment.source_range.length <= max_line_length
+        end
+
         def allowed_patterns
           line_length_config = config.for_cop('Layout/LineLength')
           line_length_config['AllowedPatterns'] || line_length_config['IgnoredPatterns'] || []
@@ -181,6 +259,13 @@ module RuboCop
           RUBY
         end
 
+        def to_modifier_form_with_move_comment(node, indentation, comment)
+          <<~RUBY.chomp
+            #{comment.source}
+            #{indentation}#{node.body.source} #{node.keyword} #{node.condition.source}
+          RUBY
+        end
+
         def extract_heredoc_from(last_argument)
           heredoc_body = last_argument.loc.heredoc_body
           heredoc_end = last_argument.loc.heredoc_end
@@ -193,6 +278,14 @@ module RuboCop
             corrector.remove(range_by_whole_lines(range, include_final_newline: true))
           end
         end
+
+        def comment_on_node_line(node)
+          processed_source.comments.find { |c| same_line?(c, node) }
+        end
+
+        def remove_comment(corrector, _node, comment)
+          corrector.remove(range_with_surrounding_space(range: comment.source_range, side: :left))
+        end
       end
     end
   end

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

@@ -118,6 +118,8 @@ module RuboCop
         end
 
         def return_boolean_value?(condition)
+          return false unless condition
+
           if condition.begin_type?
             return_boolean_value?(condition.children.first)
           elsif condition.or_type?

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/inverse_methods.rb

@@ -155,15 +155,15 @@ module RuboCop
         end
 
         def not_to_receiver(node, method_call)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
+          Parser::Source::Range.new(node.source_range.source_buffer,
                                     node.loc.selector.begin_pos,
-                                    method_call.loc.expression.begin_pos)
+                                    method_call.source_range.begin_pos)
         end
 
         def end_parentheses(node, method_call)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    method_call.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
+          Parser::Source::Range.new(node.source_range.source_buffer,
+                                    method_call.source_range.end_pos,
+                                    node.source_range.end_pos)
         end
 
         # When comparing classes, `!(Integer < Numeric)` is not the same as

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/map_compact_with_conditional_block.rb

@@ -123,10 +123,10 @@ module RuboCop
         end
 
         def range(node)
-          buffer = node.loc.expression.source_buffer
+          buffer = node.source_range.source_buffer
           map_node = node.receiver.send_node
           begin_pos = map_node.loc.selector.begin_pos
-          end_pos = node.loc.expression.end_pos
+          end_pos = node.source_range.end_pos
 
           Parser::Source::Range.new(buffer, begin_pos, end_pos)
         end

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

@@ -39,7 +39,10 @@ module RuboCop
 
         # @!method map_to_h?(node)
         def_node_matcher :map_to_h?, <<~PATTERN
-          $(send (block $(send _ {:map :collect}) ...) :to_h)
+          {
+            $(send ({block numblock} $(send _ {:map :collect}) ...) :to_h)
+            $(send $(send _ {:map :collect} (block_pass sym)) :to_h)
+          }
         PATTERN
 
         def on_send(node)

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

@@ -32,7 +32,10 @@ module RuboCop
 
         # @!method map_to_set?(node)
         def_node_matcher :map_to_set?, <<~PATTERN
-          $(send (block $(send _ {:map :collect}) ...) :to_set)
+          {
+            $(send ({block numblock} $(send _ {:map :collect}) ...) :to_set)
+            $(send $(send _ {:map :collect} (block_pass sym)) :to_set)
+          }
         PATTERN
 
         def on_send(node)

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)
@@ -52,17 +50,13 @@ module RuboCop
             return false unless (last_argument = node.last_argument)
             return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
 
-            modifier_form?(node) || exist_next_line_expression?(node)
-          end
-
-          def modifier_form?(node)
-            node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+            node.parent&.conditional? || !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 exist_next_line_expression?(node)
-            node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling
+          def last_expression?(node)
+            !(node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling)
           end
 
           def syntax_like_method_call?(node)
@@ -90,7 +84,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,7 +92,8 @@ 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)
@@ -216,6 +211,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_with_args_parentheses.rb

@@ -7,21 +7,19 @@ module RuboCop
       # method calls containing parameters.
       #
       # In the default style (require_parentheses), macro methods are allowed.
-      # Additional methods can be added to the `AllowedMethods`
-      # or `AllowedPatterns` list. These options are
-      # valid only in the default style. Macros can be included by
-      # either setting `IgnoreMacros` to false or adding specific macros to
-      # the `IncludedMacros` list.
+      # Additional methods can be added to the `AllowedMethods` or
+      # `AllowedPatterns` list. These options are valid only in the default
+      # style. Macros can be included by either setting `IgnoreMacros` to false
+      # or adding specific macros to the `IncludedMacros` list.
       #
-      # Precedence of options is all follows:
+      # Precedence of options is as follows:
       #
       # 1. `AllowedMethods`
       # 2. `AllowedPatterns`
       # 3. `IncludedMacros`
       #
-      # eg. If a method is listed in both
-      # `IncludedMacros` and `AllowedMethods`, then the latter takes
-      # precedence (that is, the method is allowed).
+      # If a method is listed in both `IncludedMacros` and `AllowedMethods`,
+      # then the latter takes precedence (that is, the method is allowed).
       #
       # In the alternative style (omit_parentheses), there are three additional
       # options.
@@ -40,14 +38,29 @@ module RuboCop
       #     to `true` allows the presence of parentheses in such a method call
       #     even with arguments.
       #
-      # NOTE: Parentheses are still allowed in cases where omitting them
-      # results in ambiguous or syntactically incorrect code. For example,
-      # parentheses are required around a method with arguments when inside an
-      # endless method definition introduced in Ruby 3.0. Parentheses are also
-      # allowed when forwarding arguments with the triple-dot syntax introduced
-      # in Ruby 2.7 as omitting them starts an endless range.
-      # And Ruby 3.1's hash omission syntax has a case that requires parentheses
-      # because of the following issue: https://bugs.ruby-lang.org/issues/18396.
+      # NOTE: The style of `omit_parentheses` allows parentheses in cases where
+      # omitting them results in ambiguous or syntactically incorrect code.
+      #
+      # Non-exhaustive list of examples:
+      #
+      # - Parentheses are required allowed in method calls with arguments inside
+      #   literals, logical operators, setting default values in position and
+      #   keyword arguments, chaining and more.
+      # - Parentheses are allowed in method calls with arguments inside
+      #   operators to avoid ambiguity.
+      #   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+      #   endless range.
+      # - Parentheses are allowed when forwarding arguments with the
+      #   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+      #   endless range.
+      # - Parentheses are required in calls with arguments when inside an
+      #   endless method definition introduced in Ruby 3.0.
+      # - Ruby 3.1's hash omission syntax allows parentheses if the method call
+      #   is in conditionals and requires parentheses if the call
+      #   is not the value-returning expression. See
+      #   https://bugs.ruby-lang.org/issues/18396.
+      # - Parentheses are required in anonymous arguments, keyword arguments
+      #   and block passing in Ruby 3.2.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #
@@ -80,34 +93,28 @@ module RuboCop
       #   array.delete e
       #
       #   # bad
-      #   foo.enforce(strict: true)
+      #   action.enforce(strict: true)
       #
       #   # good
-      #   foo.enforce strict: true
+      #   action.enforce strict: true
       #
       #   # good
-      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
-      #   model.validate strict(true)
+      #   # Parentheses are allowed for code that can be ambiguous without
+      #   # them.
+      #   action.enforce(condition) || other_condition
       #
       #   # good
-      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   # Parentheses are allowed for calls that won't produce valid Ruby
+      #   # without them.
       #   yield path, File.basename(path)
       #
       #   # good
-      #   # Operators methods calls with parens
-      #   array&.[](index)
-      #
-      #   # good
-      #   # Operators methods without parens, if you prefer
-      #   array.[] index
-      #
-      #   # good
-      #   # Operators methods calls with parens
-      #   array&.[](index)
-      #
-      #   # good
-      #   # Operators methods without parens, if you prefer
-      #   array.[] index
+      #   # Omitting the parentheses in Ruby 3.1 hash omission syntax can lead
+      #   # to ambiguous code. We allow them in conditionals and non-last
+      #   # expressions. See https://bugs.ruby-lang.org/issues/18396
+      #   if meets(criteria:, action:)
+      #     safe_action(action) || dangerous_action(action)
+      #   end
       #
       # @example IgnoreMacros: true (default)
       #
@@ -226,7 +233,7 @@ module RuboCop
         end
 
         def args_end(node)
-          node.loc.expression.end
+          node.source_range.end
         end
 
         def args_parenthesized?(node)