rubocop 0.49.1 → 0.50.0

data/lib/rubocop/cop/internal_affairs/redundant_message_argument.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant message arguments to `#add_offense`. This method
+      # will automatically use `#message` or `MSG` (in that order of priority)
+      # if they are defined.
+      #
+      # @example
+      #
+      #   # bad
+      #   add_offense(node, :expression, MSG)
+      #   add_offense(node, :expression, message)
+      #   add_offense(node, :expression, message(node))
+      #
+      #   # good
+      #   add_offense(node, :expression)
+      #   add_offense(node, :expression, CUSTOM_MSG)
+      #   add_offense(node, :expression, message(other_node))
+      #
+      class RedundantMessageArgument < Cop
+        MSG = 'Redundant message argument to `#add_offense`.'.freeze
+
+        def_node_matcher :node_type_check, <<-PATTERN
+          (send nil :add_offense _offender _
+            {(const nil :MSG) (send nil :message) (send nil :message _offender)})
+        PATTERN
+
+        def on_send(node)
+          node_type_check(node) do
+            add_offense(node.last_argument)
+          end
+        end
+
+        def autocorrect(node)
+          parent = node.parent
+          arguments = parent.arguments
+          range =
+            Parser::Source::Range.new(parent.source_range.source_buffer,
+                                      arguments[-2].loc.expression.end_pos,
+                                      arguments.last.loc.expression.end_pos)
+
+          ->(corrector) { corrector.remove(range) }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/useless_message_assertion.rb

@@ -26,7 +26,7 @@ module RuboCop
 
         def investigate(_processed_source)
           assertions_using_described_class_msg.each do |node|
-            add_offense(node, :expression)
+            add_offense(node)
           end
         end
 

data/lib/rubocop/cop/layout/access_modifier_indentation.rb

@@ -37,7 +37,6 @@ module RuboCop
       class AccessModifierIndentation < Cop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
-        include AccessModifierNode
 
         MSG = '%s access modifiers like `%s`.'.freeze
 
@@ -67,7 +66,7 @@ module RuboCop
         def check_body(body, node)
           return if body.nil? # Empty class etc.
 
-          modifiers = body.each_child_node.select { |c| modifier_node?(c) }
+          modifiers = body.each_child_node(:send).select(&:access_modifier?)
           class_column = node.source_range.column
 
           modifiers.each { |modifier| check_modifier(modifier, class_column) }
@@ -81,7 +80,7 @@ module RuboCop
           if @column_delta.zero?
             correct_style_detected
           else
-            add_offense(send_node, :expression) do
+            add_offense(send_node) do
               if offset == unexpected_indent_offset
                 opposite_style_detected
               else

data/lib/rubocop/cop/layout/align_array.rb

@@ -8,14 +8,14 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   a = [1, 2, 3
+      #   a = [1, 2, 3,
       #     4, 5, 6]
       #   array = ['run',
       #        'forrest',
       #        'run']
       #
       #   # good
-      #   a = [1, 2, 3
+      #   a = [1, 2, 3,
       #        4, 5, 6]
       #   a = ['run',
       #        'forrest',

data/lib/rubocop/cop/layout/align_hash.rb

@@ -136,12 +136,12 @@ module RuboCop
           first_pair = node.pairs.first
           self.column_deltas = alignment_for(first_pair)
                                .deltas_for_first_pair(first_pair, node)
-          add_offense(first_pair, :expression) unless good_alignment?
+          add_offense(first_pair) unless good_alignment?
 
           node.children.each do |current|
             self.column_deltas = alignment_for(current)
                                  .deltas(first_pair, current)
-            add_offense(current, :expression) unless good_alignment?
+            add_offense(current) unless good_alignment?
           end
         end
 

data/lib/rubocop/cop/layout/align_parameters.rb

@@ -35,7 +35,6 @@ module RuboCop
       #       :baz
       class AlignParameters < Cop
         include AutocorrectAlignment
-        include OnMethodDef
 
         ALIGN_PARAMS_MSG = 'Align the parameters of a method %s if they span ' \
           'more than one line.'.freeze
@@ -44,18 +43,15 @@ module RuboCop
           'following the first line of a multi-line method %s.'.freeze
 
         def on_send(node)
-          return if node.arguments.size < 2 || node.method?(:[]=)
+          return if node.arguments.size < 2 ||
+                    node.send_type? && node.method?(:[]=)
 
           check_alignment(node.arguments, base_column(node, node.arguments))
         end
+        alias on_def  on_send
+        alias on_defs on_send
 
-        def on_method_def(node, _method_name, args, _body)
-          args = args.children
-
-          return if args.size < 2
-
-          check_alignment(args, base_column(node, args))
-        end
+        private
 
         def message(node)
           type = node && node.parent.send_type? ? 'call' : 'definition'
@@ -64,8 +60,6 @@ module RuboCop
           format(msg, type)
         end
 
-        private
-
         def fixed_indentation?
           cop_config['EnforcedStyle'] == 'with_fixed_indentation'
         end

data/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb

@@ -27,7 +27,6 @@ module RuboCop
       #     )
       class ClosingParenthesisIndentation < Cop
         include AutocorrectAlignment
-        include OnMethodDef
 
         MSG_INDENT =
           'Indent `)` the same as the start of the line where `(` is.'.freeze
@@ -41,11 +40,12 @@ module RuboCop
           check(node, node.children)
         end
 
-        private
-
-        def on_method_def(_node, _method_name, args, _body)
-          check(args, args.children)
+        def on_def(node)
+          check(node.arguments, node.arguments)
         end
+        alias on_defs on_def
+
+        private
 
         def check(node, elements)
           right_paren = node.loc.end

data/lib/rubocop/cop/layout/comment_indentation.rb

@@ -33,7 +33,7 @@ module RuboCop
             return if column == correct_comment_indentation
           end
 
-          add_offense(comment, comment.loc.expression,
+          add_offense(comment, :expression,
                       format(MSG, column, correct_comment_indentation))
         end
 

data/lib/rubocop/cop/layout/dot_position.rb

@@ -4,6 +4,15 @@ module RuboCop
   module Cop
     module Layout
       # This cop checks the . position in multi-line method calls.
+      #
+      # @example
+      #   # bad
+      #   something.
+      #     mehod
+      #
+      #   # good
+      #   something
+      #     .method
       class DotPosition < Cop
         include ConfigurableEnforcedStyle
 

data/lib/rubocop/cop/layout/else_alignment.rb

@@ -7,6 +7,28 @@ module RuboCop
       # be aligned with an if/unless/while/until/begin/def keyword, but there
       # are special cases when they should follow the same rules as the
       # alignment of end.
+      #
+      # @example
+      #   # bad
+      #   if something
+      #     code
+      #    else
+      #     code
+      #   end
+      #
+      #   # bad
+      #   if something
+      #     code
+      #    elsif something
+      #     code
+      #   end
+      #
+      #   # good
+      #   if something
+      #     code
+      #   else
+      #     code
+      #   end
       class ElseAlignment < Cop
         include EndKeywordAlignment
         include AutocorrectAlignment
@@ -20,18 +42,9 @@ module RuboCop
 
           check_alignment(base_range(node, base), node.loc.else)
 
-          else_branch = node.else_branch
+          return unless node.elsif_conditional?
 
-          return unless else_branch && else_branch.if_type? &&
-                        else_branch.elsif?
-
-          # If the `else` part is actually an `elsif`, we check the `elsif`
-          # node in case it contains an `else` within, because that `else`
-          # should have the same alignment (base).
-          on_if(else_branch, base)
-          # The `elsif` node will get an `on_if` call from the framework later,
-          # but we're done here, so we set it to ignored.
-          ignore_node(else_branch)
+          check_nested(node.else_branch, base)
         end
 
         def on_rescue(node)
@@ -55,6 +68,11 @@ module RuboCop
 
         private
 
+        def check_nested(node, base)
+          on_if(node, base)
+          ignore_node(node)
+        end
+
         def base_range(node, base)
           if base
             base.source_range
@@ -86,8 +104,7 @@ module RuboCop
 
           return unless rhs.if_type?
 
-          on_if(rhs, base)
-          ignore_node(rhs)
+          check_nested(rhs, base)
         end
 
         def check_alignment(base_range, else_range)

data/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -32,6 +32,10 @@ module RuboCop
       class EmptyLineBetweenDefs < Cop
         MSG = 'Use empty lines between method definitions.'.freeze
 
+        def self.autocorrect_incompatible_with
+          [Layout::EmptyLines]
+        end
+
         # We operate on `begin` nodes, instead of using `OnMethodDef`,
         # so that we can walk over pairs of consecutive nodes and
         # efficiently access a node's predecessor; #prev_node ends up

data/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb

@@ -4,18 +4,34 @@ module RuboCop
   module Cop
     module Layout
       # Access modifiers should be surrounded by blank lines.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     def bar; end
+      #     private
+      #     def baz; end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def bar; end
+      #
+      #     private
+      #
+      #     def baz; end
+      #   end
       class EmptyLinesAroundAccessModifier < Cop
-        include AccessModifierNode
-
         MSG_AFTER = 'Keep a blank line after `%s`.'.freeze
         MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after `%s`.'.freeze
 
         def on_send(node)
-          return unless modifier_node?(node)
+          return unless node.access_modifier?
 
           return if empty_lines_around?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb

@@ -60,13 +60,13 @@ module RuboCop
       #   end
       class EmptyLinesAroundExceptionHandlingKeywords < Cop
         include EmptyLinesAroundBody
-        include OnMethodDef
 
         MSG = 'Extra empty line detected %s the `%s`.'.freeze
 
-        def on_method_def(_node, _method_name, _args, body)
-          check_body(body)
+        def on_def(node)
+          check_body(node.body)
         end
+        alias on_defs on_def
 
         def on_kwbegin(node)
           body, = *node

data/lib/rubocop/cop/layout/empty_lines_around_method_body.rb

@@ -22,13 +22,13 @@ module RuboCop
       #   end
       class EmptyLinesAroundMethodBody < Cop
         include EmptyLinesAroundBody
-        include OnMethodDef
 
         KIND = 'method'.freeze
 
-        def on_method_def(node, _method_name, _args, body)
-          check(node, body)
+        def on_def(node)
+          check(node, node.body)
         end
+        alias on_defs on_def
 
         private
 

data/lib/rubocop/cop/layout/first_method_parameter_line_break.rb

@@ -27,15 +27,15 @@ module RuboCop
       #       do_something
       #     end
       class FirstMethodParameterLineBreak < Cop
-        include OnMethodDef
         include FirstElementLineBreak
 
         MSG = 'Add a line break before the first parameter of a ' \
               'multi-line method parameter list.'.freeze
 
-        def on_method_def(node, _method_name, args, _body)
-          check_method_line_break(node, args.to_a)
+        def on_def(node)
+          check_method_line_break(node, node.arguments)
         end
+        alias on_defs on_def
       end
     end
   end

data/lib/rubocop/cop/layout/first_parameter_indentation.rb

@@ -60,8 +60,7 @@ module RuboCop
 
           parent = node.parent
 
-          return false unless parent && parent.send_type? &&
-                              !parent.method?(:[]=)
+          return false unless eligible_method_call?(parent)
           return false if !parent.parenthesized? &&
                           style == :special_for_inner_method_call_in_parentheses
 
@@ -70,6 +69,10 @@ module RuboCop
           node.source_range.begin_pos > parent.source_range.begin_pos
         end
 
+        def_node_matcher :eligible_method_call?, <<-PATTERN
+          (send _ !:[]= ...)
+        PATTERN
+
         def base_range(send_node, arg_node)
           range_between(send_node.source_range.begin_pos,
                         arg_node.source_range.begin_pos)

data/lib/rubocop/cop/layout/indent_heredoc.rb

@@ -12,24 +12,25 @@ module RuboCop
       # @example
       #
       #   # bad
-      #   <<-END
+      #   <<-RUBY
       #   something
-      #   END
+      #   RUBY
       #
       #   # good
       #   # When EnforcedStyle is squiggly, bad code is auto-corrected to the
       #   # following code.
-      #   <<~END
+      #   <<~RUBY
       #     something
-      #   END
+      #   RUBY
       #
       #   # good
       #   # When EnforcedStyle is active_support, bad code is auto-corrected to
       #   # the following code.
-      #   <<-END.strip_heredoc
+      #   <<-RUBY.strip_heredoc
       #     something
-      #   END
+      #   RUBY
       class IndentHeredoc < Cop
+        include Heredoc
         include ConfigurableEnforcedStyle
         include SafeMode
 
@@ -43,10 +44,11 @@ module RuboCop
           powerpack: 'strip_indent'
         }.freeze
 
-        def on_str(node)
-          return unless heredoc?(node)
+        def on_heredoc(node)
+          body = heredoc_body(node)
+          return if body =~ /\A\s*\z/
 
-          body_indent_level = body_indent_level(node)
+          body_indent_level = indent_level(body)
 
           if heredoc_indent_type(node) == '~'
             expected_indent_level = base_indent_level(node) + indentation_width
@@ -58,9 +60,6 @@ module RuboCop
           add_offense(node, :heredoc_body)
         end
 
-        alias on_dstr on_str
-        alias on_xstr on_str
-
         def autocorrect(node)
           check_style!
 
@@ -133,22 +132,13 @@ module RuboCop
           end
         end
 
-        def heredoc?(node)
-          node.loc.is_a?(Parser::Source::Map::Heredoc)
-        end
-
         def indented_body(node)
-          body = node.loc.heredoc_body.source
-          body_indent_level = body_indent_level(node)
+          body = heredoc_body(node)
+          body_indent_level = indent_level(body)
           correct_indent_level = base_indent_level(node) + indentation_width
           body.gsub(/^\s{#{body_indent_level}}/, ' ' * correct_indent_level)
         end
 
-        def body_indent_level(node)
-          body = node.loc.heredoc_body.source
-          indent_level(body)
-        end
-
         def base_indent_level(node)
           base_line_num = node.loc.expression.line
           base_line = processed_source.lines[base_line_num - 1]
@@ -156,7 +146,8 @@ module RuboCop
         end
 
         def indent_level(str)
-          str.scan(/^\s*/).reject { |line| line == "\n" }.min_by(&:size).size
+          indentations = str.scan(/^\s*/).reject { |line| line == "\n" }
+          indentations.empty? ? 0 : indentations.min_by(&:size).size
         end
 
         # Returns '~', '-' or nil
@@ -167,6 +158,10 @@ module RuboCop
         def indentation_width
           @config.for_cop('IndentationWidth')['Width'] || 2
         end
+
+        def heredoc_body(node)
+          scrub_string(node.loc.heredoc_body.source)
+        end
       end
     end
   end