rubocop 0.88.0 → 0.91.1

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,53 @@
+# 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 = node.right_siblings.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
+
+        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

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

@@ -46,8 +46,9 @@ module RuboCop
       #   f = ->(x) do
       #         x
       #       end
-      class Lambda < Cop
+      class Lambda < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for ' \
                           '%<modifier>s lambdas.'
@@ -69,21 +70,15 @@ module RuboCop
 
           return unless offending_selector?(node, selector)
 
-          add_offense(node,
-                      location: node.send_node.source_range,
-                      message: message(node, selector))
-        end
-        alias on_numblock on_block
-
-        def autocorrect(node)
-          if node.send_node.source == 'lambda'
-            lambda do |corrector|
+          add_offense(node.send_node.source_range, message: message(node, selector)) do |corrector|
+            if node.send_node.source == 'lambda'
               autocorrect_method_to_literal(corrector, node)
+            else
+              LambdaLiteralToMethodCorrector.new(node).call(corrector)
             end
-          else
-            LambdaLiteralToMethodCorrector.new(node)
           end
         end
+        alias on_numblock on_block
 
         private
 

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

@@ -18,30 +18,33 @@ module RuboCop
       #
       #  # good
       #  lambda.(x, y)
-      class LambdaCall < Cop
+      class LambdaCall < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[call].freeze
 
         def on_send(node)
-          return unless node.receiver && node.method?(:call)
+          return unless node.receiver
 
-          if offense?(node)
-            add_offense(node) { opposite_style_detected }
+          if offense?(node) && opposite_style_detected
+            add_offense(node) do |corrector|
+              autocorrect(corrector, node)
+            end
           else
             correct_style_detected
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if explicit_style?
-              receiver = node.receiver.source
-              replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
+        def autocorrect(corrector, node)
+          if explicit_style?
+            receiver = node.receiver.source
+            replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
 
-              corrector.replace(node, replacement)
-            else
-              add_parentheses(node, corrector) unless node.parenthesized?
-              corrector.remove(node.loc.selector)
-            end
+            corrector.replace(node, replacement)
+          else
+            add_parentheses(node, corrector) unless node.parenthesized?
+            corrector.remove(node.loc.selector)
           end
         end
 

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

@@ -19,8 +19,9 @@ module RuboCop
       #   some_str = 'ala' \
       #              'bala'
       #
-      class LineEndConcatenation < Cop
+      class LineEndConcatenation < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `\\` instead of `+` or `<<` to concatenate ' \
               'those strings.'
@@ -36,25 +37,12 @@ module RuboCop
           [Style::RedundantInterpolation]
         end
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.tokens.each_index do |index|
             check_token_set(index)
           end
         end
 
-        def autocorrect(operator_range)
-          # Include any trailing whitespace so we don't create a syntax error.
-          operator_range = range_with_surrounding_space(range: operator_range,
-                                                        side: :right,
-                                                        newlines: false)
-          one_more_char = operator_range.resize(operator_range.size + 1)
-          # Don't create a double backslash at the end of the line, in case
-          # there already was a backslash after the concatenation operator.
-          operator_range = one_more_char if one_more_char.source.end_with?('\\')
-
-          ->(corrector) { corrector.replace(operator_range, '\\') }
-        end
-
         private
 
         def check_token_set(index)
@@ -68,7 +56,22 @@ module RuboCop
 
           return unless eligible_next_successor?(next_successor)
 
-          add_offense(operator.pos, location: operator.pos)
+          add_offense(operator.pos) do |corrector|
+            autocorrect(corrector, operator.pos)
+          end
+        end
+
+        def autocorrect(corrector, operator_range)
+          # Include any trailing whitespace so we don't create a syntax error.
+          operator_range = range_with_surrounding_space(range: operator_range,
+                                                        side: :right,
+                                                        newlines: false)
+          one_more_char = operator_range.resize(operator_range.size + 1)
+          # Don't create a double backslash at the end of the line, in case
+          # there already was a backslash after the concatenation operator.
+          operator_range = one_more_char if one_more_char.source.end_with?('\\')
+
+          corrector.replace(operator_range, '\\')
         end
 
         def eligible_token_set?(predecessor, operator, successor)

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

@@ -143,10 +143,11 @@ module RuboCop
       #
       #   # good
       #   Array 1
-      class MethodCallWithArgsParentheses < Cop
+      class MethodCallWithArgsParentheses < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
         include IgnoredPattern
+        extend AutoCorrector
 
         def initialize(*)
           super

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -15,14 +15,7 @@ module RuboCop
             return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
 
-            add_offense(node, location: node.loc.begin.join(node.loc.end))
-          end
-          alias on_csend on_send
-          alias on_super on_send
-          alias on_yield on_send
-
-          def autocorrect(node)
-            lambda do |corrector|
+            add_offense(offense_range(node)) do |corrector|
               if parentheses_at_the_end_of_multiline_call?(node)
                 corrector.replace(args_begin(node), ' \\')
               else
@@ -31,13 +24,20 @@ module RuboCop
               corrector.remove(node.loc.end)
             end
           end
+          alias on_csend on_send
+          alias on_super on_send
+          alias on_yield on_send
+
+          private
+
+          def offense_range(node)
+            node.loc.begin.join(node.loc.end)
+          end
 
-          def message(_node = nil)
+          def message(_range = nil)
             'Omit parentheses for method calls with arguments.'
           end
 
-          private
-
           def super_call_without_arguments?(node)
             node.super_type? && node.arguments.none?
           end
@@ -60,6 +60,7 @@ module RuboCop
               call_with_ambiguous_arguments?(node) ||
               call_in_logical_operators?(node) ||
               call_in_optional_arguments?(node) ||
+              call_in_single_line_inheritance?(node) ||
               allowed_multiline_call_with_parentheses?(node) ||
               allowed_chained_call_with_parentheses?(node)
           end
@@ -86,6 +87,10 @@ module RuboCop
               (node.parent.optarg_type? || node.parent.kwoptarg_type?)
           end
 
+          def call_in_single_line_inheritance?(node)
+            node.parent&.class_type? && node.parent&.single_line?
+          end
+
           def call_with_ambiguous_arguments?(node)
             call_with_braced_block?(node) ||
               call_as_argument_or_chain?(node) ||

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -12,19 +12,15 @@ module RuboCop
             return if eligible_for_parentheses_omission?(node)
             return unless node.arguments? && !node.parenthesized?
 
-            add_offense(node)
-          end
-          alias on_csend on_send
-          alias on_super on_send
-          alias on_yield on_send
-
-          def autocorrect(node)
-            lambda do |corrector|
+            add_offense(node) do |corrector|
               corrector.replace(args_begin(node), '(')
 
               corrector.insert_after(args_end(node), ')') unless args_parenthesized?(node)
             end
           end
+          alias on_csend on_send
+          alias on_super on_send
+          alias on_yield on_send
 
           def message(_node = nil)
             'Use parentheses for method calls with arguments.'

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

@@ -11,23 +11,20 @@ module RuboCop
       #
       #   # good
       #   object.some_method
-      class MethodCallWithoutArgsParentheses < Cop
+      class MethodCallWithoutArgsParentheses < Base
         include IgnoredMethods
+        extend AutoCorrector
 
         MSG = 'Do not use parentheses for method calls with ' \
               'no arguments.'
 
         def on_send(node)
-          return if ineligible_node?(node)
           return unless !node.arguments? && node.parenthesized?
+          return if ineligible_node?(node)
           return if ignored_method?(node.method_name)
           return if same_name_assignment?(node)
 
-          add_offense(node, location: node.loc.begin.join(node.loc.end))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(offense_range(node)) do |corrector|
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)
           end
@@ -69,6 +66,10 @@ module RuboCop
 
           var_nodes.any? { |n| n.to_a.first == variable_name }
         end
+
+        def offense_range(node)
+          node.loc.begin.join(node.loc.end)
+        end
       end
     end
   end