rubocop 0.82.0 → 1.18.4

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

@@ -6,9 +6,9 @@ module RuboCop
       # Checks for uses of unless with a negated condition. Only unless
       # without else are considered. There are three different styles:
       #
-      #   - both
-      #   - prefix
-      #   - postfix
+      # * both
+      # * prefix
+      # * postfix
       #
       # @example EnforcedStyle: both (default)
       #   # enforces `if` for `prefix` and `postfix` conditionals
@@ -58,19 +58,19 @@ module RuboCop
       #   unless !foo
       #     bar
       #   end
-      class NegatedUnless < Cop
+      class NegatedUnless < Base
         include ConfigurableEnforcedStyle
         include NegativeConditional
+        extend AutoCorrector
 
         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)
+          message = message(node)
+          check_negative_conditional(node, message: message) do |corrector|
+            ConditionCorrector.correct_negative_condition(corrector, node)
+          end
         end
 
         private
@@ -80,8 +80,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :prefix && node.modifier_form? ||
-            style == :postfix && !node.modifier_form?
+          style == :prefix && node.modifier_form? || style == :postfix && !node.modifier_form?
         end
       end
     end

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

@@ -22,26 +22,18 @@ module RuboCop
       #   # good
       #   bar while foo
       #   bar while !foo && baz
-      class NegatedWhile < Cop
+      class NegatedWhile < Base
         include NegativeConditional
+        extend AutoCorrector
 
         def on_while(node)
-          check_negative_conditional(node)
-        end
-
-        def on_until(node)
-          check_negative_conditional(node)
-        end
-
-        def autocorrect(node)
-          ConditionCorrector.correct_negative_condition(node)
-        end
-
-        private
+          message = format(MSG, inverse: node.inverse_keyword, current: node.keyword)
 
-        def message(node)
-          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
+          check_negative_conditional(node, message: message) do |corrector|
+            ConditionCorrector.correct_negative_condition(corrector, node)
+          end
         end
+        alias on_until on_while
       end
     end
   end

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

@@ -13,28 +13,25 @@ module RuboCop
       #
       #   # good
       #   something if b && a
-      class NestedModifier < Cop
+      class NestedModifier < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Avoid using nested modifiers.'
 
         def on_while(node)
           check(node)
         end
+        alias on_until on_while
+        alias on_if on_while
 
-        def on_until(node)
-          check(node)
-        end
-
-        def on_if(node)
-          check(node)
-        end
+        private
 
         def check(node)
           return if part_of_ignored_node?(node)
           return unless modifier?(node) && modifier?(node.parent)
 
-          add_offense(node, location: :keyword)
+          add_offense(node.loc.keyword) { |corrector| autocorrect(corrector, node) }
           ignore_node(node)
         end
 
@@ -42,15 +39,13 @@ module RuboCop
           node&.basic_conditional? && node&.modifier_form?
         end
 
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           return unless node.if_type? && node.parent.if_type?
 
           range = range_between(node.loc.keyword.begin_pos,
                                 node.parent.condition.source_range.end_pos)
 
-          lambda do |corrector|
-            corrector.replace(range, new_expression(node))
-          end
+          corrector.replace(range, new_expression(node))
         end
 
         def new_expression(inner_node)
@@ -69,8 +64,7 @@ module RuboCop
 
         def left_hand_operand(node, operator)
           expr = node.condition.source
-          expr = "(#{expr})" if node.condition.or_type? &&
-                                operator == '&&'
+          expr = "(#{expr})" if node.condition.or_type? && operator == '&&'
           expr
         end
 
@@ -98,8 +92,7 @@ module RuboCop
         end
 
         def requires_parens?(node)
-          node.or_type? ||
-            !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?
+          node.or_type? || !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?
         end
       end
     end

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

@@ -12,40 +12,47 @@ module RuboCop
       #
       #   # bad
       #   method1(method2 arg)
-      class NestedParenthesizedCalls < Cop
+      class NestedParenthesizedCalls < Base
         include RangeHelp
+        include AllowedMethods
+        extend AutoCorrector
 
         MSG = 'Add parentheses to nested method call `%<source>s`.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return unless node.parenthesized?
 
           node.each_child_node(:send, :csend) do |nested|
             next if allowed_omission?(nested)
 
-            add_offense(nested,
-                        location: nested.source_range,
-                        message: format(MSG, source: nested.source))
+            message = format(MSG, source: nested.source)
+            add_offense(nested.source_range, message: message) do |corrector|
+              autocorrect(corrector, nested)
+            end
           end
         end
         alias on_csend on_send
 
-        def autocorrect(nested)
+        private
+
+        def autocorrect(corrector, nested)
           first_arg = nested.first_argument.source_range
           last_arg = nested.last_argument.source_range
 
           leading_space =
             range_with_surrounding_space(range: first_arg.begin,
-                                         side: :left)
+                                         side: :left,
+                                         whitespace: true,
+                                         continuations: true)
 
-          lambda do |corrector|
-            corrector.replace(leading_space, '(')
-            corrector.insert_after(last_arg, ')')
-          end
+          corrector.replace(leading_space, '(')
+          corrector.insert_after(last_arg, ')')
         end
 
-        private
-
         def allowed_omission?(send_node)
           !send_node.arguments? || send_node.parenthesized? ||
             send_node.setter_method? || send_node.operator_method? ||
@@ -54,13 +61,9 @@ module RuboCop
 
         def allowed?(send_node)
           send_node.parent.arguments.one? &&
-            allowed_methods.include?(send_node.method_name.to_s) &&
+            allowed_method?(send_node.method_name) &&
             send_node.arguments.one?
         end
-
-        def allowed_methods
-          cop_config['AllowedMethods'] || []
-        end
       end
     end
   end

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

@@ -15,17 +15,43 @@ module RuboCop
       #   else
       #     a2
       #   end
-      class NestedTernaryOperator < Cop
-        MSG = 'Ternary operators must not be nested. Prefer `if` or `else` ' \
-              'constructs instead.'
+      class NestedTernaryOperator < Base
+        extend AutoCorrector
+
+        MSG = 'Ternary operators must not be nested. Prefer `if` or `else` constructs instead.'
 
         def on_if(node)
           return unless node.ternary?
 
           node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
-            add_offense(nested_ternary)
+            add_offense(nested_ternary) do |corrector|
+              if_node = if_node(nested_ternary)
+
+              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
         end
+
+        private
+
+        def if_node(node)
+          node = node.parent
+          return node if node.if_type?
+
+          if_node(node)
+        end
+
+        def remove_parentheses(source)
+          return source unless source.start_with?('(')
+
+          source.delete_prefix('(').delete_suffix(')')
+        end
       end
     end
   end

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

@@ -46,10 +46,11 @@ module RuboCop
       #     next unless a == 1
       #     puts a
       #   end
-      class Next < Cop
+      class Next < Base
         include ConfigurableEnforcedStyle
         include MinBodyLength
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `next` to skip iteration.'
         EXIT_TYPES = %i[break return].freeze
@@ -58,15 +59,14 @@ module RuboCop
           [Style::SafeNavigation]
         end
 
-        def investigate(_processed_source)
+        def on_new_investigation
           # When correcting nested offenses, we need to keep track of how much
           # we have adjusted the indentation of each line
           @reindented_lines = Hash.new(0)
         end
 
         def on_block(node)
-          return unless node.send_node.send_type? &&
-                        node.send_node.enumerator_method?
+          return unless node.send_node.send_type? && node.send_node.enumerator_method?
 
           check(node)
         end
@@ -77,16 +77,6 @@ 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)
@@ -94,8 +84,13 @@ module RuboCop
 
           offending_node = offense_node(node.body)
 
-          add_offense(offending_node,
-                      location: offense_location(offending_node))
+          add_offense(offense_location(offending_node)) do |corrector|
+            if offending_node.modifier_form?
+              autocorrect_modifier(corrector, offending_node)
+            else
+              autocorrect_block(corrector, offending_node)
+            end
+          end
         end
 
         def ends_with_condition?(body)
@@ -184,14 +179,13 @@ module RuboCop
           source_buffer = node.source_range.source_buffer
           end_pos = node.loc.end.end_pos
           begin_pos = node.loc.end.begin_pos - node.loc.end.column
-          begin_pos -= 1 if end_followed_by_whitespace_only?(source_buffer,
-                                                             end_pos)
+          begin_pos -= 1 if end_followed_by_whitespace_only?(source_buffer, end_pos)
 
           range_between(begin_pos, end_pos)
         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)
@@ -201,7 +195,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`
@@ -211,9 +205,7 @@ module RuboCop
 
           target_indent = range.source_line =~ /\S/
           delta = actual_indent(lines, buffer) - target_indent
-          lines.each do |lineno|
-            reindent_line(corrector, lineno, delta, buffer)
-          end
+          lines.each { |lineno| reindent_line(corrector, lineno, delta, buffer) }
         end
 
         def actual_indent(lines, buffer)
@@ -234,8 +226,7 @@ module RuboCop
           if adjustment.positive?
             corrector.remove_leading(buffer.line_range(lineno), adjustment)
           elsif adjustment.negative?
-            corrector.insert_before(buffer.line_range(lineno),
-                                    ' ' * -adjustment)
+            corrector.insert_before(buffer.line_range(lineno), ' ' * -adjustment)
           end
         end
       end

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

@@ -28,28 +28,36 @@ module RuboCop
       #   if x == nil
       #   end
       #
-      class NilComparison < Cop
+      class NilComparison < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         PREDICATE_MSG = 'Prefer the use of the `nil?` predicate.'
         EXPLICIT_MSG = 'Prefer the use of the `==` comparison.'
 
+        RESTRICT_ON_SEND = %i[== === nil?].freeze
+
+        # @!method nil_comparison?(node)
         def_node_matcher :nil_comparison?, '(send _ {:== :===} nil)'
+
+        # @!method nil_check?(node)
         def_node_matcher :nil_check?, '(send _ :nil?)'
 
         def on_send(node)
           style_check?(node) do
-            add_offense(node, location: :selector)
-          end
-        end
+            add_offense(node.loc.selector) do |corrector|
+              new_code = if prefer_comparison?
+                           node.source.sub('.nil?', ' == nil')
+                         else
+                           node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
+                         end
+
+              corrector.replace(node, new_code)
 
-        def autocorrect(node)
-          new_code = if prefer_comparison?
-                       node.source.sub('.nil?', ' == nil')
-                     else
-                       node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
-                     end
-          ->(corrector) { corrector.replace(node, new_code) }
+              parent = node.parent
+              corrector.wrap(node, '(', ')') if parent.respond_to?(:method?) && parent.method?(:!)
+            end
+          end
         end
 
         private

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for lambdas and procs that always return nil,
+      # which can be replaced with an empty lambda or proc instead.
+      #
+      # @example
+      #   # bad
+      #   -> { nil }
+      #
+      #   lambda do
+      #     next nil
+      #   end
+      #
+      #   proc { nil }
+      #
+      #   Proc.new do
+      #     break nil
+      #   end
+      #
+      #   # good
+      #   -> {}
+      #
+      #   lambda do
+      #   end
+      #
+      #   -> (x) { nil if x }
+      #
+      #   proc {}
+      #
+      #   Proc.new { nil if x }
+      #
+      class NilLambda < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use an empty %<type>s instead of always returning nil.'
+
+        # @!method nil_return?(node)
+        def_node_matcher :nil_return?, <<~PATTERN
+          { ({return next break} nil) (nil) }
+        PATTERN
+
+        def on_block(node)
+          return unless node.lambda? || node.proc?
+          return unless nil_return?(node.body)
+
+          message = format(MSG, type: node.lambda? ? 'lambda' : 'proc')
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          range = if node.single_line?
+                    range_with_surrounding_space(range: node.body.loc.expression)
+                  else
+                    range_by_whole_lines(node.body.loc.expression, include_final_newline: true)
+                  end
+
+          corrector.remove(range)
+        end
+      end
+    end
+  end
+end