rubocop 0.51.0 → 0.87.0

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

@@ -6,21 +6,13 @@ module RuboCop
       # Checks for uses of if with a negated condition. Only ifs
       # without else are considered. There are three different styles:
       #
-      #   - both
-      #   - prefix
-      #   - postfix
+      # * both
+      # * prefix
+      # * postfix
       #
-      # @example
-      #
-      #   # EnforcedStyle: both
+      # @example EnforcedStyle: both (default)
       #   # enforces `unless` for `prefix` and `postfix` conditionals
       #
-      #   # good
-      #
-      #   unless foo
-      #     bar
-      #   end
-      #
       #   # bad
       #
       #   if !foo
@@ -29,26 +21,30 @@ module RuboCop
       #
       #   # good
       #
-      #   bar unless foo
+      #   unless foo
+      #     bar
+      #   end
       #
       #   # bad
       #
       #   bar if !foo
       #
-      # @example
+      #   # good
       #
-      #   # EnforcedStyle: prefix
+      #   bar unless foo
+      #
+      # @example EnforcedStyle: prefix
       #   # enforces `unless` for just `prefix` conditionals
       #
-      #   # good
+      #   # bad
       #
-      #   unless foo
+      #   if !foo
       #     bar
       #   end
       #
-      #   # bad
+      #   # good
       #
-      #   if !foo
+      #   unless foo
       #     bar
       #   end
       #
@@ -56,21 +52,19 @@ module RuboCop
       #
       #   bar if !foo
       #
-      # @example
-      #
-      #   # EnforcedStyle: postfix
+      # @example EnforcedStyle: postfix
       #   # enforces `unless` for just `postfix` conditionals
       #
-      #   # good
-      #
-      #   bar unless foo
-      #
       #   # bad
       #
       #   bar if !foo
       #
       #   # good
       #
+      #   bar unless foo
+      #
+      #   # good
+      #
       #   if !foo
       #     bar
       #   end
@@ -78,23 +72,21 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include NegativeConditional
 
-        MSG = 'Favor `%s` over `%s` for negative conditions.'.freeze
-
         def on_if(node)
-          return if node.elsif? || node.ternary?
+          return if node.unless? || node.elsif? || node.ternary?
           return if correct_style?(node)
 
           check_negative_conditional(node)
         end
 
+        def autocorrect(node)
+          ConditionCorrector.correct_negative_condition(node)
+        end
+
         private
 
         def message(node)
-          format(MSG, node.inverse_keyword, node.keyword)
-        end
-
-        def autocorrect(node)
-          negative_conditional_corrector(node)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
         end
 
         def correct_style?(node)

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of unless with a negated condition. Only unless
+      # without else are considered. There are three different styles:
+      #
+      # * both
+      # * prefix
+      # * postfix
+      #
+      # @example EnforcedStyle: both (default)
+      #   # enforces `if` for `prefix` and `postfix` conditionals
+      #
+      #   # bad
+      #   unless !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   if foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #   bar unless !foo
+      #
+      #   # good
+      #   bar if foo
+      #
+      # @example EnforcedStyle: prefix
+      #   # enforces `if` for just `prefix` conditionals
+      #
+      #   # bad
+      #   unless !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   if foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   bar unless !foo
+      #
+      # @example EnforcedStyle: postfix
+      #   # enforces `if` for just `postfix` conditionals
+      #
+      #   # bad
+      #   bar unless !foo
+      #
+      #   # good
+      #   bar if foo
+      #
+      #   # good
+      #   unless !foo
+      #     bar
+      #   end
+      class NegatedUnless < Cop
+        include ConfigurableEnforcedStyle
+        include NegativeConditional
+
+        def on_if(node)
+          return if node.if? || node.elsif? || node.ternary?
+          return if correct_style?(node)
+
+          check_negative_conditional(node)
+        end
+
+        def autocorrect(node)
+          ConditionCorrector.correct_negative_condition(node)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
+        end
+
+        def correct_style?(node)
+          style == :prefix && node.modifier_form? ||
+            style == :postfix && !node.modifier_form?
+        end
+      end
+    end
+  end
+end

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

@@ -4,11 +4,27 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of while with a negated condition.
+      #
+      # @example
+      #   # bad
+      #   while !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   until foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #   bar until !foo
+      #
+      #   # good
+      #   bar while foo
+      #   bar while !foo && baz
       class NegatedWhile < Cop
         include NegativeConditional
 
-        MSG = 'Favor `%s` over `%s` for negative conditions.'.freeze
-
         def on_while(node)
           check_negative_conditional(node)
         end
@@ -17,14 +33,14 @@ module RuboCop
           check_negative_conditional(node)
         end
 
-        def message(node)
-          format(MSG, node.inverse_keyword, node.keyword)
+        def autocorrect(node)
+          ConditionCorrector.correct_negative_condition(node)
         end
 
         private
 
-        def autocorrect(node)
-          negative_conditional_corrector(node)
+        def message(node)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
         end
       end
     end

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

@@ -14,7 +14,9 @@ module RuboCop
       #   # good
       #   something if b && a
       class NestedModifier < Cop
-        MSG = 'Avoid using nested modifiers.'.freeze
+        include RangeHelp
+
+        MSG = 'Avoid using nested modifiers.'
 
         def on_while(node)
           check(node)
@@ -37,7 +39,7 @@ module RuboCop
         end
 
         def modifier?(node)
-          node && MODIFIER_NODES.include?(node.type) && node.modifier_form?
+          node&.basic_conditional? && node&.modifier_form?
         end
 
         def autocorrect(node)
@@ -47,11 +49,13 @@ module RuboCop
                                 node.parent.condition.source_range.end_pos)
 
           lambda do |corrector|
-            corrector.replace(range, new_expression(node.parent, node))
+            corrector.replace(range, new_expression(node))
           end
         end
 
-        def new_expression(outer_node, inner_node)
+        def new_expression(inner_node)
+          outer_node = inner_node.parent
+
           operator = replacement_operator(outer_node.keyword)
           lh_operand = left_hand_operand(outer_node, operator)
           rh_operand = right_hand_operand(inner_node, outer_node.keyword)
@@ -60,23 +64,39 @@ module RuboCop
         end
 
         def replacement_operator(keyword)
-          keyword == 'if'.freeze ? '&&'.freeze : '||'.freeze
+          keyword == 'if' ? '&&' : '||'
         end
 
         def left_hand_operand(node, operator)
           expr = node.condition.source
           expr = "(#{expr})" if node.condition.or_type? &&
-                                operator == '&&'.freeze
+                                operator == '&&'
           expr
         end
 
         def right_hand_operand(node, left_hand_keyword)
-          expr = node.condition.source
-          expr = "(#{expr})" if requires_parens?(node.condition)
+          condition = node.condition
+
+          expr = if condition.send_type? && !condition.arguments.empty? &&
+                    !condition.operator_method?
+                   add_parentheses_to_method_arguments(condition)
+                 else
+                   condition.source
+                 end
+          expr = "(#{expr})" if requires_parens?(condition)
           expr = "!#{expr}" unless left_hand_keyword == node.keyword
           expr
         end
 
+        def add_parentheses_to_method_arguments(send_node)
+          expr = +''
+          expr << "#{send_node.receiver.source}." if send_node.receiver
+          expr << send_node.method_name.to_s
+          expr << "(#{send_node.arguments.map(&:source).join(', ')})"
+
+          expr
+        end
+
         def requires_parens?(node)
           node.or_type? ||
             !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?

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

@@ -7,46 +7,37 @@ module RuboCop
       # of a parenthesized method call.
       #
       # @example
-      #   @good
-      #   method1(method2(arg), method3(arg))
+      #   # good
+      #   method1(method2(arg))
       #
-      #   @bad
-      #   method1(method2 arg, method3, arg)
+      #   # bad
+      #   method1(method2 arg)
       class NestedParenthesizedCalls < Cop
-        MSG = 'Add parentheses to nested method call `%s`.'.freeze
+        include RangeHelp
+        include AllowedMethods
+
+        MSG = 'Add parentheses to nested method call `%<source>s`.'
 
         def on_send(node)
           return unless node.parenthesized?
 
-          node.each_child_node(:send) do |nested|
+          node.each_child_node(:send, :csend) do |nested|
             next if allowed_omission?(nested)
 
             add_offense(nested,
                         location: nested.source_range,
-                        message: format(MSG, nested.source))
+                        message: format(MSG, source: nested.source))
           end
         end
-
-        private
-
-        def allowed_omission?(send_node)
-          !send_node.arguments? || send_node.parenthesized? ||
-            send_node.setter_method? || send_node.operator_method? ||
-            whitelisted?(send_node)
-        end
-
-        def whitelisted?(send_node)
-          send_node.parent.arguments.one? &&
-            whitelisted_methods.include?(send_node.method_name.to_s) &&
-            send_node.arguments.one?
-        end
+        alias on_csend on_send
 
         def autocorrect(nested)
           first_arg = nested.first_argument.source_range
           last_arg = nested.last_argument.source_range
 
           leading_space =
-            range_with_surrounding_space(first_arg, :left).begin.resize(1)
+            range_with_surrounding_space(range: first_arg.begin,
+                                         side: :left)
 
           lambda do |corrector|
             corrector.replace(leading_space, '(')
@@ -54,8 +45,18 @@ module RuboCop
           end
         end
 
-        def whitelisted_methods
-          cop_config['Whitelist'] || []
+        private
+
+        def allowed_omission?(send_node)
+          !send_node.arguments? || send_node.parenthesized? ||
+            send_node.setter_method? || send_node.operator_method? ||
+            allowed?(send_node)
+        end
+
+        def allowed?(send_node)
+          send_node.parent.arguments.one? &&
+            allowed_method?(send_node.method_name) &&
+            send_node.arguments.one?
         end
       end
     end

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

@@ -4,9 +4,20 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for nested ternary op expressions.
+      #
+      # @example
+      #   # bad
+      #   a ? (b ? b1 : b2) : a2
+      #
+      #   # good
+      #   if a
+      #     b ? b1 : b2
+      #   else
+      #     a2
+      #   end
       class NestedTernaryOperator < Cop
         MSG = 'Ternary operators must not be nested. Prefer `if` or `else` ' \
-              'constructs instead.'.freeze
+              'constructs instead.'
 
         def on_if(node)
           return unless node.ternary?
@@ -15,6 +26,33 @@ module RuboCop
             add_offense(nested_ternary)
           end
         end
+
+        def autocorrect(node)
+          if_node = if_node(node)
+
+          lambda do |corrector|
+            corrector.replace(if_node, <<~RUBY.chop)
+              if #{if_node.condition.source}
+                #{remove_parentheses(if_node.if_branch.source)}
+              else
+                #{if_node.else_branch.source}
+              end
+            RUBY
+          end
+        end
+
+        private
+
+        def if_node(node)
+          node = node.parent
+          return node if node.if_type?
+
+          if_node(node)
+        end
+
+        def remove_parentheses(source)
+          source.gsub(/\A\(/, '').gsub(/\)\z/, '')
+        end
       end
     end
   end

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

@@ -5,7 +5,35 @@ module RuboCop
     module Style
       # Use `next` to skip iteration instead of a condition at the end.
       #
-      # @example
+      # @example EnforcedStyle: skip_modifier_ifs (default)
+      #   # bad
+      #   [1, 2].each do |a|
+      #     if a == 1
+      #       puts a
+      #     end
+      #   end
+      #
+      #   # good
+      #   [1, 2].each do |a|
+      #     next unless a == 1
+      #     puts a
+      #   end
+      #
+      #   # good
+      #   [1, 2].each do |a|
+      #     puts a if a == 1
+      #   end
+      #
+      # @example EnforcedStyle: always
+      #   # With `always` all conditions at the end of an iteration needs to be
+      #   # replaced by next - with `skip_modifier_ifs` the modifier if like
+      #   # this one are ignored: `[1, 2].each { |a| puts a if a == 1 }`
+      #
+      #   # bad
+      #   [1, 2].each do |a|
+      #     puts a if a == 1
+      #   end
+      #
       #   # bad
       #   [1, 2].each do |a|
       #     if a == 1
@@ -21,10 +49,15 @@ module RuboCop
       class Next < Cop
         include ConfigurableEnforcedStyle
         include MinBodyLength
+        include RangeHelp
 
-        MSG = 'Use `next` to skip iteration.'.freeze
+        MSG = 'Use `next` to skip iteration.'
         EXIT_TYPES = %i[break return].freeze
 
+        def self.autocorrect_incompatible_with
+          [Style::SafeNavigation]
+        end
+
         def investigate(_processed_source)
           # When correcting nested offenses, we need to keep track of how much
           # we have adjusted the indentation of each line
@@ -44,6 +77,16 @@ module RuboCop
         alias on_until on_while
         alias on_for on_while
 
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.modifier_form?
+              autocorrect_modifier(corrector, node)
+            else
+              autocorrect_block(corrector, node)
+            end
+          end
+        end
+
         private
 
         def check(node)
@@ -82,7 +125,7 @@ module RuboCop
         end
 
         def if_without_else?(node)
-          node && node.if_type? && !node.ternary? && !node.else?
+          node&.if_type? && !node.ternary? && !node.else?
         end
 
         def exit_body_type?(node)
@@ -93,52 +136,38 @@ module RuboCop
 
         def offense_node(body)
           *_, condition = *body
-          condition && condition.if_type? ? condition : body
+
+          condition&.if_type? ? condition : body
         end
 
         def offense_location(offense_node)
-          condition_expression, = *offense_node
           offense_begin_pos = offense_node.source_range.begin
-          offense_begin_pos.join(condition_expression.source_range)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.modifier_form?
-              autocorrect_modifier(corrector, node)
-            else
-              autocorrect_block(corrector, node)
-            end
-          end
+          offense_begin_pos.join(offense_node.condition.source_range)
         end
 
         def autocorrect_modifier(corrector, node)
-          cond, if_body, else_body = *node
-          body = if_body || else_body
+          body = node.if_branch || node.else_branch
 
-          replacement = "next #{opposite_kw(if_body)} #{cond.source}\n" \
-                        "#{' ' * node.source_range.column}#{body.source}"
+          replacement =
+            "next #{node.inverse_keyword} #{node.condition.source}\n" \
+            "#{' ' * node.source_range.column}#{body.source}"
 
-          corrector.replace(node.source_range, replacement)
+          corrector.replace(node, replacement)
         end
 
         def autocorrect_block(corrector, node)
-          cond, if_body, = *node
+          next_code = "next #{node.inverse_keyword} #{node.condition.source}"
 
-          next_code = "next #{opposite_kw(if_body)} #{cond.source}"
-          corrector.insert_before(node.source_range, next_code)
+          corrector.insert_before(node, next_code)
 
-          corrector.remove(cond_range(node, cond))
+          corrector.remove(cond_range(node, node.condition))
           corrector.remove(end_range(node))
 
           lines = reindentable_lines(node)
-          return if lines.empty?
 
-          reindent(lines, cond, corrector)
-        end
+          return if lines.empty?
 
-        def opposite_kw(if_body)
-          if_body.nil? ? 'if' : 'unless'
+          reindent(lines, node.condition, corrector)
         end
 
         def cond_range(node, cond)
@@ -162,7 +191,7 @@ module RuboCop
         end
 
         def end_followed_by_whitespace_only?(source_buffer, end_pos)
-          source_buffer.source[end_pos..-1] =~ /\A\s*$/
+          /\A\s*$/.match?(source_buffer.source[end_pos..-1])
         end
 
         def reindentable_lines(node)
@@ -172,7 +201,7 @@ module RuboCop
           lines = (node.source_range.line + 1)...node.loc.end.line
           lines = lines.to_a - heredoc_lines(node)
           # Skip blank lines
-          lines.reject { |lineno| buffer.source_line(lineno) =~ /\A\s*\z/ }
+          lines.reject { |lineno| /\A\s*\z/.match?(buffer.source_line(lineno)) }
         end
 
         # Adjust indentation of `lines` to match `node`
@@ -193,7 +222,7 @@ module RuboCop
 
         def heredoc_lines(node)
           node.each_node(:dstr)
-              .select { |n| n.loc.respond_to?(:heredoc_body) }
+              .select(&:heredoc?)
               .map { |n| n.loc.heredoc_body }
               .flat_map { |b| (b.line...b.last_line).to_a }
         end
@@ -202,9 +231,9 @@ module RuboCop
           adjustment = delta + @reindented_lines[lineno]
           @reindented_lines[lineno] = adjustment
 
-          if adjustment > 0
+          if adjustment.positive?
             corrector.remove_leading(buffer.line_range(lineno), adjustment)
-          elsif adjustment < 0
+          elsif adjustment.negative?
             corrector.insert_before(buffer.line_range(lineno),
                                     ' ' * -adjustment)
           end