rubocop 0.89.1 → 0.93.0

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

@@ -53,20 +53,20 @@ module RuboCop
       #   # good
       #   foo[ ]
       #
-      class SpaceInsideReferenceBrackets < Cop
+      class SpaceInsideReferenceBrackets < Base
         include SurroundingSpace
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = '%<command>s space inside reference brackets.'
         EMPTY_MSG = '%<command>s space inside empty reference brackets.'
 
-        BRACKET_METHODS = %i[[] []=].freeze
+        RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
           return if node.multiline?
-          return unless bracket_method?(node)
 
-          tokens = tokens(node)
+          tokens = processed_source.tokens_within(node)
           left_token = left_ref_bracket(node, tokens)
           return unless left_token
 
@@ -83,34 +83,26 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            left, right = reference_brackets(node)
-
-            if empty_brackets?(left, right)
-              SpaceCorrector.empty_corrections(processed_source, corrector,
-                                               empty_config, left, right)
-            elsif style == :no_space
-              SpaceCorrector.remove_space(processed_source, corrector,
-                                          left, right)
-            else
-              SpaceCorrector.add_space(processed_source, corrector, left, right)
-            end
+        private
+
+        def autocorrect(corrector, node)
+          left, right = reference_brackets(node)
+
+          if empty_brackets?(left, right)
+            SpaceCorrector.empty_corrections(processed_source, corrector, empty_config, left, right)
+          elsif style == :no_space
+            SpaceCorrector.remove_space(processed_source, corrector, left, right)
+          else
+            SpaceCorrector.add_space(processed_source, corrector, left, right)
           end
         end
 
-        private
-
         def reference_brackets(node)
-          tokens = tokens(node)
+          tokens = processed_source.tokens_within(node)
           left = left_ref_bracket(node, tokens)
           [left, closing_bracket(tokens, left)]
         end
 
-        def bracket_method?(node)
-          BRACKET_METHODS.include?(node.method_name)
-        end
-
         def left_ref_bracket(node, tokens)
           current_token = tokens.reverse.find(&:left_ref_bracket?)
           previous_token = previous_token(current_token)

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

@@ -18,11 +18,12 @@ module RuboCop
       #
       #   # good
       #      var = "This is the #{ space } example"
-      class SpaceInsideStringInterpolation < Cop
+      class SpaceInsideStringInterpolation < Base
         include Interpolation
         include SurroundingSpace
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         NO_SPACE_MSG = 'Space inside string interpolation detected.'
         SPACE_MSG = 'Missing space inside string interpolation detected.'
@@ -40,23 +41,21 @@ module RuboCop
           end
         end
 
-        def autocorrect(begin_node)
-          lambda do |corrector|
-            delims = delimiters(begin_node)
+        private
+
+        def autocorrect(corrector, begin_node)
+          delims = delimiters(begin_node)
 
-            if style == :no_space
-              SpaceCorrector.remove_space(processed_source, corrector, *delims)
-            else
-              SpaceCorrector.add_space(processed_source, corrector, *delims)
-            end
+          if style == :no_space
+            SpaceCorrector.remove_space(processed_source, corrector, *delims)
+          else
+            SpaceCorrector.add_space(processed_source, corrector, *delims)
           end
         end
 
-        private
-
         def delimiters(begin_node)
-          left = processed_source.tokens[index_of_first_token(begin_node)]
-          right = processed_source.tokens[index_of_last_token(begin_node)]
+          left = processed_source.first_token_of(begin_node)
+          right = processed_source.last_token_of(begin_node)
           [left, right]
         end
       end

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

@@ -37,11 +37,12 @@ module RuboCop
       #   class Foo; end
       #   # EOF
       #
-      class TrailingEmptyLines < Cop
+      class TrailingEmptyLines < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
-        def investigate(processed_source)
+        def on_new_investigation
           buffer = processed_source.buffer
           return if buffer.source.empty?
 
@@ -57,28 +58,22 @@ module RuboCop
 
           return unless blank_lines != wanted_blank_lines
 
-          offense_detected(buffer, wanted_blank_lines, blank_lines,
-                           whitespace_at_end)
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
-          end
+          offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end)
         end
 
         private
 
-        def offense_detected(buffer, wanted_blank_lines, blank_lines,
-                             whitespace_at_end)
+        def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end)
           begin_pos = buffer.source.length - whitespace_at_end.length
           autocorrect_range = range_between(begin_pos, buffer.source.length)
           begin_pos += 1 unless whitespace_at_end.empty?
           report_range = range_between(begin_pos, buffer.source.length)
 
-          add_offense(autocorrect_range,
-                      location: report_range,
-                      message: message(wanted_blank_lines, blank_lines))
+          add_offense(
+            report_range, message: message(wanted_blank_lines, blank_lines)
+          ) do |corrector|
+            corrector.replace(autocorrect_range, style == :final_newline ? "\n" : "\n\n")
+          end
         end
 
         def ends_in_end?(processed_source)

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

@@ -28,12 +28,13 @@ module RuboCop
       #     x = 0
       #   RUBY
       #
-      class TrailingWhitespace < Cop
+      class TrailingWhitespace < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Trailing whitespace detected.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           heredoc_ranges = extract_heredoc_ranges(processed_source.ast)
           processed_source.lines.each_with_index do |line, index|
             lineno = index + 1
@@ -41,18 +42,13 @@ module RuboCop
             next unless line.end_with?(' ', "\t")
             next if skip_heredoc? && inside_heredoc?(heredoc_ranges, lineno)
 
-            range = source_range(processed_source.buffer,
-                                 lineno,
-                                 (line.rstrip.length)...(line.length))
-
-            add_offense(range, location: range)
+            range = offense_range(lineno, line)
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
           end
         end
 
-        def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def skip_heredoc?
@@ -71,6 +67,10 @@ module RuboCop
             (body.first_line...body.last_line)
           end
         end
+
+        def offense_range(lineno, line)
+          source_range(processed_source.buffer, lineno, (line.rstrip.length)...(line.length))
+        end
       end
     end
   end

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

@@ -15,6 +15,8 @@ module RuboCop
       #
       #   # good
       #   # With parentheses, there's no ambiguity.
+      #   some_method(a { |val| puts val })
+      #   # or (different meaning)
       #   some_method(a) { |val| puts val }
       #
       #   # good

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

@@ -43,6 +43,8 @@ module RuboCop
             next unless diagnostic.reason == :ambiguous_prefix
 
             offense_node = find_offense_node_by(diagnostic)
+            next unless offense_node
+
             message = message(diagnostic)
 
             add_offense(

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

@@ -47,7 +47,21 @@ module RuboCop
             regexp_node.source_range.begin_pos == diagnostic.location.begin_pos
           end
 
-          node.parent
+          find_offense_node(node.parent, node)
+        end
+
+        def find_offense_node(node, regexp_receiver)
+          return node unless node.parent
+
+          if node.parent.send_type? || method_chain_to_regexp_receiver?(node)
+            node = find_offense_node(node.parent, regexp_receiver)
+          end
+
+          node
+        end
+
+        def method_chain_to_regexp_receiver?(node)
+          node.parent.parent && node.parent.receiver.receiver == regexp_receiver
         end
       end
     end

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

@@ -19,6 +19,7 @@ module RuboCop
 
         MSG = '`%<double_colon>sBigDecimal.new()` is deprecated. ' \
               'Use `%<double_colon>sBigDecimal()` instead.'
+        RESTRICT_ON_SEND = %i[new].freeze
 
         def_node_matcher :big_decimal_new, <<~PATTERN
           (send
@@ -26,8 +27,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.method?(:new)
-
           big_decimal_new(node) do |captured_value|
             double_colon = captured_value ? '::' : ''
             message = format(MSG, double_colon: double_colon)

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

@@ -35,7 +35,7 @@ module RuboCop
           return unless node.binary_operation?
 
           lhs, operation, rhs = *node
-          return if MATH_OPERATORS.include?(node.method_name) && rhs.basic_literal?
+          return if MATH_OPERATORS.include?(node.method_name) && lhs.basic_literal?
 
           add_offense(node, message: format(MSG, op: operation)) if lhs == rhs
         end

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

@@ -32,6 +32,9 @@ module RuboCop
         def on_sym(node)
           return unless boolean_symbol?(node)
 
+          parent = node.parent
+          return if parent&.array_type? && parent&.percent_literal?(:symbol)
+
           add_offense(node, message: format(MSG, boolean: node.value)) do |corrector|
             autocorrect(corrector, node)
           end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Do not define constants within a block, since the block's scope does not
+      # isolate or namespace the constant in any way.
+      #
+      # If you are trying to define that constant once, define it outside of
+      # the block instead, or use a variable or method if defining the constant
+      # in the outer scope would be problematic.
+      #
+      # For meta-programming, use `const_set`.
+      #
+      # @example
+      #   # bad
+      #   task :lint do
+      #     FILES_TO_LINT = Dir['lib/*.rb']
+      #   end
+      #
+      #   # bad
+      #   describe 'making a request' do
+      #     class TestRequest; end
+      #   end
+      #
+      #   # bad
+      #   module M
+      #     extend ActiveSupport::Concern
+      #     included do
+      #       LIST = []
+      #     end
+      #   end
+      #
+      #   # good
+      #   task :lint do
+      #     files_to_lint = Dir['lib/*.rb']
+      #   end
+      #
+      #   # good
+      #   describe 'making a request' do
+      #     let(:test_request) { Class.new }
+      #     # see also `stub_const` for RSpec
+      #   end
+      #
+      #   # good
+      #   module M
+      #     extend ActiveSupport::Concern
+      #     included do
+      #       const_set(:LIST, [])
+      #     end
+      #   end
+      class ConstantDefinitionInBlock < Base
+        MSG = 'Do not define constants this way within a block.'
+
+        def_node_matcher :constant_assigned_in_block?, <<~PATTERN
+          ({^block_type? [^begin_type? ^^block_type?]} nil? ...)
+        PATTERN
+
+        def_node_matcher :module_defined_in_block?, <<~PATTERN
+          ({^block_type? [^begin_type? ^^block_type?]} ...)
+        PATTERN
+
+        def on_casgn(node)
+          add_offense(node) if constant_assigned_in_block?(node)
+        end
+
+        def on_class(node)
+          add_offense(node) if module_defined_in_block?(node)
+        end
+        alias on_module on_class
+      end
+    end
+  end
+end

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

@@ -63,7 +63,7 @@ module RuboCop
         PATTERN
 
         def on_const(node)
-          return unless unqualified_const?(node)
+          return if !unqualified_const?(node) || node.parent&.defined_module
 
           add_offense(node)
         end

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

@@ -35,10 +35,10 @@ module RuboCop
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
-        DEBUGGER_METHODS = %i[
+        RESTRICT_ON_SEND = %i[
           debugger byebug remote_byebug pry remote_pry pry_remote console rescue
           save_and_open_page save_and_open_screenshot save_screenshot irb
-        ].to_set.freeze
+        ].freeze
 
         def_node_matcher :kernel?, <<~PATTERN
           {
@@ -62,7 +62,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless DEBUGGER_METHODS.include?(node.method_name)
           return unless debugger_call?(node) || binding_irb?(node)
 
           add_offense(node)

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

@@ -62,11 +62,9 @@ module RuboCop
                                     replacement: :block_given?)
         ].freeze
 
-        DEPRECATED_METHODS = DEPRECATED_METHODS_OBJECT.map(&:deprecated_method).freeze
+        RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.map(&:deprecated_method).freeze
 
         def on_send(node)
-          return unless DEPRECATED_METHODS.include?(node.method_name)
-
           check(node) do |data|
             message = format(MSG, current: deprecated_method(data),
                                   prefer: replacement_method(data))

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

@@ -53,8 +53,8 @@ module RuboCop
         MSG = 'Method `%<method>s` is defined at both %<defined>s and ' \
               '%<current>s.'
 
-        METHOD_DEF_METHODS = %i[alias_method attr_reader attr_writer
-                                attr_accessor attr].to_set.freeze
+        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer
+                              attr_accessor attr].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -100,8 +100,6 @@ module RuboCop
 
         def_node_matcher :sym_name, '(sym $_name)'
         def on_send(node)
-          return unless METHOD_DEF_METHODS.include?(node.method_name)
-
           if (name = alias_method?(node))
             return if node.ancestors.any?(&:if_type?)
             return if possible_dsl?(node)

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicate `require`s and `require_relative`s.
+      #
+      # @example
+      #   # bad
+      #   require 'foo'
+      #   require 'bar'
+      #   require 'foo'
+      #
+      #   # good
+      #   require 'foo'
+      #   require 'bar'
+      #
+      #   # good
+      #   require 'foo'
+      #   require_relative 'foo'
+      #
+      class DuplicateRequire < Base
+        MSG = 'Duplicate `%<method>s` detected.'
+        REQUIRE_METHODS = %i[require require_relative].freeze
+        RESTRICT_ON_SEND = REQUIRE_METHODS
+
+        def_node_matcher :require_call?, <<~PATTERN
+          (send {nil? (const _ :Kernel)} {:#{REQUIRE_METHODS.join(' :')}} _)
+        PATTERN
+
+        def on_new_investigation
+          # Holds the known required files for a given parent node (used as key)
+          @required = Hash.new { |h, k| h[k] = Set.new }.compare_by_identity
+          super
+        end
+
+        def on_send(node)
+          return unless require_call?(node)
+          return if @required[node.parent].add?("#{node.method_name}#{node.first_argument}")
+
+          add_offense(node, message: format(MSG, method: node.method_name))
+        end
+      end
+    end
+  end
+end