rubocop 0.50.0 → 0.51.0

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

@@ -10,36 +10,49 @@ module RuboCop
       # @example
       #
       #   # bad
-      #   add_offense(node, :expression)
+      #   add_offense(node, location: :expression)
       #
       #   # good
       #   add_offense(node)
-      #   add_offense(node, :selector)
-      #   add_offense(node, :expression, 'message')
+      #   add_offense(node, location: :selector)
       #
       class RedundantLocationArgument < Cop
         MSG = 'Redundant location argument to `#add_offense`.'.freeze
 
-        def_node_matcher :node_type_check, <<-PATTERN
-          (send nil :add_offense _ (sym :expression))
+        def_node_matcher :add_offense_kwargs, <<-PATTERN
+          (send nil? :add_offense _ $hash)
+        PATTERN
+
+        def_node_matcher :redundant_location_argument?, <<-PATTERN
+          (pair (sym :location) (sym :expression))
         PATTERN
 
         def on_send(node)
-          node_type_check(node) do
-            add_offense(node.last_argument)
-          end
+          redundant_location_argument(node) { |argument| add_offense(argument) }
         end
 
         def autocorrect(node)
-          first, second = node.parent.arguments
-
-          range = range_between(
-            first.loc.expression.end_pos,
-            second.loc.expression.end_pos
-          )
+          range = offending_range(node)
 
           ->(corrector) { corrector.remove(range) }
         end
+
+        private
+
+        def redundant_location_argument(node)
+          add_offense_kwargs(node) do |kwargs|
+            result =
+              kwargs.pairs.find { |arg| redundant_location_argument?(arg) }
+
+            yield result if result
+          end
+        end
+
+        def offending_range(node)
+          with_space = range_with_surrounding_space(node.loc.expression)
+
+          range_with_surrounding_comma(with_space, :left)
+        end
       end
     end
   end

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

@@ -10,39 +10,61 @@ module RuboCop
       # @example
       #
       #   # bad
-      #   add_offense(node, :expression, MSG)
-      #   add_offense(node, :expression, message)
-      #   add_offense(node, :expression, message(node))
+      #   add_offense(node, message: MSG)
+      #   add_offense(node, message: message)
+      #   add_offense(node, message: message(node))
       #
       #   # good
-      #   add_offense(node, :expression)
-      #   add_offense(node, :expression, CUSTOM_MSG)
-      #   add_offense(node, :expression, message(other_node))
+      #   add_offense(node)
+      #   add_offense(node, message: CUSTOM_MSG)
+      #   add_offense(node, message: 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)})
+          (send nil? :add_offense $_node $hash)
         PATTERN
 
+        def_node_matcher :redundant_message_argument, <<-PATTERN
+          (pair
+            (sym :message)
+            ${(const nil? :MSG) (send nil? :message) (send nil? :message _)})
+        PATTERN
+
+        def_node_matcher :message_method_call, '(send nil? :message $_node)'
+
         def on_send(node)
-          node_type_check(node) do
-            add_offense(node.last_argument)
+          node_type_check(node) do |node_arg, kwargs|
+            find_offending_argument(node_arg, kwargs) do |pair|
+              add_offense(pair)
+            end
           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)
+          range = offending_range(node)
 
           ->(corrector) { corrector.remove(range) }
         end
+
+        private
+
+        def offending_range(node)
+          with_space = range_with_surrounding_space(node.loc.expression)
+
+          range_with_surrounding_comma(with_space, :left)
+        end
+
+        def find_offending_argument(searched_node, kwargs)
+          kwargs.pairs.each do |pair|
+            redundant_message_argument(pair) do |message_argument|
+              node = message_method_call(message_argument)
+
+              yield pair if !node || node == searched_node
+            end
+          end
+        end
       end
     end
   end

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

@@ -17,11 +17,11 @@ module RuboCop
         MSG = 'Do not specify cop behavior using `described_class::MSG`.'.freeze
 
         def_node_search :described_class_msg, <<-PATTERN
-          (const (send nil :described_class) :MSG)
+          (const (send nil? :described_class) :MSG)
         PATTERN
 
         def_node_matcher :rspec_expectation_on_msg?, <<-PATTERN
-          (send (send nil :expect #contains_described_class_msg?) :to ...)
+          (send (send nil? :expect #contains_described_class_msg?) :to ...)
         PATTERN
 
         def investigate(_processed_source)

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

@@ -35,7 +35,7 @@ module RuboCop
           # If the end is on its own line, there is no offense
           return if end_loc.source_line =~ /^\s*#{end_loc.source}/
 
-          add_offense(node, end_loc)
+          add_offense(node, location: end_loc)
         end
 
         private

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

@@ -109,7 +109,7 @@ module RuboCop
           when_column = when_node.loc.keyword.column
           base_column = base_column(when_node.parent, alternative_style)
 
-          add_offense(when_node, :keyword, message(style)) do
+          add_offense(when_node, location: :keyword, message: message(style)) do
             if when_column == base_column
               opposite_style_detected
             else

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

@@ -60,7 +60,7 @@ module RuboCop
           left_paren = node.loc.begin
           msg = correct_column == left_paren.column ? MSG_ALIGN : MSG_INDENT
 
-          add_offense(right_paren, right_paren, msg)
+          add_offense(right_paren, location: right_paren, message: msg)
         end
 
         def expected_column(node, elements)

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

@@ -33,8 +33,10 @@ module RuboCop
             return if column == correct_comment_indentation
           end
 
-          add_offense(comment, :expression,
-                      format(MSG, column, correct_comment_indentation))
+          add_offense(
+            comment,
+            message: format(MSG, column, correct_comment_indentation)
+          )
         end
 
         def own_line_comment?(comment)

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

@@ -22,7 +22,7 @@ module RuboCop
           if proper_dot_position?(node)
             correct_style_detected
           else
-            add_offense(node, :dot) { opposite_style_detected }
+            add_offense(node, location: :dot) { opposite_style_detected }
           end
         end
 

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

@@ -113,8 +113,11 @@ module RuboCop
           @column_delta = effective_column(base_range) - else_range.column
           return if @column_delta.zero?
 
-          add_offense(else_range, else_range,
-                      format(MSG, else_range.source, base_range.source[/^\S*/]))
+          add_offense(
+            else_range,
+            location: else_range,
+            message: format(MSG, else_range.source, base_range.source[/^\S*/])
+          )
         end
       end
     end

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

@@ -32,7 +32,7 @@ module RuboCop
           offending_range =
             source_range(source.buffer, last_magic_comment.loc.line + 1, 0)
 
-          add_offense(offending_range, offending_range)
+          add_offense(offending_range, location: offending_range)
         end
 
         def autocorrect(token)

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

@@ -54,7 +54,7 @@ module RuboCop
           return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
-          add_offense(nodes.last, :keyword)
+          add_offense(nodes.last, location: :keyword)
         end
 
         private

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

@@ -19,7 +19,7 @@ module RuboCop
           end
 
           each_extra_empty_line(lines.sort) do |range|
-            add_offense(range, range)
+            add_offense(range, location: range)
           end
         end
 

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

@@ -23,7 +23,7 @@ module RuboCop
 
             range =
               source_range(processed_source.buffer, index + 1, 0, line.length)
-            add_offense(nil, range, msg)
+            add_offense(nil, location: range, message: msg)
             # Usually there will be carriage return characters on all or none
             # of the lines in a file, so we report only one offense.
             break

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

@@ -87,7 +87,7 @@ module RuboCop
             message = format(MSG_UNALIGNED_ASGN, 'following')
           end
           return if aligned_assignment?(token.pos, assignment_line)
-          add_offense(token.pos, token.pos, message)
+          add_offense(token.pos, location: token.pos, message: message)
         end
 
         def should_aligned_with_preceding_line?(token)
@@ -108,7 +108,7 @@ module RuboCop
             next if ignored_range?(ast, range.begin_pos)
             next if unary_plus_non_offense?(range)
 
-            add_offense(range, range, MSG_UNNECESSARY)
+            add_offense(range, location: range, message: MSG_UNNECESSARY)
           end
         end
 

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

@@ -90,7 +90,7 @@ module RuboCop
                   'Indent the right bracket the same as the start of the line' \
                   ' where the left bracket is.'
                 end
-          add_offense(right_bracket, right_bracket, msg)
+          add_offense(right_bracket, location: right_bracket, message: msg)
         end
 
         # Returns the description of what the correct indentation is based on.

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

@@ -96,7 +96,7 @@ module RuboCop
                   'Indent the right brace the same as the start of the line ' \
                   'where the left brace is.'
                 end
-          add_offense(right_brace, right_brace, msg)
+          add_offense(right_brace, location: right_brace, message: msg)
         end
 
         def separator_style?(first_pair)

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

@@ -57,7 +57,7 @@ module RuboCop
             return unless body_indent_level.zero?
           end
 
-          add_offense(node, :heredoc_body)
+          add_offense(node, location: :heredoc_body)
         end
 
         def autocorrect(node)
@@ -160,7 +160,7 @@ module RuboCop
         end
 
         def heredoc_body(node)
-          scrub_string(node.loc.heredoc_body.source)
+          node.loc.heredoc_body.source.scrub
         end
       end
     end

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

@@ -51,6 +51,8 @@ module RuboCop
         include CheckAssignment
         include IgnoredPattern
 
+        MSG = 'Use %d (not %d) spaces for%s indentation.'.freeze
+
         SPECIAL_MODIFIERS = %w[private protected].freeze
 
         def on_rescue(node)
@@ -236,11 +238,11 @@ module RuboCop
                    body_node
                  end
 
-          indentation_name = style == 'normal' ? '' : "#{style} "
-          add_offense(node, offending_range(body_node, indentation),
-                      format("Use #{configured_indentation_width} (not %d) " \
-                             "spaces for #{indentation_name}indentation.",
-                             indentation))
+          name = style == 'normal' ? '' : " #{style}"
+          msg = format(MSG, configured_indentation_width, indentation, name)
+
+          add_offense(node, location: offending_range(body_node, indentation),
+                            message: msg)
         end
 
         # Returns true if the given node is within another node that has

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

@@ -9,8 +9,9 @@ module RuboCop
         MSG = 'Indentation of first line in file detected.'.freeze
 
         def investigate(_processed_source)
-          token = first_token
-          space_before(token) { |space| add_offense(space, token.pos) }
+          space_before(first_token) do |space|
+            add_offense(space, location: first_token.pos)
+          end
         end
 
         def autocorrect(range)

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

@@ -56,13 +56,13 @@ module RuboCop
         def check_new_line_offense(node, rhs)
           return unless node.loc.operator.line == rhs.loc.line
 
-          add_offense(node, :expression, NEW_LINE_OFFENSE)
+          add_offense(node, message: NEW_LINE_OFFENSE)
         end
 
         def check_same_line_offense(node, rhs)
           return unless node.loc.operator.line != rhs.loc.line
 
-          add_offense(node, :expression, SAME_LINE_OFFENSE)
+          add_offense(node, message: SAME_LINE_OFFENSE)
         end
 
         def autocorrect(node)

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

@@ -64,7 +64,7 @@ module RuboCop
           expression = expr.source_range
           range = range_between(expression.begin_pos, expression.end_pos)
 
-          add_offense(node, range, msg)
+          add_offense(node, location: range, message: msg)
         end
 
         def autocorrect(node)

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

@@ -57,7 +57,9 @@ module RuboCop
           return if end_loc.column == kw_loc.column
           return if end_loc.line == kw_loc.line
 
-          add_offense(node, kw_loc, format_message(kw_loc, end_loc))
+          add_offense(node,
+                      location: kw_loc,
+                      message: format_message(kw_loc, end_loc))
         end
 
         def format_message(kw_loc, end_loc)

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

@@ -21,7 +21,7 @@ module RuboCop
 
           colon = node.loc.operator
 
-          add_offense(colon, colon) unless followed_by_space?(colon)
+          add_offense(colon, location: colon) unless followed_by_space?(colon)
         end
 
         def on_kwoptarg(node)
@@ -29,7 +29,7 @@ module RuboCop
           # optional keyword argument's name, so must construct one.
           colon = node.loc.name.end.resize(1)
 
-          add_offense(colon, colon) unless followed_by_space?(colon)
+          add_offense(colon, location: colon) unless followed_by_space?(colon)
         end
 
         private

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

@@ -24,7 +24,7 @@ module RuboCop
                                                 expr.begin_pos)
           return unless pos_before_left_paren.source =~ /\s/
 
-          add_offense(pos_before_left_paren, pos_before_left_paren)
+          add_offense(pos_before_left_paren, location: pos_before_left_paren)
         end
         alias on_defs on_def
 

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

@@ -113,14 +113,15 @@ module RuboCop
         def check_space(space_begin_pos, space_end_pos, range, msg)
           return if space_begin_pos != space_end_pos
 
-          add_offense(range, range, "Space #{msg} missing.")
+          add_offense(range, location: range, message: "Space #{msg} missing.")
         end
 
         def check_no_space(space_begin_pos, space_end_pos, msg)
           return if space_begin_pos >= space_end_pos
 
           range = range_between(space_begin_pos, space_end_pos)
-          add_offense(range, range, "#{msg} block parameter detected.")
+          add_offense(range, location: range,
+                             message: "#{msg} block parameter detected.")
         end
 
         def autocorrect(range)

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

@@ -33,7 +33,7 @@ module RuboCop
         def incorrect_style_detected(arg, value, space_on_both_sides,
                                      no_surrounding_space)
           range = range_between(arg.pos.end_pos, value.pos.begin_pos)
-          add_offense(range, range) do
+          add_offense(range, location: range) do
             if style == :space && no_surrounding_space ||
                style == :no_space && space_on_both_sides
               opposite_style_detected