rubocop 0.89.1 → 0.93.0

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

@@ -43,8 +43,8 @@ module RuboCop
           'Modifier form of `%<keyword>s` makes the line too long.'
 
         def on_if(node)
-          msg = if single_line_as_modifier?(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
@@ -157,10 +157,6 @@ module RuboCop
             #{indentation}end
           RUBY
         end
-
-        def first_line_comment(node)
-          processed_source.comment_at_line(node.loc.line)&.text
-        end
       end
     end
   end

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

@@ -17,6 +17,7 @@ module RuboCop
       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/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_call.rb

@@ -22,8 +22,10 @@ module RuboCop
         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) && opposite_style_detected
             add_offense(node) do |corrector|

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

@@ -8,10 +8,19 @@ module RuboCop
       # when reading code.
       #
       # @example
-      #
+      #   # bad
       #   a do
       #     b
       #   end.c
+      #
+      #   # good
+      #   a { b }.c
+      #
+      #   # good
+      #   foo = a do
+      #     b
+      #   end
+      #   foo.c
       class MethodCalledOnDoEndBlock < Base
         include RangeHelp
 

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

@@ -140,16 +140,12 @@ module RuboCop
         def missing_parentheses(node)
           location = node.arguments.source_range
 
-          return unless unexpected_style_detected(:require_no_parentheses)
-
           add_offense(location, message: MSG_MISSING) do |corrector|
             correct_definition(node, corrector)
           end
         end
 
         def unwanted_parentheses(args)
-          return unless unexpected_style_detected(:require_parentheses)
-
           add_offense(args, message: MSG_PRESENT) do |corrector|
             # offense is registered on args node when parentheses are unwanted
             correct_arguments(args, corrector)

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

@@ -43,47 +43,28 @@ module RuboCop
       class MixinUsage < Base
         MSG = '`%<statement>s` is used at the top level. Use inside `class` ' \
               'or `module`.'
+        RESTRICT_ON_SEND = %i[include extend prepend].freeze
 
         def_node_matcher :include_statement, <<~PATTERN
           (send nil? ${:include :extend :prepend}
             const)
         PATTERN
 
-        def_node_matcher :wrapped_macro_scope?, <<~PATTERN
-          {({sclass class module block} ... ({begin if} ...))}
+        def_node_matcher :in_top_level_scope?, <<~PATTERN
+          {
+            root?                        # either at the top level
+            ^[  {kwbegin begin if def}   # or wrapped within one of these
+                #in_top_level_scope? ]   # that is in top level scope
+          }
         PATTERN
 
         def on_send(node)
           include_statement(node) do |statement|
-            return if node.argument? ||
-                      accepted_include?(node) ||
-                      belongs_to_class_or_module?(node)
+            return unless in_top_level_scope?(node)
 
             add_offense(node, message: format(MSG, statement: statement))
           end
         end
-
-        private
-
-        def accepted_include?(node)
-          node.parent && (node.macro? || ascend_macro_scope?(node.parent))
-        end
-
-        def ascend_macro_scope?(ancestor)
-          return true if wrapped_macro_scope?(ancestor)
-
-          ancestor.parent && ascend_macro_scope?(ancestor.parent)
-        end
-
-        def belongs_to_class_or_module?(node)
-          if !node.parent
-            false
-          else
-            return true if node.parent.class_type? || node.parent.module_type?
-
-            belongs_to_class_or_module?(node.parent)
-          end
-        end
       end
     end
   end

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

@@ -22,7 +22,7 @@ module RuboCop
       #   alive_threads.map do |t|
       #     t.object_id
       #   end
-      class MultilineBlockChain < Cop
+      class MultilineBlockChain < Base
         include RangeHelp
 
         MSG = 'Avoid multi-line chains of blocks.'
@@ -36,7 +36,7 @@ module RuboCop
             range = range_between(receiver.loc.end.begin_pos,
                                   node.send_node.source_range.end_pos)
 
-            add_offense(nil, location: range)
+            add_offense(range)
 
             # Done. If there are more blocks in the chain, they will be
             # found by subsequent calls to on_block.

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # This cop checks for multi-line ternary op expressions.
       #
+      # NOTE: `return if ... else ... end` is syntax error. If `return` is used before
+      # multiline ternary operator expression, it cannot be auto-corrected.
+      #
       # @example
       #   # bad
       #   a = cond ?
@@ -29,9 +32,13 @@ module RuboCop
               'use `if` or `unless` instead.'
 
         def on_if(node)
-          return unless node.ternary? && node.multiline?
+          return unless offense?(node)
 
           add_offense(node) do |corrector|
+            # `return if ... else ... end` is syntax error. If `return` is used before
+            # multiline ternary operator expression, it cannot be auto-corrected.
+            next unless offense?(node) && !node.parent.return_type?
+
             corrector.replace(node, <<~RUBY.chop)
               if #{node.condition.source}
                 #{node.if_branch.source}
@@ -41,6 +48,12 @@ module RuboCop
             RUBY
           end
         end
+
+        private
+
+        def offense?(node)
+          node.ternary? && node.multiline?
+        end
       end
     end
   end

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

@@ -44,7 +44,7 @@ module RuboCop
           # Requires `then` for write `when` and its body on the same line.
           return if require_then?(node)
 
-          # With more than one statements after then, there's not offense
+          # For arrays and hashes there's no offense
           return if accept_node_type?(node.body)
 
           range = node.loc.begin
@@ -58,13 +58,14 @@ module RuboCop
         private
 
         def require_then?(when_node)
+          return true if when_node.conditions.count >= 2
           return false unless when_node.body
 
           when_node.loc.line == when_node.body.loc.line
         end
 
         def accept_node_type?(node)
-          node&.begin_type? || node&.array_type? || node&.hash_type?
+          node&.array_type? || node&.hash_type?
         end
       end
     end

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

@@ -68,19 +68,19 @@ module RuboCop
       #   if !foo
       #     bar
       #   end
-      class NegatedIf < Cop
+      class NegatedIf < Base
         include ConfigurableEnforcedStyle
         include NegativeConditional
+        extend AutoCorrector
 
         def on_if(node)
           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)
+          message = message(node)
+          check_negative_conditional(node, message: message) do |corrector|
+            ConditionCorrector.correct_negative_condition(corrector, node)
+          end
         end
 
         private

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

@@ -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

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,27 @@ 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) do |corrector|
+            autocorrect(corrector, node)
+          end
           ignore_node(node)
         end
 
@@ -42,15 +41,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)

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

@@ -12,9 +12,10 @@ 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`.'
 
@@ -24,14 +25,17 @@ module RuboCop
           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
 
@@ -41,14 +45,10 @@ module RuboCop
                                          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? ||