rubocop 0.49.1 → 0.50.0

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

@@ -46,22 +46,12 @@ module RuboCop
           return if ignored_method?(node)
           return unless node.arguments? && !node.parenthesized?
 
-          add_offense(node, :selector)
+          add_offense(node)
         end
+        alias on_super on_send
+        alias on_yield on_send
 
-        def on_super(node)
-          return if node.parenthesized?
-
-          add_offense(node, :keyword)
-        end
-
-        def on_yield(node)
-          args = node.children
-          return if args.empty?
-          return if parentheses?(node)
-
-          add_offense(node, :keyword)
-        end
+        private
 
         def autocorrect(node)
           lambda do |corrector|
@@ -70,8 +60,6 @@ module RuboCop
           end
         end
 
-        private
-
         def ignored_method?(node)
           node.operator_method? || node.setter_method? ||
             ignore_macros? && node.macro? ||
@@ -86,10 +74,6 @@ module RuboCop
           cop_config['IgnoreMacros']
         end
 
-        def parentheses?(node)
-          node.loc.begin
-        end
-
         def args_begin(node)
           loc = node.loc
           selector =

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

@@ -18,15 +18,15 @@ module RuboCop
         ASGN_NODES = %i[lvasgn masgn] + SHORTHAND_ASGN_NODES
 
         def on_send(node)
-          return if node.camel_case_method?
+          return if ineligible_node?(node)
           return unless !node.arguments? && node.parenthesized?
           return if same_name_assignment?(node)
-          return if node.implicit_call?
-          return if node.keyword_not?
 
           add_offense(node, :begin)
         end
 
+        private
+
         def autocorrect(node)
           lambda do |corrector|
             corrector.remove(node.loc.begin)
@@ -34,7 +34,9 @@ module RuboCop
           end
         end
 
-        private
+        def ineligible_node?(node)
+          node.camel_case_method? || node.implicit_call? || node.keyword_not?
+        end
 
         def same_name_assignment?(node)
           any_assignment?(node) do |asgn_node|

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

@@ -6,13 +6,18 @@ module RuboCop
       # This cops checks for parentheses around the arguments in method
       # definitions. Both instance and class/singleton methods are checked.
       class MethodDefParentheses < Cop
-        include OnMethodDef
         include ConfigurableEnforcedStyle
 
-        def on_method_def(node, _method_name, args, _body)
+        MSG_PRESENT = 'Use def without parentheses.'.freeze
+        MSG_MISSING = 'Use def with parentheses when there are ' \
+                      'parameters.'.freeze
+
+        def on_def(node)
+          args = node.arguments
+
           if require_parentheses?(args)
-            if arguments_without_parentheses?(args)
-              missing_parentheses(node, args)
+            if arguments_without_parentheses?(node)
+              missing_parentheses(node)
             else
               correct_style_detected
             end
@@ -22,6 +27,9 @@ module RuboCop
             correct_style_detected
           end
         end
+        alias on_defs on_def
+
+        private
 
         def autocorrect(node)
           lambda do |corrector|
@@ -30,7 +38,7 @@ module RuboCop
               corrector.replace(node.loc.begin, ' ')
               corrector.remove(node.loc.end)
             else
-              args_expr = args_node(node).source_range
+              args_expr = node.arguments.source_range
               args_with_space = range_with_surrounding_space(args_expr, :left)
               just_space = range_between(args_with_space.begin_pos,
                                          args_expr.begin_pos)
@@ -40,43 +48,27 @@ module RuboCop
           end
         end
 
-        private
-
         def require_parentheses?(args)
           style == :require_parentheses ||
             (style == :require_no_parentheses_except_multiline &&
              args.multiline?)
         end
 
-        def arguments_without_parentheses?(args)
-          arguments?(args) && !parentheses?(args)
+        def arguments_without_parentheses?(node)
+          node.arguments? && !parentheses?(node.arguments)
         end
 
-        def missing_parentheses(node, args)
-          add_offense(node, args.source_range,
-                      'Use def with parentheses when there are parameters.') do
+        def missing_parentheses(node)
+          add_offense(node, node.arguments.source_range, MSG_MISSING) do
             unexpected_style_detected(:require_no_parentheses)
           end
         end
 
         def unwanted_parentheses(args)
-          add_offense(args, :expression, 'Use def without parentheses.') do
+          add_offense(args, :expression, MSG_PRESENT) do
             unexpected_style_detected(:require_parentheses)
           end
         end
-
-        def args_node(def_node)
-          if def_node.def_type?
-            _method_name, args, _body = *def_node
-          else
-            _scope, _method_name, args, _body = *def_node
-          end
-          args
-        end
-
-        def arguments?(args)
-          !args.children.empty?
-        end
       end
     end
   end

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

@@ -22,22 +22,21 @@ module RuboCop
       #     super
       #   end
       class MethodMissing < Cop
-        include OnMethodDef
-
         MSG = 'When using `method_missing`, %s.'.freeze
 
-        def on_method_def(node, method_name, _args, _body)
-          return unless method_name == :method_missing
+        def on_def(node)
+          return unless node.method?(:method_missing)
 
           check(node)
         end
+        alias on_defs on_def
 
         private
 
         def check(node)
           return if calls_super?(node) && implements_respond_to_missing?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def message(node)
@@ -60,21 +59,9 @@ module RuboCop
 
         def implements_respond_to_missing?(node)
           node.parent.each_child_node(node.type).any? do |sibling|
-            if node.def_type?
-              respond_to_missing_def?(sibling)
-            elsif node.defs_type?
-              respond_to_missing_defs?(sibling)
-            end
+            sibling.method?(:respond_to_missing?)
           end
         end
-
-        def_node_matcher :respond_to_missing_def?, <<-PATTERN
-          (def :respond_to_missing? (...) ...)
-        PATTERN
-
-        def_node_matcher :respond_to_missing_defs?, <<-PATTERN
-          (defs (self) :respond_to_missing? (...) ...)
-        PATTERN
       end
     end
   end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for potential uses of `Enumerable#minmax`.
+      #
+      # @example
+      #
+      #   @bad
+      #   bar = [foo.min, foo.max]
+      #   return foo.min, foo.max
+      #
+      #   @good
+      #   bar = foo.minmax
+      #   return foo.minmax
+      class MinMax < Cop
+        MSG = 'Use `%<receiver>s.minmax` instead of `%<offender>s`.'.freeze
+
+        def on_array(node)
+          min_max_candidate(node) do |receiver|
+            offender = offending_range(node)
+
+            add_offense(node, offender, message(offender, receiver))
+          end
+        end
+        alias on_return on_array
+
+        private
+
+        def_node_matcher :min_max_candidate, <<-PATTERN
+          ({array return} (send $_receiver :min) (send $_receiver :max))
+        PATTERN
+
+        def message(offender, receiver)
+          format(MSG, offender: offender.source,
+                      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
+            argument_range(node)
+          else
+            node.loc.expression
+          end
+        end
+
+        def argument_range(node)
+          first_argument_range = node.children.first.loc.expression
+          last_argument_range  = node.children.last.loc.expression
+
+          first_argument_range.join(last_argument_range)
+        end
+      end
+    end
+  end
+end

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

@@ -57,13 +57,26 @@ module RuboCop
 
           if empty_else_cop_enabled?
             if empty_else_style == :empty
-              add_offense(node, :expression, format(MSG_NIL, node.type))
+              add_offense(node)
             elsif empty_else_style == :nil
-              add_offense(node, :expression, format(MSG_EMPTY, node.type))
+              add_offense(node)
             end
           end
 
-          add_offense(node, :expression, format(MSG, node.type))
+          add_offense(node)
+        end
+
+        def message(node)
+          template = case empty_else_style
+                     when :empty
+                       MSG_NIL
+                     when :nil
+                       MSG_EMPTY
+                     else
+                       MSG
+                     end
+
+          format(template, node.type)
         end
 
         def if_style?

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

@@ -74,13 +74,13 @@ module RuboCop
         def check_grouped_style(send_node)
           return if sibling_mixins(send_node).empty?
 
-          add_offense(send_node, :expression)
+          add_offense(send_node)
         end
 
         def check_separated_style(send_node)
           return if send_node.arguments.one?
 
-          add_offense(send_node, :expression)
+          add_offense(send_node)
         end
 
         def sibling_mixins(send_node)

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

@@ -39,8 +39,8 @@ module RuboCop
           _name, body = *node
           return unless body && body.begin_type?
 
-          each_wrong_style(body.children) do |child_node, msg|
-            add_offense(child_node, :expression, msg)
+          each_wrong_style(body.children) do |child_node|
+            add_offense(child_node)
           end
         end
 
@@ -50,14 +50,18 @@ module RuboCop
           case style
           when :module_function
             nodes.each do |node|
-              yield node, MODULE_FUNCTION_MSG if extend_self_node?(node)
+              yield node if extend_self_node?(node)
             end
           when :extend_self
             nodes.each do |node|
-              yield node, EXTEND_SELF_MSG if module_function_node?(node)
+              yield node if module_function_node?(node)
             end
           end
         end
+
+        def message(_node)
+          style == :module_function ? MODULE_FUNCTION_MSG : EXTEND_SELF_MSG
+        end
       end
     end
   end

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

@@ -24,7 +24,7 @@ module RuboCop
         def on_if(node)
           return unless node.modifier_form? && node.body.multiline?
 
-          add_offense(node, :expression, format(MSG, node.keyword))
+          add_offense(node)
         end
 
         private
@@ -35,6 +35,10 @@ module RuboCop
           end
         end
 
+        def message(node)
+          format(MSG, node.keyword)
+        end
+
         def to_normal_if(node)
           indented_body = indented_body(node.body, node)
           condition = "#{node.keyword} #{node.condition.source}"

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

@@ -46,7 +46,7 @@ module RuboCop
 
           return unless bad_rhs?(rhs)
 
-          add_offense(rhs, node.source_range, MSG)
+          add_offense(rhs, node.source_range)
         end
 
         private
@@ -54,8 +54,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             if style == :keyword
-              corrector.replace(node.loc.begin, 'begin')
-              corrector.replace(node.loc.end, 'end')
+              keyword_autocorrect(node, corrector)
             else
               corrector.replace(node.loc.begin, '(')
               corrector.replace(node.loc.end, ')')
@@ -71,6 +70,29 @@ module RuboCop
             rhs.kwbegin_type?
           end
         end
+
+        def keyword_autocorrect(node, corrector)
+          node_buf = node.source_range.source_buffer
+          corrector.replace(node.loc.begin, keyword_begin_str(node, node_buf))
+          corrector.replace(node.loc.end, keyword_end_str(node, node_buf))
+        end
+
+        def keyword_begin_str(node, node_buf)
+          indent = config.for_cop('IndentationWidth')['Width'] || 2
+          if node_buf.source[node.loc.begin.end_pos] == "\n"
+            'begin'
+          else
+            "begin\n" + (' ' * (node.loc.column + indent))
+          end
+        end
+
+        def keyword_end_str(node, node_buf)
+          if node_buf.source_line(node.loc.end.line) =~ /[^\s\)]/
+            "\n" + (' ' * node.loc.column) + 'end'
+          else
+            'end'
+          end
+        end
       end
     end
   end

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

@@ -11,7 +11,7 @@ module RuboCop
         def on_if(node)
           return unless node.ternary? && node.multiline?
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
       end
     end

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

@@ -20,7 +20,7 @@ module RuboCop
 
         def on_if(node)
           return unless nested_variable_comparison?(node.condition)
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         private