rubocop 0.51.0 → 0.52.0

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

@@ -8,10 +8,7 @@ module RuboCop
       # It is configurable to enforce one of the styles for both single line
       # and multiline lambdas as well.
       #
-      # @example
-      #
-      #   # EnforcedStyle: line_count_dependent (default)
-      #
+      # @example EnforcedStyle: line_count_dependent (default)
       #   # bad
       #   f = lambda { |x| x }
       #   f = ->(x) do
@@ -24,10 +21,7 @@ module RuboCop
       #         x
       #       end
       #
-      # @example
-      #
-      #   # EnforcedStyle: lambda
-      #
+      # @example EnforcedStyle: lambda
       #   # bad
       #   f = ->(x) { x }
       #   f = ->(x) do
@@ -40,10 +34,7 @@ module RuboCop
       #         x
       #       end
       #
-      # @example
-      #
-      #   # EnforcedStyle: literal
-      #
+      # @example EnforcedStyle: literal
       #   # bad
       #   f = lambda { |x| x }
       #   f = lambda do |x|
@@ -59,8 +50,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for ' \
-                          '%s lambdas.'.freeze
-        METHOD_MESSAGE = 'Use the `lambda` method for %s lambdas.'.freeze
+                          '%<modifier>s lambdas.'.freeze
+        METHOD_MESSAGE = 'Use the `lambda` method for %<modifier>s ' \
+                         'lambdas.'.freeze
 
         OFFENDING_SELECTORS = {
           style: {
@@ -84,6 +76,22 @@ module RuboCop
                       message: message(node, selector))
         end
 
+        def autocorrect(node)
+          block_method, _args = *node
+          selector = block_method.source
+
+          # Don't autocorrect if this would change the meaning of the code
+          return if selector == '->' && arg_to_unparenthesized_call?(node)
+
+          lambda do |corrector|
+            if selector == 'lambda'
+              autocorrect_method_to_literal(corrector, node)
+            else
+              autocorrect_literal_to_method(corrector, node)
+            end
+          end
+        end
+
         private
 
         def offending_selector?(node, selector)
@@ -95,7 +103,7 @@ module RuboCop
         def message(node, selector)
           message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
 
-          format(message, message_line_modifier(node))
+          format(message, modifier: message_line_modifier(node))
         end
 
         def message_line_modifier(node)
@@ -107,22 +115,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          block_method, _args = *node
-          selector = block_method.source
-
-          # Don't autocorrect if this would change the meaning of the code
-          return if selector == '->' && arg_to_unparenthesized_call?(node)
-
-          lambda do |corrector|
-            if selector == 'lambda'
-              autocorrect_method_to_literal(corrector, node)
-            else
-              autocorrect_literal_to_method(corrector, node)
-            end
-          end
-        end
-
         def autocorrect_literal_to_method(corrector, node)
           block_method, args = *node
 

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

@@ -5,13 +5,19 @@ module RuboCop
     module Style
       # This cop checks for use of the lambda.(args) syntax.
       #
-      # @example
-      #
+      # @example EnforcedStyle: call (default)
       #  # bad
       #  lambda.(x, y)
       #
       #  # good
       #  lambda.call(x, y)
+      #
+      # @example EnforcedStyle: braces
+      #  # bad
+      #  lambda.call(x, y)
+      #
+      #  # good
+      #  lambda.(x, y)
       class LambdaCall < Cop
         include ConfigurableEnforcedStyle
 
@@ -25,13 +31,6 @@ module RuboCop
           end
         end
 
-        private
-
-        def offense?(node)
-          explicit_style? && node.implicit_call? ||
-            implicit_style? && !node.implicit_call?
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             if explicit_style?
@@ -46,6 +45,13 @@ module RuboCop
           end
         end
 
+        private
+
+        def offense?(node)
+          explicit_style? && node.implicit_call? ||
+            implicit_style? && !node.implicit_call?
+        end
+
         def add_parentheses(node, corrector)
           if node.arguments.empty?
             corrector.insert_after(node.source_range, '()')

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

@@ -41,9 +41,9 @@ module RuboCop
 
         def autocorrect(operator_range)
           # Include any trailing whitespace so we don't create a syntax error.
-          operator_range = range_with_surrounding_space(operator_range,
-                                                        :right,
-                                                        false)
+          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.
@@ -61,7 +61,7 @@ module RuboCop
                         eligible_operator?(operator) &&
                         eligible_predecessor?(predecessor)
 
-          return if operator.pos.line == successor.pos.line
+          return if operator.line == successor.line
 
           next_successor = token_after_last_string(successor, index)
 

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

@@ -51,8 +51,6 @@ module RuboCop
         alias on_super on_send
         alias on_yield on_send
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(args_begin(node), '(')
@@ -60,6 +58,8 @@ module RuboCop
           end
         end
 
+        private
+
         def ignored_method?(node)
           node.operator_method? || node.setter_method? ||
             ignore_macros? && node.macro? ||

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

@@ -25,8 +25,6 @@ module RuboCop
           add_offense(node, location: :begin)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.remove(node.loc.begin)
@@ -34,6 +32,8 @@ module RuboCop
           end
         end
 
+        private
+
         def ineligible_node?(node)
           node.camel_case_method? || node.implicit_call? || node.keyword_not?
         end

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

@@ -29,8 +29,6 @@ module RuboCop
         end
         alias on_defs on_def
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             if node.args_type?
@@ -39,7 +37,8 @@ module RuboCop
               corrector.remove(node.loc.end)
             else
               args_expr = node.arguments.source_range
-              args_with_space = range_with_surrounding_space(args_expr, :left)
+              args_with_space = range_with_surrounding_space(range: args_expr,
+                                                             side: :left)
               just_space = range_between(args_with_space.begin_pos,
                                          args_expr.begin_pos)
               corrector.replace(just_space, '(')
@@ -48,6 +47,8 @@ module RuboCop
           end
         end
 
+        private
+
         def require_parentheses?(args)
           style == :require_parentheses ||
             (style == :require_no_parentheses_except_multiline &&

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

@@ -8,21 +8,21 @@ module RuboCop
       #
       # @example
       #   #bad
-      #   def method_missing(...)
-      #     ...
+      #   def method_missing(name, *args)
+      #     # ...
       #   end
       #
       #   #good
-      #   def respond_to_missing?(...)
-      #     ...
+      #   def respond_to_missing?(name, include_private)
+      #     # ...
       #   end
       #
-      #   def method_missing(...)
-      #     ...
+      #   def method_missing(name, *args)
+      #     # ...
       #     super
       #   end
       class MethodMissing < Cop
-        MSG = 'When using `method_missing`, %s.'.freeze
+        MSG = 'When using `method_missing`, %<instructions>s.'.freeze
 
         def on_def(node)
           return unless node.method?(:method_missing)
@@ -50,7 +50,7 @@ module RuboCop
             instructions << 'fall back on `super`'.freeze
           end
 
-          format(MSG, instructions.join(' and '))
+          format(MSG, instructions: instructions.join(' and '))
         end
 
         def calls_super?(node)

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

@@ -7,11 +7,11 @@ module RuboCop
       #
       # @example
       #
-      #   @bad
+      #   # bad
       #   bar = [foo.min, foo.max]
       #   return foo.min, foo.max
       #
-      #   @good
+      #   # good
       #   bar = foo.minmax
       #   return foo.minmax
       class MinMax < Cop
@@ -27,10 +27,19 @@ module RuboCop
         end
         alias on_return on_array
 
+        def autocorrect(node)
+          receiver = node.children.first.receiver
+
+          lambda do |corrector|
+            corrector.replace(offending_range(node),
+                              "#{receiver.source}.minmax")
+          end
+        end
+
         private
 
         def_node_matcher :min_max_candidate, <<-PATTERN
-          ({array return} (send $_receiver :min) (send $_receiver :max))
+          ({array return} (send [$_receiver !nil?] :min) (send [$_receiver !nil?] :max))
         PATTERN
 
         def message(offender, receiver)
@@ -38,15 +47,6 @@ module RuboCop
                       receiver: receiver.source)
         end
 
-        def autocorrect(node)
-          receiver = node.children.first.receiver
-
-          lambda do |corrector|
-            corrector.replace(offending_range(node),
-                              "#{receiver.source}.minmax")
-          end
-        end
-
         def offending_range(node)
           case node.type
           when :return

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

@@ -32,10 +32,11 @@ module RuboCop
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
 
-        MSG = '`%s` condition requires an `else`-clause.'.freeze
-        MSG_NIL = '`%s` condition requires an `else`-clause with ' \
+        MSG = '`%<type>s` condition requires an `else`-clause.'.freeze
+        MSG_NIL = '`%<type>s` condition requires an `else`-clause with ' \
                   '`nil` in it.'.freeze
-        MSG_EMPTY = '`%s` condition requires an empty `else`-clause.'.freeze
+        MSG_EMPTY = '`%<type>s` condition requires an empty ' \
+                    '`else`-clause.'.freeze
 
         def on_normal_if_unless(node)
           return if case_style?
@@ -76,7 +77,7 @@ module RuboCop
                        MSG
                      end
 
-          format(template, node.type)
+          format(template, type: node.type)
         end
 
         def if_style?

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

@@ -7,30 +7,26 @@ module RuboCop
       # By default it enforces mixins to be placed in separate declarations,
       # but it can be configured to enforce grouping them in one declaration.
       #
-      # @example
-      #
-      #   EnforcedStyle: separated (default)
-      #
-      #   @bad
+      # @example EnforcedStyle: separated (default)
+      #   # bad
       #   class Foo
       #     include Bar, Qox
       #   end
       #
-      #   @good
+      #   # good
       #   class Foo
       #     include Qox
       #     include Bar
       #   end
       #
-      #   EnforcedStyle: grouped
-      #
-      #   @bad
+      # @example EnforcedStyle: grouped
+      #   # bad
       #   class Foo
       #     extend Bar
       #     extend Qox
       #   end
       #
-      #   @good
+      #   # good
       #   class Foo
       #     extend Qox, Bar
       #   end
@@ -38,7 +34,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         MIXIN_METHODS = %i[extend include prepend].freeze
-        MSG = 'Put `%s` mixins in %s.'.freeze
+        MSG = 'Put `%<mixin>s` mixins in %<suffix>s.'.freeze
 
         def on_send(node)
           return unless node.macro? && MIXIN_METHODS.include?(node.method_name)
@@ -47,15 +43,17 @@ module RuboCop
         end
 
         def autocorrect(node)
+          range = node.loc.expression
           if separated_style?
-            range = node.loc.expression
             correction = separate_mixins(node)
           else
             mixins = sibling_mixins(node)
-            mixins.unshift(node)
-
-            range = node.loc.expression.join(mixins.last.loc.expression)
-            correction = group_mixins(node, mixins)
+            if node == mixins.first
+              correction = group_mixins(node, mixins)
+            else
+              range = range_to_remove_for_subsequent_mixin(mixins, node)
+              correction = ''
+            end
           end
 
           ->(corrector) { corrector.replace(range, correction) }
@@ -63,6 +61,18 @@ module RuboCop
 
         private
 
+        def range_to_remove_for_subsequent_mixin(mixins, node)
+          range = node.loc.expression
+          prev_mixin = mixins.each_cons(2) { |m, n| break m if n == node }
+          between = prev_mixin.loc.expression.end
+                              .join(range.begin)
+          # if separated from previous mixin with only whitespace?
+          if between.source !~ /\S/
+            range = range.join(between) # then remove that too
+          end
+          range
+        end
+
         def check(send_node)
           if separated_style?
             check_separated_style(send_node)
@@ -72,7 +82,7 @@ module RuboCop
         end
 
         def check_grouped_style(send_node)
-          return if sibling_mixins(send_node).empty?
+          return if sibling_mixins(send_node).size == 1
 
           add_offense(send_node)
         end
@@ -85,7 +95,7 @@ module RuboCop
 
         def sibling_mixins(send_node)
           siblings = send_node.parent.each_child_node(:send)
-                              .reject { |sibling| sibling == send_node }
+                              .select(&:macro?)
 
           siblings.select do |sibling_node|
             sibling_node.method_name == send_node.method_name
@@ -96,7 +106,7 @@ module RuboCop
           suffix =
             separated_style? ? 'separate statements' : 'a single statement'
 
-          format(MSG, send_node.method_name, suffix)
+          format(MSG, mixin: send_node.method_name, suffix: suffix)
         end
 
         def grouped_style?