rubocop 1.53.0 → 1.90.0

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

@@ -23,6 +23,17 @@ module RuboCop
       # end
       # ----
       #
+      # The code `def method_name = body if condition` is considered a bad case by
+      # `Style/AmbiguousEndlessMethodDefinition` cop. So, to respect the user's intention to use
+      # an endless method definition in the `if` body, the following code is allowed:
+      #
+      # [source,ruby]
+      # ----
+      # if condition
+      #   def method_name = body
+      # end
+      # ----
+      #
       # NOTE: It is allowed when `defined?` argument has an undefined value,
       # because using the modifier form causes the following incompatibility:
       #
@@ -60,10 +71,9 @@ module RuboCop
       #   if short_condition # a long comment that makes it too long if it were just a single line
       #     do_something
       #   end
+      #
       class IfUnlessModifier < Base
         include StatementModifier
-        include LineLengthHelp
-        include AllowedPattern
         include RangeHelp
         include CommentsHelp
         extend AutoCorrector
@@ -71,20 +81,29 @@ module RuboCop
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
                            'single-line body. Another good alternative is ' \
                            'the usage of control flow `&&`/`||`.'
+        MSG_USE_MODIFIER_PARENS = 'Favor modifier `%<keyword>s` usage when having a ' \
+                                  'single-line body. Wrap the expression in parentheses ' \
+                                  'to keep the current behavior, as it is part of a ' \
+                                  'larger expression.'
         MSG_USE_NORMAL = 'Modifier form of `%<keyword>s` makes the line too long.'
 
         def self.autocorrect_incompatible_with
-          [Style::SoleNestedConditional]
+          [Style::Next, Style::SoleNestedConditional]
         end
 
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_if(node)
+          return if endless_method?(node.body) || node.each_ancestor(:dstr).any?
+
           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|
             next if part_of_ignored_node?(node)
+            next if another_modifier_if_on_same_line?(node)
 
             autocorrect(corrector, node)
             ignore_node(node)
@@ -93,17 +112,21 @@ module RuboCop
 
         private
 
+        def endless_method?(body)
+          body&.any_def_type? && body.endless?
+        end
+
         def defined_nodes(condition)
           if condition.defined_type?
             [condition]
           else
-            condition.each_descendant.select(&:defined_type?)
+            condition.each_descendant(:defined?)
           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?
+          return false unless defined_argument.type?(:lvar, :send)
 
           if_node.left_siblings.none? do |sibling|
             sibling.respond_to?(:lvasgn_type?) && sibling.lvasgn_type? &&
@@ -112,18 +135,16 @@ module RuboCop
         end
 
         def pattern_matching_nodes(condition)
-          if condition.match_pattern_type? || condition.match_pattern_p_type?
+          if condition.any_match_pattern_type?
             [condition]
           else
-            condition.each_descendant.select do |node|
-              node.match_pattern_type? || node.match_pattern_p_type?
-            end
+            condition.each_descendant(:any_match_pattern)
           end
         end
 
         def message(node)
           if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
-            MSG_USE_MODIFIER
+            parenthesize?(node) ? MSG_USE_MODIFIER_PARENS : MSG_USE_MODIFIER
           elsif too_long_due_to_modifier?(node)
             MSG_USE_NORMAL
           end
@@ -164,64 +185,68 @@ module RuboCop
 
         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'] || []
+          max_line_length.between?(source_length - comment.source_range.length, source_length)
         end
 
         def too_long_single_line?(node)
-          return false unless max_line_length
-
           range = node.source_range
-          return false unless range.single_line?
-          return false unless line_length_enabled_at_line?(range.first_line)
+          range.single_line? && !acceptable_line_length?(range.source_line, range.first_line)
+        end
 
-          line = range.source_line
-          return false if line_length(line) <= max_line_length
+        def named_capture_in_condition?(node)
+          node.condition.match_with_lvasgn_type?
+        end
 
-          too_long_line_based_on_config?(range, line)
+        def non_eligible_node?(node)
+          non_simple_if_unless?(node) || node.chained? || node.nested_conditional? ||
+            multiline_inside_collection?(node) || super
         end
 
-        def too_long_line_based_on_config?(range, line)
-          return false if matches_allowed_pattern?(line)
+        def multiline_inside_collection?(node)
+          return false if node.modifier_form?
+          return false unless (collection = find_containing_collection(node))
 
-          too_long = too_long_line_based_on_ignore_cop_directives?(range, line)
-          return too_long unless too_long == :undetermined
+          collection.children.any? { |child| sibling_if_shares_line?(child, node) }
+        end
 
-          too_long_line_based_on_allow_uri?(line)
+        def sibling_if_shares_line?(child, node)
+          inner = unwrap_begin(child)
+          inner&.if_type? && !inner.ternary? && shares_line_with?(inner, node)
         end
 
-        def too_long_line_based_on_ignore_cop_directives?(range, line)
-          if ignore_cop_directives? && directive_on_source_line?(range.line - 1)
-            return line_length_without_directive(line) > max_line_length
-          end
+        def unwrap_begin(node)
+          return unless node.is_a?(RuboCop::AST::Node)
 
-          :undetermined
+          node = node.value if node.pair_type?
+          node.begin_type? ? node.children.first : node
         end
 
-        def too_long_line_based_on_allow_uri?(line)
-          if allow_uri?
-            uri_range = find_excessive_uri_range(line)
-            return false if uri_range && allowed_uri_position?(line, uri_range)
-          end
-
-          true
+        def shares_line_with?(inner, node)
+          same_line?(inner, node.loc.end) || same_line?(inner.loc.end, node)
         end
 
-        def line_length_enabled_at_line?(line)
-          processed_source.comment_config.cop_enabled_at_line?('Layout/LineLength', line)
+        def find_containing_collection(node)
+          parent = node.parent
+          return collection_from_ancestor(parent) unless parent&.begin_type?
+
+          collection_from_ancestor(parent.parent)
         end
 
-        def named_capture_in_condition?(node)
-          node.condition.match_with_lvasgn_type?
+        def collection_from_ancestor(node)
+          return node if node&.type?(:array, :call)
+
+          node.parent if node&.type?(:pair)
         end
 
-        def non_eligible_node?(node)
-          non_simple_if_unless?(node) || node.chained? || node.nested_conditional? || super
+        def another_modifier_if_on_same_line?(node)
+          collection = find_containing_collection(node)
+          return false unless collection
+
+          line = node.source_range.line
+          collection.each_descendant(:if).any? do |sibling|
+            sibling != node && sibling.modifier_form? && sibling.source_range.line == line
+          end
         end
 
         def non_simple_if_unless?(node)
@@ -283,7 +308,7 @@ module RuboCop
         end
 
         def comment_on_node_line(node)
-          processed_source.comments.find { |c| same_line?(c, node) }
+          processed_source.comment_at_line(node.first_line)
         end
 
         def remove_comment(corrector, _node, comment)

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

@@ -8,37 +8,33 @@ module RuboCop
       #
       # @example
       #
-      #  # bad
-      #  tired? ? 'stop' : 'go faster' if running?
+      #   # bad
+      #   tired? ? 'stop' : 'go faster' if running?
       #
-      #  # bad
-      #  if tired?
-      #    "please stop"
-      #  else
-      #    "keep going"
-      #  end if running?
+      #   # bad
+      #   if tired?
+      #     "please stop"
+      #   else
+      #     "keep going"
+      #   end if running?
       #
-      #  # good
-      #  if running?
-      #    tired? ? 'stop' : 'go faster'
-      #  end
+      #   # good
+      #   if running?
+      #     tired? ? 'stop' : 'go faster'
+      #   end
       class IfUnlessModifierOfIfUnless < Base
         include StatementModifier
         extend AutoCorrector
 
         MSG = 'Avoid modifier `%<keyword>s` after another conditional.'
 
+        # rubocop:disable-next Metrics/AbcSize
         def on_if(node)
           return unless node.modifier_form? && node.body.if_type?
 
           add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
-            keyword = node.if? ? 'if' : 'unless'
-
-            corrector.replace(node, <<~RUBY.chop)
-              #{keyword} #{node.condition.source}
-              #{node.if_branch.source}
-              end
-            RUBY
+            corrector.wrap(node.if_branch, "#{node.keyword} #{node.condition.source}\n", "\nend")
+            corrector.remove(node.if_branch.source_range.end.join(node.condition.source_range.end))
           end
         end
       end

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

@@ -10,7 +10,7 @@ module RuboCop
       # `nonzero?` method is allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
-      # This cop targets only `if`s with a single `elsif` or `else` branch. The following
+      # This cop targets only ``if``s with a single `elsif` or `else` branch. The following
       # code will be allowed, because it has two `elsif` branches:
       #
       # [source,ruby]
@@ -44,7 +44,6 @@ module RuboCop
       #   # good
       #   foo == bar
       #
-      # @example
       #   # bad
       #   if foo.do_something?
       #     true
@@ -55,7 +54,10 @@ module RuboCop
       #   # good (but potentially an unsafe correction)
       #   foo.do_something?
       #
-      # @example AllowedMethods: ['nonzero?'] (default)
+      # @example AllowedMethods: ['infinite?', 'nonzero?'] (default)
+      #   # good
+      #   num.infinite? ? true : false
+      #
       #   # good
       #   num.nonzero? ? true : false
       #
@@ -68,7 +70,7 @@ module RuboCop
 
         # @!method if_with_boolean_literal_branches?(node)
         def_node_matcher :if_with_boolean_literal_branches?, <<~PATTERN
-          (if #return_boolean_value? {(true) (false) | (false) (true)})
+          (if #return_boolean_value? <true false>)
         PATTERN
         # @!method double_negative?(node)
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
@@ -112,9 +114,11 @@ module RuboCop
         end
 
         def message(node, keyword)
-          message_template = node.elsif? ? MSG_FOR_ELSIF : MSG
-
-          format(message_template, keyword: keyword)
+          if node.elsif?
+            MSG_FOR_ELSIF
+          else
+            format(MSG, keyword: keyword)
+          end
         end
 
         def return_boolean_value?(condition)
@@ -154,8 +158,7 @@ module RuboCop
         end
 
         def require_parentheses?(condition)
-          condition.and_type? || condition.or_type? ||
-            (condition.send_type? && condition.comparison_method?)
+          condition.operator_keyword? || (condition.send_type? && condition.comparison_method?)
         end
       end
     end

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

@@ -17,46 +17,104 @@ module RuboCop
         include OnNormalIfUnless
         extend AutoCorrector
 
-        MSG_IF_ELSE = 'Do not use `if %<expr>s;` - use `if/else` instead.'
-        MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
+        MSG_IF_ELSE = 'Do not use `%<keyword>s %<expr>s;` - use `if/else` instead.'
+        MSG_NEWLINE = 'Do not use `%<keyword>s %<expr>s;` - use a newline instead.'
+        MSG_TERNARY = 'Do not use `%<keyword>s %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
           return if node.parent&.if_type?
+          return if part_of_ignored_node?(node)
 
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
-          message = node.else_branch&.if_type? ? MSG_IF_ELSE : MSG_TERNARY
+          message = message(node)
 
-          add_offense(node, message: format(message, expr: node.condition.source)) do |corrector|
-            corrector.replace(node, autocorrect(node))
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
           end
+
+          ignore_node(node)
         end
 
         private
 
-        def autocorrect(node)
+        def message(node)
+          template = if require_newline?(node)
+                       MSG_NEWLINE
+                     elsif node.else_branch&.type?(:if, :begin) ||
+                           use_masgn_or_block_in_branches?(node)
+                       MSG_IF_ELSE
+                     else
+                       MSG_TERNARY
+                     end
+
+          format(template, keyword: node.keyword, expr: node.condition.source)
+        end
+
+        def autocorrect(corrector, node)
+          if require_newline?(node) || use_masgn_or_block_in_branches?(node)
+            corrector.replace(node.loc.begin, "\n")
+          else
+            corrector.replace(node, replacement(node))
+          end
+        end
+
+        def require_newline?(node)
+          node.branches.compact.any?(&:begin_type?) || use_return_with_argument?(node)
+        end
+
+        def use_masgn_or_block_in_branches?(node)
+          node.branches.compact.any? do |branch|
+            branch.type?(:masgn, :any_block)
+          end
+        end
+
+        def use_return_with_argument?(node)
+          node.branches.compact.any? { |branch| branch.return_type? && branch.arguments.any? }
+        end
+
+        def replacement(node)
           return correct_elsif(node) if node.else_branch&.if_type?
 
-          then_code = node.if_branch ? node.if_branch.source : 'nil'
-          else_code = node.else_branch ? node.else_branch.source : 'nil'
+          then_code = node.if_branch ? build_expression(node.if_branch) : 'nil'
+          else_code = node.else_branch ? build_expression(node.else_branch) : 'nil'
+
+          then_code, else_code = else_code, then_code if node.unless?
 
-          "#{node.condition.source} ? #{then_code} : #{else_code}"
+          "#{ternary_condition(node)} ? #{then_code} : #{else_code}"
         end
 
         def correct_elsif(node)
           <<~RUBY.chop
             if #{node.condition.source}
-              #{node.if_branch.source}
+              #{node.if_branch&.source}
             #{build_else_branch(node.else_branch).chop}
             end
           RUBY
         end
 
+        def build_expression(expr)
+          return expr.source unless require_argument_parentheses?(expr)
+
+          method = expr.source_range.begin.join(expr.loc.selector.end)
+          arguments = expr.first_argument.source_range.begin.join(expr.source_range.end)
+
+          "#{method.source}(#{arguments.source})"
+        end
+
+        # An assignment used as the condition must be parenthesized, otherwise the
+        # assignment would capture the whole ternary (`a = b ? c : d` instead of
+        # `(a = b) ? c : d`), changing what gets assigned.
+        def ternary_condition(node)
+          condition = node.condition
+          condition.assignment? ? "(#{condition.source})" : condition.source
+        end
+
         def build_else_branch(second_condition)
           result = <<~RUBY
             elsif #{second_condition.condition.source}
-              #{second_condition.if_branch.source}
+              #{second_condition.if_branch&.source}
           RUBY
 
           if second_condition.else_branch
@@ -72,6 +130,12 @@ module RuboCop
 
           result
         end
+
+        def require_argument_parentheses?(node)
+          return false if !node.call_type? || node.arithmetic_operation?
+
+          !node.parenthesized? && node.arguments.any? && !node.method?(:[]) && !node.method?(:[]=)
+        end
       end
     end
   end

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

@@ -44,11 +44,15 @@ module RuboCop
         private
 
         def alternative_pattern_source(pattern)
+          collect_alternative_patterns(pattern).join(' | ')
+        end
+
+        def collect_alternative_patterns(pattern)
           return pattern.children.map(&:source) unless pattern.children.first.match_alt_type?
 
-          pattern_sources = alternative_pattern_source(pattern.children.first)
+          pattern_sources = collect_alternative_patterns(pattern.children.first)
 
-          (pattern_sources << pattern.children[1].source).join(' | ')
+          pattern_sources << pattern.children[1].source
         end
       end
     end

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

@@ -68,7 +68,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          if node.while_post_type? || node.until_post_type?
+          if node.post_condition_loop?
             replace_begin_end_with_modifier(corrector, node)
           elsif node.modifier_form?
             replace_source(corrector, node.source_range, modifier_replacement(node))

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

@@ -3,7 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for trailing inline comments.
+      # Checks for trailing inline comments. Inline comments can
+      # make lines harder to read, especially when they are long.
+      # Placing comments on their own line above the code they
+      # describe is often clearer.
       #
       # @example
       #
@@ -23,7 +26,7 @@ module RuboCop
         def on_new_investigation
           processed_source.comments.each do |comment|
             next if comment_line?(processed_source[comment.loc.line - 1]) ||
-                    comment.text.match?(/\A# rubocop:(enable|disable)/)
+                    comment.text.match?(/\A# rubocop:(enable|disable|todo)/)
 
             add_offense(comment)
           end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for usages of not (`not` or `!`) called on a method
+      # Checks for usages of not (`not` or `!`) called on a method
       # when an inverse of that method can be used instead.
       #
       # Methods that can be inverted by a not (`not` or `!`) should be defined
@@ -41,12 +41,12 @@ module RuboCop
       #     f != 1
       #   end
       class InverseMethods < Base
-        include IgnoredNode
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'
         CLASS_COMPARISON_METHODS = %i[<= >= < >].freeze
+        SAFE_NAVIGATION_INCOMPATIBLE_METHODS = (CLASS_COMPARISON_METHODS + %i[any? none?]).freeze
         EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
@@ -60,25 +60,25 @@ module RuboCop
         # @!method inverse_candidate?(node)
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
-            (send $(send $(...) $_ $...) :!)
-            (send ({block numblock} $(send $(...) $_) $...) :!)
-            (send (begin $(send $(...) $_ $...)) :!)
+            (send $(call $(...) $_ $...) :!)
+            (send (any_block $(call $(...) $_) $...) :!)
+            (send (begin $(call $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          ({block numblock} $(send (...) $_) ... { $(send ... :!)
-                                                   $(send (...) {:!= :!~} ...)
-                                                   (begin ... $(send ... :!))
-                                                   (begin ... $(send (...) {:!= :!~} ...))
-                                                 })
+          (any_block $(call (...) $_) ... { $(call ... :!)
+                                            $(send (...) {:!= :!~} ...)
+                                            (begin ... $(call ... :!))
+                                            (begin ... $(send (...) {:!= :!~} ...))
+                                          })
         PATTERN
 
         def on_send(node)
-          inverse_candidate?(node) do |_method_call, lhs, method, rhs|
+          inverse_candidate?(node) do |method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
-            return if negated?(node)
+            return if negated?(node) || safe_navigation_incompatible?(method_call)
             return if part_of_ignored_node?(node)
             return if possible_class_hierarchy_check?(lhs, rhs, method)
 
@@ -87,6 +87,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         def on_block(node)
           inverse_block?(node) do |_method_call, method, block|
@@ -105,6 +106,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -155,15 +157,17 @@ module RuboCop
         end
 
         def not_to_receiver(node, method_call)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.loc.selector.begin_pos,
-                                    method_call.source_range.begin_pos)
+          node.loc.selector.begin.join(method_call.source_range.begin)
         end
 
         def end_parentheses(node, method_call)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    method_call.source_range.end_pos,
-                                    node.source_range.end_pos)
+          method_call.source_range.end.join(node.source_range.end)
+        end
+
+        def safe_navigation_incompatible?(node)
+          return false unless node.csend_type?
+
+          SAFE_NAVIGATION_INCOMPATIBLE_METHODS.include?(node.method_name)
         end
 
         # When comparing classes, `!(Integer < Numeric)` is not the same as