rubocop 0.89.1 → 0.93.0

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

@@ -15,7 +15,9 @@ module RuboCop
       #   else
       #     a2
       #   end
-      class NestedTernaryOperator < Cop
+      class NestedTernaryOperator < Base
+        extend AutoCorrector
+
         MSG = 'Ternary operators must not be nested. Prefer `if` or `else` ' \
               'constructs instead.'
 
@@ -23,21 +25,17 @@ module RuboCop
           return unless node.ternary?
 
           node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
-            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
+            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
 
@@ -51,6 +49,8 @@ module RuboCop
         end
 
         def remove_parentheses(source)
+          return source unless source.start_with?('(')
+
           source.gsub(/\A\(/, '').gsub(/\)\z/, '')
         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,7 +59,7 @@ 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)
@@ -77,16 +78,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 +85,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)

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

@@ -28,28 +28,30 @@ 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
+
         def_node_matcher :nil_comparison?, '(send _ {:== :===} nil)'
         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
 
-        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) }
+              corrector.replace(node, new_code)
+            end
+          end
         end
 
         private

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

@@ -38,7 +38,11 @@ module RuboCop
       #   if !x.nil?
       #   end
       #
-      class NonNilCheck < Cop
+      class NonNilCheck < Base
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[!= nil? !].freeze
+
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
         def_node_matcher :nil_check?, '(send _ :nil?)'
@@ -46,12 +50,11 @@ module RuboCop
 
         def on_send(node)
           return if ignored_node?(node)
+          return unless (offense_node = find_offense_node(node))
 
-          if not_equal_to_nil?(node)
-            add_offense(node, location: :selector)
-          elsif include_semantic_changes? &&
-                (not_and_nil_check?(node) || unless_and_nil_check?(node))
-            add_offense(node)
+          message = message(node)
+          add_offense(offense_node, message: message) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 
@@ -68,19 +71,28 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
+        private
+
+        def find_offense_node(node)
+          if not_equal_to_nil?(node)
+            node.loc.selector
+          elsif include_semantic_changes? &&
+                (not_and_nil_check?(node) || unless_and_nil_check?(node))
+            node
+          end
+        end
+
+        def autocorrect(corrector, node)
           case node.method_name
           when :!=
-            autocorrect_comparison(node)
+            autocorrect_comparison(corrector, node)
           when :!
-            autocorrect_non_nil(node, node.receiver)
+            autocorrect_non_nil(corrector, node, node.receiver)
           when :nil?
-            autocorrect_unless_nil(node, node.receiver)
+            autocorrect_unless_nil(corrector, node, node.receiver)
           end
         end
 
-        private
-
         def unless_and_nil_check?(send_node)
           parent = send_node.parent
 
@@ -100,7 +112,7 @@ module RuboCop
           cop_config['IncludeSemanticChanges']
         end
 
-        def autocorrect_comparison(node)
+        def autocorrect_comparison(corrector, node)
           expr = node.source
 
           new_code = if include_semantic_changes?
@@ -111,24 +123,20 @@ module RuboCop
 
           return if expr == new_code
 
-          ->(corrector) { corrector.replace(node, new_code) }
+          corrector.replace(node, new_code)
         end
 
-        def autocorrect_non_nil(node, inner_node)
-          lambda do |corrector|
-            if inner_node.receiver
-              corrector.replace(node, inner_node.receiver.source)
-            else
-              corrector.replace(node, 'self')
-            end
+        def autocorrect_non_nil(corrector, node, inner_node)
+          if inner_node.receiver
+            corrector.replace(node, inner_node.receiver.source)
+          else
+            corrector.replace(node, 'self')
           end
         end
 
-        def autocorrect_unless_nil(node, receiver)
-          lambda do |corrector|
-            corrector.replace(node.parent.loc.keyword, 'if')
-            corrector.replace(node, receiver.source)
-          end
+        def autocorrect_unless_nil(corrector, node, receiver)
+          corrector.replace(node.parent.loc.keyword, 'if')
+          corrector.replace(node, receiver.source)
         end
       end
     end

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

@@ -13,10 +13,12 @@ module RuboCop
       #   # good
       #   x = !something
       #
-      class Not < Cop
+      class Not < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `!` instead of `not`.'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         OPPOSITE_METHODS = {
           :== => :!=,
@@ -30,19 +32,16 @@ module RuboCop
         def on_send(node)
           return unless node.prefix_not?
 
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          range = range_with_surrounding_space(range: node.loc.selector,
-                                               side: :right)
+          add_offense(node.loc.selector) do |corrector|
+            range = range_with_surrounding_space(range: node.loc.selector, side: :right)
 
-          if opposite_method?(node.receiver)
-            correct_opposite_method(range, node.receiver)
-          elsif requires_parens?(node.receiver)
-            correct_with_parens(range, node)
-          else
-            correct_without_parens(range)
+            if opposite_method?(node.receiver)
+              correct_opposite_method(corrector, range, node.receiver)
+            elsif requires_parens?(node.receiver)
+              correct_with_parens(corrector, range, node)
+            else
+              correct_without_parens(corrector, range)
+            end
           end
         end
 
@@ -58,23 +57,18 @@ module RuboCop
             child.if_type? && child.ternary?
         end
 
-        def correct_opposite_method(range, child)
-          lambda do |corrector|
-            corrector.remove(range)
-            corrector.replace(child.loc.selector,
-                              OPPOSITE_METHODS[child.method_name].to_s)
-          end
+        def correct_opposite_method(corrector, range, child)
+          corrector.remove(range)
+          corrector.replace(child.loc.selector, OPPOSITE_METHODS[child.method_name].to_s)
         end
 
-        def correct_with_parens(range, node)
-          lambda do |corrector|
-            corrector.replace(range, '!(')
-            corrector.insert_after(node, ')')
-          end
+        def correct_with_parens(corrector, range, node)
+          corrector.replace(range, '!(')
+          corrector.insert_after(node, ')')
         end
 
-        def correct_without_parens(range)
-          ->(corrector) { corrector.replace(range, '!') }
+        def correct_without_parens(corrector, range)
+          corrector.replace(range, '!')
         end
       end
     end

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

@@ -33,8 +33,9 @@ module RuboCop
       #
       #   # good
       #   num = 01234
-      class NumericLiteralPrefix < Cop
+      class NumericLiteralPrefix < Base
         include IntegerNode
+        extend AutoCorrector
 
         OCTAL_ZERO_ONLY_REGEX = /^0[Oo][0-7]+$/.freeze
         OCTAL_REGEX = /^0O?[0-7]+$/.freeze
@@ -53,14 +54,8 @@ module RuboCop
 
           return unless type
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            type = literal_type(node)
-            corrector.replace(node,
-                              send(:"format_#{type}", node.source))
+          add_offense(node) do |corrector|
+            corrector.replace(node, send(:"format_#{type}", node.source))
           end
         end
 

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

@@ -41,9 +41,10 @@ module RuboCop
       #   foo == 0
       #   0 > foo
       #   bar.baz > 0
-      class NumericPredicate < Cop
+      class NumericPredicate < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -53,11 +54,9 @@ module RuboCop
           'negative?' => '<'
         }.freeze
 
-        COMPARISON_METHODS = %i[== > < positive? negative? zero?].to_set.freeze
+        RESTRICT_ON_SEND = %i[== > < positive? negative? zero?].freeze
 
         def on_send(node)
-          return unless COMPARISON_METHODS.include?(node.method_name)
-
           numeric, replacement = check(node)
           return unless numeric
 
@@ -66,16 +65,8 @@ module RuboCop
                       ignored_method?(ancestor.method_name)
                     end
 
-          add_offense(node,
-                      message: format(MSG,
-                                      prefer: replacement,
-                                      current: node.source))
-        end
-
-        def autocorrect(node)
-          _, replacement = check(node)
-
-          lambda do |corrector|
+          message = format(MSG, prefer: replacement, current: node.source)
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node, replacement)
           end
         end

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

@@ -3,39 +3,48 @@
 module RuboCop
   module Cop
     module Style
-      # TODO: Make configurable.
-      # Checks for uses of if/then/else/end on a single line.
+      # Checks for uses of if/then/else/end constructs on a single line.
+      # AlwaysCorrectToMultiline config option can be set to true to auto-convert all offenses to
+      # multi-line constructs. When AlwaysCorrectToMultiline is false (default case) the
+      # auto-correct will first try converting them to ternary operators.
       #
       # @example
       #   # bad
-      #   if foo then boo else doo end
-      #   unless foo then boo else goo end
+      #   if foo then bar else baz end
+      #
+      #   # bad
+      #   unless foo then baz else bar end
       #
       #   # good
-      #   foo ? boo : doo
-      #   boo if foo
-      #   if foo then boo end
+      #   foo ? bar : baz
+      #
+      #   # good
+      #   bar if foo
+      #
+      #   # good
+      #   if foo then bar end
       #
       #   # good
       #   if foo
-      #     boo
+      #     bar
       #   else
-      #     doo
+      #     baz
       #   end
-      class OneLineConditional < Cop
+      class OneLineConditional < Base
+        include ConfigurableEnforcedStyle
         include OnNormalIfUnless
+        extend AutoCorrector
 
-        MSG = 'Favor the ternary operator (`?:`) ' \
-              'over `%<keyword>s/then/else/end` constructs.'
+        MSG = 'Favor the ternary operator (`?:`) or multi-line constructs ' \
+              'over single-line `%<keyword>s/then/else/end` constructs.'
 
         def on_normal_if_unless(node)
-          return unless node.single_line? && node.else_branch
-
-          add_offense(node)
-        end
+          return unless node.single_line?
+          return unless node.else_branch
+          return if node.elsif?
 
-        def autocorrect(node)
-          lambda do |corrector|
+          message = message(node)
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node, replacement(node))
           end
         end
@@ -47,16 +56,57 @@ module RuboCop
         end
 
         def replacement(node)
-          return to_ternary(node) unless node.parent
+          if always_multiline? || cannot_replace_to_ternary?(node)
+            multiline_replacement(node)
+          else
+            replaced_node = ternary_replacement(node)
+            return replaced_node unless node.parent
+            return "(#{replaced_node})" if %i[and or].include?(node.parent.type)
+            return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
+
+            replaced_node
+          end
+        end
+
+        def always_multiline?
+          @config.for_cop('Style/OneLineConditional')['AlwaysCorrectToMultiline']
+        end
+
+        def cannot_replace_to_ternary?(node)
+          node.elsif_conditional?
+        end
 
-          return "(#{to_ternary(node)})" if %i[and or].include?(node.parent.type)
+        def multiline_replacement(node, indentation = nil)
+          indentation = ' ' * node.source_range.column if indentation.nil?
+          if_branch_source = node.if_branch&.source || 'nil'
+          elsif_indentation = indentation if node.respond_to?(:elsif?) && node.elsif?
+          if_branch = <<~RUBY
+            #{elsif_indentation}#{node.keyword} #{node.condition.source}
+            #{indentation}#{branch_body_indentation}#{if_branch_source}
+          RUBY
+          else_branch = else_branch_to_multiline(node.else_branch, indentation)
+          if_branch + else_branch
+        end
 
-          return "(#{to_ternary(node)})" if node.parent.send_type? && node.parent.operator_method?
+        def else_branch_to_multiline(else_branch, indentation)
+          if else_branch.nil?
+            'end'
+          elsif else_branch.if_type? && else_branch.elsif?
+            multiline_replacement(else_branch, indentation)
+          else
+            <<~RUBY.chomp
+              #{indentation}else
+              #{indentation}#{branch_body_indentation}#{else_branch.source}
+              #{indentation}end
+            RUBY
+          end
+        end
 
-          to_ternary(node)
+        def branch_body_indentation
+          ' ' * (@config.for_cop('Layout/IndentationWidth')['Width'] || 2)
         end
 
-        def to_ternary(node)
+        def ternary_replacement(node)
           condition, if_branch, else_branch = *node
 
           "#{expr_replacement(condition)} ? " \