rubocop 0.50.0 → 0.51.0

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

@@ -166,7 +166,7 @@ module RuboCop
         end
 
         def offense(range, msg)
-          add_offense(range, range, msg % range.source)
+          add_offense(range, location: range, message: msg % range.source)
         end
 
         def space_before_missing?(range)

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

@@ -90,7 +90,7 @@ module RuboCop
           return if with_space.source.start_with?("\n")
 
           offense(op, with_space, right_operand) do |msg|
-            add_offense(with_space, op, msg)
+            add_offense(with_space, location: op, message: msg)
           end
         end
 

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

@@ -50,11 +50,11 @@ module RuboCop
             used_style.to_s
 
           if style_for_empty_braces == :space
-            add_offense(left_brace, left_brace, MISSING_MSG)
+            add_offense(left_brace, location: left_brace, message: MISSING_MSG)
           else
             space = range_between(space_plus_brace.begin_pos,
                                   left_brace.begin_pos)
-            add_offense(space, space, DETECTED_MSG)
+            add_offense(space, location: space, message: DETECTED_MSG)
           end
         end
 
@@ -67,7 +67,7 @@ module RuboCop
         end
 
         def space_missing(left_brace)
-          add_offense(left_brace, left_brace, MISSING_MSG) do
+          add_offense(left_brace, location: left_brace, message: MISSING_MSG) do
             opposite_style_detected
           end
         end
@@ -75,7 +75,7 @@ module RuboCop
         def space_detected(left_brace, space_plus_brace)
           space = range_between(space_plus_brace.begin_pos,
                                 left_brace.begin_pos)
-          add_offense(space, space, DETECTED_MSG) do
+          add_offense(space, location: space, message: DETECTED_MSG) do
             opposite_style_detected
           end
         end

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

@@ -19,7 +19,7 @@ module RuboCop
           processed_source.tokens.each_cons(2) do |t1, t2|
             next unless t2.type == :tCOMMENT
             next unless t1.pos.line == t2.pos.line
-            add_offense(t2.pos, t2.pos) if t1.pos.end == t2.pos.begin
+            add_offense(t2.pos, location: t2.pos) if t1.pos.end == t2.pos.begin
           end
         end
 

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

@@ -36,7 +36,7 @@ module RuboCop
           space = range_between(first_arg_with_space.begin_pos,
                                 first_arg.begin_pos)
 
-          add_offense(space, space) if space.length != 1
+          add_offense(space, location: space) if space.length != 1
         end
 
         def autocorrect(range)

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

@@ -37,9 +37,13 @@ module RuboCop
         def on_send(node)
           return unless arrow_lambda_with_args?(node)
           if style == :require_space && !space_after_arrow?(node)
-            add_offense(node, node.parent.loc.expression, MSG_REQUIRE_SPACE)
+            add_offense(node,
+                        location: node.parent.loc.expression,
+                        message: MSG_REQUIRE_SPACE)
           elsif style == :require_no_space && space_after_arrow?(node)
-            add_offense(node, node.parent.loc.expression, MSG_REQUIRE_NO_SPACE)
+            add_offense(node,
+                        location: node.parent.loc.expression,
+                        message: MSG_REQUIRE_NO_SPACE)
           end
         end
 

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

@@ -26,7 +26,7 @@ module RuboCop
 
         def on_percent_literal(node)
           each_unnecessary_space_match(node) do |range|
-            add_offense(node, range)
+            add_offense(node, location: range)
           end
         end
 

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

@@ -128,9 +128,9 @@ module RuboCop
           end
         end
 
-        def offense(begin_pos, end_pos, msg)
+        def offense(begin_pos, end_pos, msg, &block)
           range = range_between(begin_pos, end_pos)
-          add_offense(range, range, msg) { yield if block_given? }
+          add_offense(range, location: range, message: msg, &block)
         end
 
         def style_for_empty_braces

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

@@ -74,8 +74,11 @@ module RuboCop
         def incorrect_style_detected(t1, t2, expect_space, is_empty_braces)
           brace = (t1.text == '{' ? t1 : t2).pos
           range = expect_space ? brace : space_range(brace)
-          add_offense(range, range,
-                      message(brace, is_empty_braces, expect_space)) do
+          add_offense(
+            range,
+            location: range,
+            message: message(brace, is_empty_braces, expect_space)
+          ) do
             style = expect_space ? :no_space : :space
             ambiguous_or_unexpected_style_detected(style, t1.text == t2.text)
           end

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

@@ -4,6 +4,15 @@ module RuboCop
   module Cop
     module Layout
       # Checks for spaces inside ordinary round parentheses.
+      #
+      # @example
+      #   # bad
+      #   f( 3)
+      #   g = (a + 3 )
+      #
+      #   # good
+      #   f(3)
+      #   g = (a + 3)
       class SpaceInsideParens < Cop
         include SpaceInside
 

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

@@ -50,7 +50,7 @@ module RuboCop
           return unless node.single_line?
 
           regex_matches(node) do |match_range|
-            add_offense(node, match_range)
+            add_offense(node, location: match_range)
           end
         end
 

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

@@ -7,6 +7,8 @@ module RuboCop
     module Layout
       # This cop checks for tabs inside the source code.
       class Tab < Cop
+        include AutocorrectAlignment
+
         MSG = 'Tab detected.'.freeze
 
         def investigate(processed_source)
@@ -22,7 +24,7 @@ module RuboCop
                                  index + 1,
                                  (spaces.length)...(match.end(0)))
 
-            add_offense(range, range)
+            add_offense(range, location: range)
           end
         end
 
@@ -30,7 +32,8 @@ module RuboCop
 
         def autocorrect(range)
           lambda do |corrector|
-            corrector.replace(range, range.source.gsub(/\t/, '  '))
+            spaces = ' ' * configured_indentation_width
+            corrector.replace(range, range.source.gsub(/\t/, spaces))
           end
         end
 

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

@@ -36,8 +36,10 @@ module RuboCop
           autocorrect_range = range_between(begin_pos, sb.source.length)
           begin_pos += 1 unless whitespace_at_end.empty?
           report_range = range_between(begin_pos, sb.source.length)
-          add_offense(autocorrect_range, report_range,
-                      message(wanted_blank_lines, blank_lines))
+
+          add_offense(autocorrect_range,
+                      location: report_range,
+                      message: message(wanted_blank_lines, blank_lines))
         end
 
         def ends_in_end?(processed_source)

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

@@ -15,7 +15,7 @@ module RuboCop
                                  index + 1,
                                  (line.rstrip.length)...(line.length))
 
-            add_offense(range, range)
+            add_offense(range, location: range)
           end
         end
 

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -62,7 +62,7 @@ module RuboCop
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
 
-            add_offense(asgn_node, :operator)
+            add_offense(asgn_node, location: :operator)
           end
         end
 

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -146,7 +146,7 @@ module RuboCop
           message = format_message(start_loc, end_loc, do_source_line_column,
                                    error_source_line_column)
 
-          add_offense(block_node, end_loc, message)
+          add_offense(block_node, location: end_loc, message: message)
         end
 
         def format_message(start_loc, end_loc, do_source_line_column,

data/lib/rubocop/cop/lint/boolean_symbol.rb

@@ -30,7 +30,7 @@ module RuboCop
         def on_sym(node)
           return unless boolean_symbol?(node)
 
-          add_offense(node, :expression, format(MSG, node.source[1..-1]))
+          add_offense(node, message: format(MSG, node.to_a.first))
         end
       end
     end

data/lib/rubocop/cop/lint/circular_argument_reference.rb

@@ -61,21 +61,10 @@ module RuboCop
         private
 
         def check_for_circular_argument_references(arg_name, arg_value)
-          case arg_value.type
-          when :send
-            # Ruby 2.0 will have type send every time, and "send nil" if it is
-            # calling itself with a specified "self" receiver
-            receiver, name = *arg_value
-            return unless name == arg_name && receiver.nil?
-          when :lvar
-            # Ruby 2.2.2 will have type lvar if it is calling its own method
-            # without a specified "self"
-            return unless arg_value.to_a == [arg_name]
-          else
-            return
-          end
+          return unless arg_value.lvar_type?
+          return unless arg_value.to_a == [arg_name]
 
-          add_offense(arg_value, :expression, format(MSG, arg_name))
+          add_offense(arg_value, message: format(MSG, arg_name))
         end
       end
     end

data/lib/rubocop/cop/lint/debugger.rb

@@ -37,26 +37,26 @@ module RuboCop
 
         def_node_matcher :kernel?, <<-PATTERN
           {
-            (const nil :Kernel)
+            (const nil? :Kernel)
             (const (cbase) :Kernel)
           }
         PATTERN
 
         def_node_matcher :debugger_call?, <<-PATTERN
-          {(send {nil #kernel?} {:debugger :byebug} ...)
-           (send (send {#kernel? nil} :binding)
+          {(send {nil? #kernel?} {:debugger :byebug} ...)
+           (send (send {#kernel? nil?} :binding)
              {:pry :remote_pry :pry_remote} ...)
-           (send (const {nil (cbase)} :Pry) :rescue ...)
-           (send nil {:save_and_open_page
+           (send (const {nil? (cbase)} :Pry) :rescue ...)
+           (send nil? {:save_and_open_page
                       :save_and_open_screenshot
                       :save_screenshot} ...)}
         PATTERN
 
         def_node_matcher :binding_irb_call?, <<-PATTERN
-          (send (send {#kernel? nil} :binding) :irb ...)
+          (send (send {#kernel? nil?} :binding) :irb ...)
         PATTERN
 
-        def_node_matcher :pry_rescue?, '(send (const nil :Pry) :rescue ...)'
+        def_node_matcher :pry_rescue?, '(send (const nil? :Pry) :rescue ...)'
 
         def on_send(node)
           return unless debugger_call?(node) || binding_irb?(node)

data/lib/rubocop/cop/lint/deprecated_class_methods.rb

@@ -47,10 +47,10 @@ module RuboCop
 
         def on_send(node)
           check(node) do |data|
-            add_offense(node, :selector,
-                        format(MSG,
-                               deprecated_method(data),
-                               replacement_method(data)))
+            message = format(MSG, deprecated_method(data),
+                             replacement_method(data))
+
+            add_offense(node, location: :selector, message: message)
           end
         end
 

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -83,11 +83,11 @@ module RuboCop
         end
 
         def_node_matcher :alias_method?, <<-PATTERN
-          (send nil :alias_method (sym $_name) _)
+          (send nil? :alias_method (sym $_name) _)
         PATTERN
 
         def_node_matcher :attr?, <<-PATTERN
-          (send nil ${:attr_reader :attr_writer :attr_accessor :attr} $...)
+          (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
         PATTERN
 
         def_node_matcher :sym_name, '(sym $_name)'
@@ -137,7 +137,9 @@ module RuboCop
         def found_method(node, method_name)
           if @definitions.key?(method_name)
             loc = node.send_type? ? node.loc.selector : node.loc.keyword
-            add_offense(node, loc, message_for_dup(node, method_name))
+            message = message_for_dup(node, method_name)
+
+            add_offense(node, location: loc, message: message)
           else
             @definitions[method_name] = source_location(node)
           end

data/lib/rubocop/cop/lint/empty_ensure.rb

@@ -46,7 +46,7 @@ module RuboCop
         MSG = 'Empty `ensure` block detected.'.freeze
 
         def on_ensure(node)
-          add_offense(node, :keyword) unless node.body
+          add_offense(node, location: :keyword) unless node.body
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/lint/empty_expression.rb

@@ -28,7 +28,7 @@ module RuboCop
         def on_begin(node)
           return unless empty_expression?(node)
 
-          add_offense(node, node.source_range)
+          add_offense(node, location: node.source_range)
         end
 
         private

data/lib/rubocop/cop/lint/empty_when.rb

@@ -29,7 +29,7 @@ module RuboCop
           node.each_when do |when_node|
             next if when_node.body
 
-            add_offense(when_node, when_node.source_range)
+            add_offense(when_node, location: when_node.source_range)
           end
         end
       end

data/lib/rubocop/cop/lint/end_in_method.rb

@@ -32,7 +32,7 @@ module RuboCop
 
         def on_postexe(node)
           inside_of_method = node.each_ancestor(:def, :defs).count.nonzero?
-          add_offense(node, :keyword) if inside_of_method
+          add_offense(node, location: :keyword) if inside_of_method
         end
       end
     end

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -35,7 +35,7 @@ module RuboCop
         def on_send(node)
           return unless offending_node?(node)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         private

data/lib/rubocop/cop/lint/implicit_string_concatenation.rb

@@ -39,7 +39,7 @@ module RuboCop
             elsif node.parent && node.parent.send_type?
               message << FOR_METHOD
             end
-            add_offense(node, range, message)
+            add_offense(node, location: range, message: message)
           end
         end
 

data/lib/rubocop/cop/lint/ineffective_access_modifier.rb

@@ -54,7 +54,7 @@ module RuboCop
                                 'block'.freeze
 
         def_node_matcher :private_class_method, <<-PATTERN
-          (send nil :private_class_method $...)
+          (send nil? :private_class_method $...)
         PATTERN
 
         def on_class(node)
@@ -79,8 +79,9 @@ module RuboCop
           check_scope(node)
 
           @useless.each do |_name, (defs_node, visibility, modifier)|
-            add_offense(defs_node, :keyword,
-                        format_message(visibility, modifier))
+            add_offense(defs_node,
+                        location: :keyword,
+                        message: format_message(visibility, modifier))
           end
         end
 

data/lib/rubocop/cop/lint/interpolation_check.rb

@@ -22,7 +22,8 @@ module RuboCop
 
         def on_str(node)
           return if heredoc?(node)
-          return unless scrub_string(node.str_content) =~ /#\{.*\}/
+          return if node.parent && node.parent.dstr_type?
+          return unless node.str_content.scrub =~ /#\{.*\}/
           add_offense(node)
         end
 

data/lib/rubocop/cop/lint/{literal_in_condition.rb → literal_as_condition.rb}

@@ -30,8 +30,8 @@ module RuboCop
       #   if some_var && some_condition
       #     do_something
       #   end
-      class LiteralInCondition < Cop
-        MSG = 'Literal `%s` appeared in a condition.'.freeze
+      class LiteralAsCondition < Cop
+        MSG = 'Literal `%s` appeared as a condition.'.freeze
 
         def on_if(node)
           check_for_literal(node)
@@ -65,6 +65,11 @@ module RuboCop
           end
         end
 
+        def on_send(node)
+          return unless node.negation_method?
+          check_for_literal(node)
+        end
+
         def message(node)
           format(MSG, node.source)
         end
@@ -72,10 +77,11 @@ module RuboCop
         private
 
         def check_for_literal(node)
-          if node.condition.literal?
-            add_offense(node.condition)
+          cond = condition(node)
+          if cond.literal?
+            add_offense(cond)
           else
-            check_node(node.condition)
+            check_node(cond)
           end
         end
 
@@ -121,6 +127,14 @@ module RuboCop
 
           handle_node(condition)
         end
+
+        def condition(node)
+          if node.send_type?
+            node.receiver
+          else
+            node.condition
+          end
+        end
       end
     end
   end