rubocop 1.31.1 → 1.51.0

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,42 +78,96 @@ 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|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, node)
+            ignore_node(node)
           end
         end
 
         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'] || []
@@ -96,7 +177,7 @@ module RuboCop
           return false unless max_line_length
 
           range = node.source_range
-          return false unless range.first_line == range.last_line
+          return false unless range.single_line?
           return false unless line_length_enabled_at_line?(range.first_line)
 
           line = range.source_line
@@ -181,6 +262,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 +281,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

@@ -5,7 +5,26 @@ module RuboCop
     module Style
       # Checks for redundant `if` with boolean literal branches.
       # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
-      # The conditions to be checked are comparison methods, predicate methods, and double negative.
+      # The conditions to be checked are comparison methods, predicate methods, and
+      # double negation (!!).
+      # `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
+      # code will be allowed, because it has two `elsif` branches:
+      #
+      # [source,ruby]
+      # ----
+      # if foo
+      #   true
+      # elsif bar > baz
+      #   true
+      # elsif qux > quux # Single `elsif` is warned, but two or more `elsif`s are not.
+      #   true
+      # else
+      #   false
+      # end
+      # ----
       #
       # @safety
       #   Autocorrection is unsafe because there is no guarantee that all predicate methods
@@ -55,7 +74,7 @@ module RuboCop
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
         def on_if(node)
-          return unless if_with_boolean_literal_branches?(node)
+          return if !if_with_boolean_literal_branches?(node) || multiple_elsif?(node)
 
           condition = node.condition
           range, keyword = offense_range_with_keyword(node, condition)
@@ -74,6 +93,12 @@ module RuboCop
 
         private
 
+        def multiple_elsif?(node)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && parent.elsif?
+        end
+
         def offense_range_with_keyword(node, condition)
           if node.ternary?
             range = condition.source_range.end.join(node.source_range.end)
@@ -93,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/if_with_semicolon.rb

@@ -21,13 +21,12 @@ module RuboCop
         MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
-          return unless node.else_branch
           return if node.parent&.if_type?
 
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
-          message = node.else_branch.if_type? ? MSG_IF_ELSE : MSG_TERNARY
+          message = node.else_branch&.if_type? ? MSG_IF_ELSE : MSG_TERNARY
 
           add_offense(node, message: format(message, expr: node.condition.source)) do |corrector|
             corrector.replace(node, autocorrect(node))
@@ -37,11 +36,12 @@ module RuboCop
         private
 
         def autocorrect(node)
-          return correct_elsif(node) if node.else_branch.if_type?
+          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'
 
-          "#{node.condition.source} ? #{node.if_branch.source} : #{else_code}"
+          "#{node.condition.source} ? #{then_code} : #{else_code}"
         end
 
         def correct_elsif(node)

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

@@ -51,6 +51,8 @@ module RuboCop
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
 
+        RESTRICT_ON_SEND = [:!].freeze
+
         def self.autocorrect_incompatible_with
           [Style::Not, Style::SymbolProc]
         end
@@ -59,18 +61,18 @@ module RuboCop
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
             (send $(send $(...) $_ $...) :!)
-            (send (block $(send $(...) $_) $...) :!)
+            (send ({block numblock} $(send $(...) $_) $...) :!)
             (send (begin $(send $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          (block $(send (...) $_) ... { $(send ... :!)
-                                        $(send (...) {:!= :!~} ...)
-                                        (begin ... $(send ... :!))
-                                        (begin ... $(send (...) {:!= :!~} ...))
-                                      })
+          ({block numblock} $(send (...) $_) ... { $(send ... :!)
+                                                   $(send (...) {:!= :!~} ...)
+                                                   (begin ... $(send ... :!))
+                                                   (begin ... $(send (...) {:!= :!~} ...))
+                                                 })
         PATTERN
 
         def on_send(node)
@@ -102,6 +104,8 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
         def correct_inverse_method(corrector, node)
@@ -151,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,118 @@
+# 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,
+      #
+      # [source,yaml]
+      # ----
+      # 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/line_end_concatenation.rb

@@ -55,7 +55,10 @@ module RuboCop
         private
 
         def check_token_set(index)
-          predecessor, operator, successor = processed_source.tokens[index, 3]
+          tokens = processed_source.tokens
+          predecessor = tokens[index]
+          operator = tokens[index + 1]
+          successor = tokens[index + 2]
 
           return unless eligible_token_set?(predecessor, operator, successor)