rubocop 0.87.1 → 0.91.0

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

@@ -62,7 +62,7 @@ module RuboCop
       #     do_x
       #     do_z
       #   end
-      class IdenticalConditionalBranches < Cop
+      class IdenticalConditionalBranches < Base
         MSG = 'Move `%<source>s` out of the conditional.'
 
         def on_if(node)
@@ -81,7 +81,7 @@ module RuboCop
 
         private
 
-        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity
+        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
           return if branches.any?(&:nil?)

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

@@ -58,10 +58,10 @@ module RuboCop
       #     action_b
       #   end
       #
-      class IfInsideElse < Cop
+      class IfInsideElse < Base
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
-        def on_if(node) # rubocop:todo Metrics/CyclomaticComplexity
+        def on_if(node)
           return if node.ternary? || node.unless?
 
           else_branch = node.else_branch
@@ -69,7 +69,7 @@ module RuboCop
           return unless else_branch&.if_type? && else_branch&.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
 
-          add_offense(else_branch, location: :keyword)
+          add_offense(else_branch.loc.keyword)
         end
 
         private

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

@@ -30,10 +30,11 @@ module RuboCop
       #   if long_condition
       #     do_something_in_a_method_with_a_long_name(arg)
       #   end
-      class IfUnlessModifier < Cop
+      class IfUnlessModifier < Base
         include StatementModifier
         include LineLengthHelp
         include IgnoredPattern
+        extend AutoCorrector
 
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
                            'single-line body. Another good alternative is ' \
@@ -41,33 +42,30 @@ module RuboCop
         MSG_USE_NORMAL =
           'Modifier form of `%<keyword>s` makes the line too long.'
 
-        ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
-                              gvasgn ivasgn masgn].freeze
-
         def on_if(node)
-          msg = if eligible_node?(node)
-                  MSG_USE_MODIFIER unless named_capture_in_condition?(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
 
-          add_offense(node,
-                      location: :keyword,
-                      message: format(msg, keyword: node.keyword))
+          add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           replacement = if node.modifier_form?
                           to_normal_form(node)
                         else
                           to_modifier_form(node)
                         end
-          ->(corrector) { corrector.replace(node, replacement) }
+          corrector.replace(node, replacement)
         end
 
-        private
-
         def too_long_due_to_modifier?(node)
           node.modifier_form? && too_long_single_line?(node) &&
             !another_statement_on_same_line?(node)
@@ -125,13 +123,15 @@ module RuboCop
           node.condition.match_with_lvasgn_type?
         end
 
-        def eligible_node?(node)
-          !non_eligible_if?(node) && !node.chained? &&
-            !node.nested_conditional? && single_line_as_modifier?(node)
+        def non_eligible_node?(node)
+          non_simple_if_unless?(node) ||
+            node.chained? ||
+            node.nested_conditional? ||
+            super
         end
 
-        def non_eligible_if?(node)
-          node.ternary? || node.modifier_form? || node.elsif? || node.else?
+        def non_simple_if_unless?(node)
+          node.ternary? || node.elsif? || node.else?
         end
 
         def another_statement_on_same_line?(node)
@@ -149,25 +149,6 @@ module RuboCop
             sibling.source_range.first_line == line_no
         end
 
-        def parenthesize?(node)
-          # Parenthesize corrected expression if changing to modifier-if form
-          # would change the meaning of the parent expression
-          # (due to the low operator precedence of modifier-if)
-          return false if node.parent.nil?
-          return true if ASSIGNMENT_TYPES.include?(node.parent.type)
-
-          node.parent.send_type? && !node.parent.parenthesized?
-        end
-
-        def to_modifier_form(node)
-          expression = [node.body.source,
-                        node.keyword,
-                        node.condition.source,
-                        first_line_comment(node)].compact.join(' ')
-
-          parenthesize?(node) ? "(#{expression})" : expression
-        end
-
         def to_normal_form(node)
           indentation = ' ' * node.source_range.column
           <<~RUBY.chomp
@@ -178,10 +159,7 @@ module RuboCop
         end
 
         def first_line_comment(node)
-          comment =
-            processed_source.find_comment { |c| c.loc.line == node.loc.line }
-
-          comment ? comment.loc.expression.source : nil
+          processed_source.comment_at_line(node.loc.line)&.text
         end
       end
     end

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

@@ -22,20 +22,16 @@ module RuboCop
       #  if running?
       #    tired? ? 'stop' : 'go faster'
       #  end
-      class IfUnlessModifierOfIfUnless < Cop
+      class IfUnlessModifierOfIfUnless < Base
         include StatementModifier
+        extend AutoCorrector
 
         MSG = 'Avoid modifier `%<keyword>s` after another conditional.'
 
         def on_if(node)
           return unless node.modifier_form? && node.body.if_type?
 
-          add_offense(node, location: :keyword,
-                            message: format(MSG, keyword: node.keyword))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
             keyword = node.if? ? 'if' : 'unless'
 
             corrector.replace(node, <<~RUBY.chop)

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

@@ -13,8 +13,9 @@ module RuboCop
       #   # good
       #   result = some_condition ? something : another_thing
       #
-      class IfWithSemicolon < Cop
+      class IfWithSemicolon < Base
         include OnNormalIfUnless
+        extend AutoCorrector
 
         MSG = 'Do not use if x; Use the ternary operator instead.'
 
@@ -24,11 +25,7 @@ module RuboCop
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             corrector.replace(node, correct_to_ternary(node))
           end
         end

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

@@ -14,9 +14,10 @@ module RuboCop
       #
       #   # good
       #   raise ArgumentError, 'Error message here'
-      class ImplicitRuntimeError < Cop
+      class ImplicitRuntimeError < Base
         MSG = 'Use `%<method>s` with an explicit exception class and message,' \
               ' rather than just a message.'
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         def_node_matcher :implicit_runtime_error_raise_or_fail,
                          '(send nil? ${:raise :fail} {str dstr})'

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

@@ -15,13 +15,15 @@ module RuboCop
       #   loop do
       #     work
       #   end
-      class InfiniteLoop < Cop
+      class InfiniteLoop < Base
+        extend AutoCorrector
+
         LEADING_SPACE = /\A(\s*)/.freeze
 
         MSG = 'Use `Kernel#loop` for infinite loops.'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
@@ -40,16 +42,6 @@ module RuboCop
         alias on_while_post on_while
         alias on_until_post on_until
 
-        def autocorrect(node)
-          if node.while_post_type? || node.until_post_type?
-            replace_begin_end_with_modifier(node)
-          elsif node.modifier_form?
-            replace_source(node.source_range, modifier_replacement(node))
-          else
-            replace_source(non_modifier_range(node), 'loop do')
-          end
-        end
-
         private
 
         def while_or_until(node)
@@ -66,7 +58,19 @@ module RuboCop
             referenced_after_loop?(var, range)
           end
 
-          add_offense(node, location: :keyword)
+          add_offense(node.loc.keyword) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          if node.while_post_type? || node.until_post_type?
+            replace_begin_end_with_modifier(corrector, node)
+          elsif node.modifier_form?
+            replace_source(corrector, node.source_range, modifier_replacement(node))
+          else
+            replace_source(corrector, non_modifier_range(node), 'loop do')
+          end
         end
 
         def assigned_inside_loop?(var, range)
@@ -83,23 +87,19 @@ module RuboCop
           var.references.any? { |r| r.node.source_range.begin_pos > e }
         end
 
-        def replace_begin_end_with_modifier(node)
-          lambda do |corrector|
-            corrector.replace(node.body.loc.begin, 'loop do')
-            corrector.remove(node.body.loc.end.end.join(node.source_range.end))
-          end
+        def replace_begin_end_with_modifier(corrector, node)
+          corrector.replace(node.body.loc.begin, 'loop do')
+          corrector.remove(node.body.loc.end.end.join(node.source_range.end))
         end
 
-        def replace_source(range, replacement)
-          lambda do |corrector|
-            corrector.replace(range, replacement)
-          end
+        def replace_source(corrector, range, replacement)
+          corrector.replace(range, replacement)
         end
 
         def modifier_replacement(node)
           body = node.body
           if node.single_line?
-            'loop { ' + body.source + ' }'
+            "loop { #{body.source} }"
           else
             indentation = body.source_range.source_line[LEADING_SPACE]
 

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

@@ -17,11 +17,11 @@ module RuboCop
       #   foo.each do |f|
       #     f.bar # Trailing inline comment
       #   end
-      class InlineComment < Cop
+      class InlineComment < Base
         MSG = 'Avoid trailing inline comments.'
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
+        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)/)
 

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

@@ -33,9 +33,10 @@ module RuboCop
       #     next if f.zero?
       #     f != 1
       #   end
-      class InverseMethods < Cop
+      class InverseMethods < Base
         include IgnoredNode
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'
         CLASS_COMPARISON_METHODS = %i[<= >= < >].freeze
@@ -64,16 +65,15 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if part_of_ignored_node?(node)
-
           inverse_candidate?(node) do |_method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
-            return if possible_class_hierarchy_check?(lhs, rhs, method)
             return if negated?(node)
+            return if part_of_ignored_node?(node)
+            return if possible_class_hierarchy_check?(lhs, rhs, method)
 
-            add_offense(node,
-                        message: format(MSG, method: method,
-                                             inverse: inverse_methods[method]))
+            add_offense(node, message: message(method, inverse_methods[method])) do |corrector|
+              correct_inverse_method(corrector, node)
+            end
           end
         end
 
@@ -87,40 +87,28 @@ module RuboCop
             # offense, such as `y.reject { |key, _value| !(key =~ /c\d/) }`,
             # can cause auto-correction to apply improper corrections.
             ignore_node(block)
-            add_offense(node,
-                        message: format(MSG, method: method,
-                                             inverse: inverse_blocks[method]))
+            add_offense(node, message: message(method, inverse_blocks[method])) do |corrector|
+              correct_inverse_block(corrector, node)
+            end
           end
         end
 
-        def autocorrect(node)
-          if node.block_type?
-            correct_inverse_block(node)
-          elsif node.send_type?
-            correct_inverse_method(node)
-          end
-        end
+        private
 
-        def correct_inverse_method(node)
+        def correct_inverse_method(corrector, node)
           method_call, _lhs, method, _rhs = inverse_candidate?(node)
           return unless method_call && method
 
-          lambda do |corrector|
-            corrector.remove(not_to_receiver(node, method_call))
-            corrector.replace(method_call.loc.selector,
-                              inverse_methods[method].to_s)
-            remove_end_parenthesis(corrector, node, method, method_call)
-          end
+          corrector.remove(not_to_receiver(node, method_call))
+          corrector.replace(method_call.loc.selector, inverse_methods[method].to_s)
+          remove_end_parenthesis(corrector, node, method, method_call)
         end
 
-        def correct_inverse_block(node)
+        def correct_inverse_block(corrector, node)
           method_call, method, block = inverse_block?(node)
 
-          lambda do |corrector|
-            corrector.replace(method_call.loc.selector,
-                              inverse_blocks[method].to_s)
-            correct_inverse_selector(block, corrector)
-          end
+          corrector.replace(method_call.loc.selector, inverse_blocks[method].to_s)
+          correct_inverse_selector(block, corrector)
         end
 
         def correct_inverse_selector(block, corrector)
@@ -140,8 +128,6 @@ module RuboCop
           end
         end
 
-        private
-
         def inverse_methods
           @inverse_methods ||= cop_config['InverseMethods']
                                .merge(cop_config['InverseMethods'].invert)
@@ -191,6 +177,10 @@ module RuboCop
 
           corrector.remove(end_parentheses(node, method_call))
         end
+
+        def message(method, inverse)
+          format(MSG, method: method, inverse: inverse)
+        end
       end
     end
   end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces that optional keyword parameters are placed at the
+      # end of the parameters list.
+      #
+      # This improves readability, because when looking through the source,
+      # it is expected to find required parameters at the beginning of parameters list
+      # and optional parameters at the end.
+      #
+      # @example
+      #   # bad
+      #   def some_method(first: false, second:, third: 10)
+      #     # body omitted
+      #   end
+      #
+      #   # good
+      #   def some_method(second:, first: false, third: 10)
+      #     # body omitted
+      #   end
+      #
+      class KeywordParametersOrder < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Place optional keyword parameters at the end of the parameters list.'
+
+        def on_kwoptarg(node)
+          kwarg_nodes = right_siblings_of(node).select(&:kwarg_type?)
+          return if kwarg_nodes.empty?
+
+          add_offense(node) do |corrector|
+            if node.parent.find(&:kwoptarg_type?) == node
+              corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+              remove_kwargs(kwarg_nodes, corrector)
+            end
+          end
+        end
+
+        private
+
+        # TODO: Use API from `rubocop-ast` when released.
+        def right_siblings_of(node)
+          node.parent.children[node.sibling_index + 1..-1]
+        end
+
+        def remove_kwargs(kwarg_nodes, corrector)
+          kwarg_nodes.each do |kwarg|
+            with_space = range_with_surrounding_space(range: kwarg.source_range)
+            corrector.remove(range_with_surrounding_comma(with_space, :left))
+          end
+        end
+      end
+    end
+  end
+end