rubocop 1.34.1 → 1.54.0

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -35,7 +35,7 @@ module RuboCop
         return false if cop_config['AutoCorrect'] == false
 
         # :safe_autocorrect is a derived option based on several command-line
-        # arguments - see Rubocop::Options#add_autocorrection_options
+        # arguments - see RuboCop::Options#add_autocorrection_options
         return safe_autocorrect? if @options.fetch(:safe_autocorrect, false)
 
         true
@@ -43,18 +43,24 @@ module RuboCop
 
       private
 
-      def disable_offense(range)
-        heredoc_range = surrounding_heredoc(range)
-        if heredoc_range
-          disable_offense_before_and_after(range_by_lines(heredoc_range))
+      def disable_offense(offense_range)
+        range = surrounding_heredoc(offense_range) || surrounding_percent_array(offense_range)
+
+        if range
+          disable_offense_before_and_after(range_by_lines(range))
+        else
+          disable_offense_with_eol_or_surround_comment(offense_range)
+        end
+      end
+
+      def disable_offense_with_eol_or_surround_comment(range)
+        eol_comment = " # rubocop:todo #{cop_name}"
+        needed_line_length = (range.source_line + eol_comment).length
+
+        if needed_line_length <= max_line_length
+          disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
         else
-          eol_comment = " # rubocop:todo #{cop_name}"
-          needed_line_length = (range.source_line + eol_comment).length
-          if needed_line_length <= max_line_length
-            disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
-          else
-            disable_offense_before_and_after(range_by_lines(range))
-          end
+          disable_offense_before_and_after(range_by_lines(range))
         end
       end
 
@@ -65,10 +71,20 @@ module RuboCop
         heredoc_nodes = processed_source.ast.each_descendant.select do |node|
           node.respond_to?(:heredoc?) && node.heredoc?
         end
-        heredoc_nodes.map { |node| node.loc.expression.join(node.loc.heredoc_end) }
+        heredoc_nodes.map { |node| node.source_range.join(node.loc.heredoc_end) }
                      .find { |range| range.contains?(offense_range) }
       end
 
+      def surrounding_percent_array(offense_range)
+        return nil if offense_range.empty?
+
+        percent_array = processed_source.ast.each_descendant.select do |node|
+          node.array_type? && node.percent_literal?
+        end
+
+        percent_array.map(&:source_range).find { |range| range.overlaps?(offense_range) }
+      end
+
       def range_of_first_line(range)
         begin_of_first_line = range.begin_pos - range.column
         end_of_first_line = begin_of_first_line + range.source_line.length

data/lib/rubocop/cop/badge.rb

@@ -10,7 +10,7 @@ module RuboCop
     # allow for badge references in source files that omit the department for
     # RuboCop to infer.
     class Badge
-      attr_reader :department, :cop_name
+      attr_reader :department, :department_name, :cop_name
 
       def self.for(class_name)
         parts = class_name.split('::')
@@ -18,19 +18,23 @@ module RuboCop
         new(name_deep_enough ? parts[2..] : parts.last(2))
       end
 
+      @parse_cache = {}
+
       def self.parse(identifier)
-        new(identifier.split('/').map { |i| camel_case(i) })
+        @parse_cache[identifier] ||= new(identifier.split('/').map! { |i| camel_case(i) })
       end
 
       def self.camel_case(name_part)
         return 'RSpec' if name_part == 'rspec'
+        return name_part unless name_part.match?(/^[a-z]|_[a-z]/)
 
-        name_part.gsub(/^\w|_\w/) { |match| match[-1, 1].upcase }
+        name_part.gsub(/^[a-z]|_[a-z]/) { |match| match[-1, 1].upcase }
       end
 
       def initialize(class_name_parts)
         department_parts = class_name_parts[0...-1]
         @department = (department_parts.join('/').to_sym unless department_parts.empty?)
+        @department_name = @department&.to_s
         @cop_name = class_name_parts.last
       end
 
@@ -40,7 +44,8 @@ module RuboCop
       alias eql? ==
 
       def hash
-        [department, cop_name].hash
+        # Do hashing manually to reduce Array allocations.
+        department.hash ^ cop_name.hash # rubocop:disable Security/CompoundHash
       end
 
       def match?(other)

data/lib/rubocop/cop/base.rb

@@ -68,6 +68,64 @@ module RuboCop
         Documentation.url_for(self) if builtin?
       end
 
+      def self.inherited(subclass)
+        super
+        Registry.global.enlist(subclass)
+      end
+
+      # Call for abstract Cop classes
+      def self.exclude_from_registry
+        Registry.global.dismiss(self)
+      end
+
+      # Returns if class supports autocorrect.
+      # It is recommended to extend AutoCorrector instead of overriding
+      def self.support_autocorrect?
+        false
+      end
+
+      ### Naming
+
+      def self.badge
+        @badge ||= Badge.for(name)
+      end
+
+      def self.cop_name
+        badge.to_s
+      end
+
+      def self.department
+        badge.department
+      end
+
+      def self.lint?
+        department == :Lint
+      end
+
+      # Returns true if the cop name or the cop namespace matches any of the
+      # given names.
+      def self.match?(given_names)
+        return false unless given_names
+
+        given_names.include?(cop_name) || given_names.include?(badge.department_name)
+      end
+
+      # Override and return the Force class(es) you need to join
+      def self.joining_forces; end
+
+      ### Persistence
+
+      # Override if your cop should be called repeatedly for multiple investigations
+      # Between calls to `on_new_investigation` and `on_investigation_end`,
+      # the result of `processed_source` will remain constant.
+      # You should invalidate any caches that depend on the current `processed_source`
+      # in the `on_new_investigation` callback.
+      # If your cop does autocorrections, be aware that your instance may be called
+      # multiple times with the same `processed_source.path` but different content.
+      def self.support_multiple_source?
+        false
+      end
+
       def initialize(config = nil, options = nil)
         @config = config || Config.new
         @options = options || { debug: false }
@@ -92,9 +150,6 @@ module RuboCop
         # Typically do nothing here
       end
 
-      # Override and return the Force class(es) you need to join
-      def self.joining_forces; end
-
       # Gets called if no message is specified when calling `add_offense` or
       # `add_global_offense`
       # Cops are discouraged to override this; instead pass your message directly
@@ -107,8 +162,7 @@ module RuboCop
       def add_global_offense(message = nil, severity: nil)
         severity = find_severity(nil, severity)
         message = find_message(nil, message)
-        @current_offenses <<
-          Offense.new(severity, Offense::NO_LOCATION, message, name, :unsupported)
+        current_offenses << Offense.new(severity, Offense::NO_LOCATION, message, name, :unsupported)
       end
 
       # Adds an offense on the specified range (or node with an expression)
@@ -126,7 +180,11 @@ module RuboCop
 
         status, corrector = enabled_line?(range.line) ? correct(range, &block) : :disabled
 
-        @current_offenses << Offense.new(severity, range, message, name, status, corrector)
+        # Since this range may be generated from Ruby code embedded in some
+        # template file, we convert it to location info in the original file.
+        range = range_for_original(range)
+
+        current_offenses << Offense.new(severity, range, message, name, status, corrector)
       end
 
       # This method should be overridden when a cop's behavior depends
@@ -148,48 +206,6 @@ module RuboCop
         nil
       end
 
-      def self.inherited(subclass)
-        super
-        Registry.global.enlist(subclass)
-      end
-
-      # Call for abstract Cop classes
-      def self.exclude_from_registry
-        Registry.global.dismiss(self)
-      end
-
-      # Returns if class supports autocorrect.
-      # It is recommended to extend AutoCorrector instead of overriding
-      def self.support_autocorrect?
-        false
-      end
-
-      ### Naming
-
-      def self.badge
-        @badge ||= Badge.for(name)
-      end
-
-      def self.cop_name
-        badge.to_s
-      end
-
-      def self.department
-        badge.department
-      end
-
-      def self.lint?
-        department == :Lint
-      end
-
-      # Returns true if the cop name or the cop namespace matches any of the
-      # given names.
-      def self.match?(given_names)
-        return false unless given_names
-
-        given_names.include?(cop_name) || given_names.include?(department.to_s)
-      end
-
       def cop_name
         @cop_name ||= self.class.cop_name
       end
@@ -225,6 +241,8 @@ module RuboCop
       end
 
       def relevant_file?(file)
+        return true unless @config.clusivity_config_for_badge?(self.class.badge)
+
         file == RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME ||
           (file_name_matches_any?(file, 'Include', true) &&
             !file_name_matches_any?(file, 'Exclude', false))
@@ -239,19 +257,6 @@ module RuboCop
         ProcessedSource.new(source, target_ruby_version, path)
       end
 
-      ### Persistence
-
-      # Override if your cop should be called repeatedly for multiple investigations
-      # Between calls to `on_new_investigation` and `on_investigation_end`,
-      # the result of `processed_source` will remain constant.
-      # You should invalidate any caches that depend on the current `processed_source`
-      # in the `on_new_investigation` callback.
-      # If your cop does autocorrections, be aware that your instance may be called
-      # multiple times with the same `processed_source.path` but different content.
-      def self.support_multiple_source?
-        false
-      end
-
       # @api private
       # Called between investigations
       def ready
@@ -270,6 +275,7 @@ module RuboCop
 
       ### Reserved for Commissioner
 
+      # rubocop:disable Layout/ClassStructure
       # @api private
       def callbacks_needed
         self.class.callbacks_needed
@@ -278,10 +284,30 @@ module RuboCop
       # @api private
       def self.callbacks_needed
         @callbacks_needed ||= public_instance_methods.select do |m|
-          m.match?(/^on_|^after_/) &&
+          m.start_with?(/on_|after_/) &&
             !Base.method_defined?(m) # exclude standard "callbacks" like 'on_begin_investigation'
         end
       end
+      # rubocop:enable Layout/ClassStructure
+
+      # Called before any investigation
+      # @api private
+      def begin_investigation(processed_source, offset: 0, original: processed_source)
+        @current_offenses = nil
+        @current_offense_locations = nil
+        @currently_disabled_lines = nil
+        @processed_source = processed_source
+        @current_corrector = nil
+
+        # We need to keep track of the original source and offset,
+        # because `processed_source` here may be an embedded code in it.
+        @current_offset = offset
+        @current_original = original
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class.name}:#{object_id} @config=#{@config} @options=#{@options}>"
+      end
 
       private
 
@@ -292,7 +318,7 @@ module RuboCop
       end
 
       def apply_correction(corrector)
-        @current_corrector&.merge!(corrector) if corrector
+        current_corrector&.merge!(corrector) if corrector
       end
 
       ### Reserved for Commissioner:
@@ -305,28 +331,32 @@ module RuboCop
         @currently_disabled_lines ||= Set.new
       end
 
-      private_class_method def self.restrict_on_send
-        @restrict_on_send ||= self::RESTRICT_ON_SEND.to_a.freeze
+      def current_corrector
+        @current_corrector ||= Corrector.new(@processed_source) if @processed_source.valid_syntax?
       end
 
-      # Called before any investigation
-      def begin_investigation(processed_source)
-        @current_offenses = []
-        @current_offense_locations = nil
-        @currently_disabled_lines = nil
-        @processed_source = processed_source
-        @current_corrector = Corrector.new(@processed_source) if @processed_source.valid_syntax?
+      def current_offenses
+        @current_offenses ||= []
       end
 
+      private_class_method def self.restrict_on_send
+        @restrict_on_send ||= self::RESTRICT_ON_SEND.to_a.freeze
+      end
+
+      EMPTY_OFFENSES = [].freeze
+      private_constant :EMPTY_OFFENSES
       # Called to complete an investigation
       def complete_investigation
-        InvestigationReport.new(self, processed_source, @current_offenses, @current_corrector)
+        InvestigationReport.new(
+          self, processed_source, @current_offenses || EMPTY_OFFENSES, @current_corrector
+        )
       ensure
         reset_investigation
       end
 
       ### Actually private methods
 
+      # rubocop:disable Layout/ClassStructure
       def self.builtin?
         return false unless (m = instance_methods(false).first) # any custom method will do
 
@@ -334,6 +364,7 @@ module RuboCop
         path.start_with?(__dir__)
       end
       private_class_method :builtin?
+      # rubocop:enable Layout/ClassStructure
 
       def reset_investigation
         @currently_disabled_lines = @current_offenses = @processed_source = @current_corrector = nil
@@ -389,7 +420,7 @@ module RuboCop
 
       def range_from_node_or_range(node_or_range)
         if node_or_range.respond_to?(:loc)
-          node_or_range.loc.expression
+          node_or_range.source_range
         elsif node_or_range.is_a?(::Parser::Source::Range)
           node_or_range
         else
@@ -412,15 +443,8 @@ module RuboCop
         patterns = cop_config[parameter]
         return default_result unless patterns
 
-        path = nil
-        patterns.any? do |pattern|
-          # Try to match the absolute path, as Exclude properties are absolute.
-          next true if match_path?(pattern, file)
-
-          # Try with relative path.
-          path ||= config.path_relative_to_config(file)
-          match_path?(pattern, path)
-        end
+        patterns = FilePatterns.from(patterns)
+        patterns.match?(config.path_relative_to_config(file)) || patterns.match?(file)
       end
 
       def enabled_line?(line_number)
@@ -449,6 +473,14 @@ module RuboCop
           warn(Rainbow(message).red)
         end
       end
+
+      def range_for_original(range)
+        ::Parser::Source::Range.new(
+          @current_original.buffer,
+          range.begin_pos + @current_offset,
+          range.end_pos + @current_offset
+        )
+      end
     end
   end
 end

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -124,7 +124,7 @@ module RuboCop
         end
 
         def preceding_comment?(node1, node2)
-          node1 && node2 && precede?(node2, node1) && comment_line?(node2.loc.expression.source)
+          node1 && node2 && precede?(node2, node1) && comment_line?(node2.source)
         end
 
         def ignored_gem?(node)
@@ -150,7 +150,7 @@ module RuboCop
         # Version specifications that restrict all updates going forward. This excludes versions
         # like ">= 1.0" or "!= 2.0.3".
         def restrictive_version_specified_gem?(node)
-          return unless version_specified_gem?(node)
+          return false unless version_specified_gem?(node)
 
           node.arguments[1..]
               .any? { |arg| arg&.str_type? && RESTRICTIVE_VERSION_PATTERN.match?(arg.value) }

data/lib/rubocop/cop/bundler/gem_version.rb

@@ -105,13 +105,13 @@ module RuboCop
         end
 
         def required_offense?(node)
-          return unless required_style?
+          return false unless required_style?
 
           !includes_version_specification?(node) && !includes_commit_reference?(node)
         end
 
         def forbidden_offense?(node)
-          return unless forbidden_style?
+          return false unless forbidden_style?
 
           includes_version_specification?(node) || includes_commit_reference?(node)
         end

data/lib/rubocop/cop/commissioner.rb

@@ -76,13 +76,14 @@ module RuboCop
       end
 
       # @return [InvestigationReport]
-      def investigate(processed_source)
+      def investigate(processed_source, offset: 0, original: processed_source)
         reset
 
-        @cops.each { |cop| cop.send :begin_investigation, processed_source }
+        begin_investigation(processed_source, offset: offset, original: original)
         if processed_source.valid_syntax?
           invoke(:on_new_investigation, @cops)
-          invoke(:investigate, @forces, processed_source)
+          invoke_with_argument(:investigate, @forces, processed_source)
+
           walk(processed_source.ast) unless @cops.empty?
           invoke(:on_investigation_end, @cops)
         else
@@ -94,6 +95,12 @@ module RuboCop
 
       private
 
+      def begin_investigation(processed_source, offset:, original:)
+        @cops.each do |cop|
+          cop.begin_investigation(processed_source, offset: offset, original: original)
+        end
+      end
+
       def trigger_responding_cops(callback, node)
         @callbacks[callback]&.each do |cop|
           with_cop_error_handling(cop, node) do
@@ -149,8 +156,12 @@ module RuboCop
         map
       end
 
-      def invoke(callback, cops, *args)
-        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback, *args) } }
+      def invoke(callback, cops)
+        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback) } }
+      end
+
+      def invoke_with_argument(callback, cops, arg)
+        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback, arg) } }
       end
 
       # Allow blind rescues here, since we're absorbing and packaging or
@@ -159,9 +170,11 @@ module RuboCop
       def with_cop_error_handling(cop, node = nil)
         yield
       rescue StandardError => e
-        raise e if @options[:raise_error]
+        raise e if @options[:raise_error] # For internal testing
 
         err = ErrorWithAnalyzedFileLocation.new(cause: e, node: node, cop: cop)
+        raise err if @options[:raise_cop_error] # From user-input option
+
         @errors << err
       end
     end

data/lib/rubocop/cop/cop.rb

@@ -22,9 +22,42 @@ module RuboCop
         end
       end
 
+      def self.support_autocorrect?
+        method_defined?(:autocorrect)
+      end
+
+      def self.joining_forces
+        return unless method_defined?(:join_force?)
+
+        cop = new
+        Force.all.select { |force_class| cop.join_force?(force_class) }
+      end
+
+      ### Deprecated registry access
+
+      # @deprecated Use Registry.global
+      def self.registry
+        Registry.global
+      end
+
+      # @deprecated Use Registry.all
+      def self.all
+        Registry.all
+      end
+
+      # @deprecated Use Registry.qualified_cop_name
+      def self.qualified_cop_name(name, origin)
+        Registry.qualified_cop_name(name, origin)
+      end
+
       def add_offense(node_or_range, location: :expression, message: nil, severity: nil, &block)
         @v0_argument = node_or_range
         range = find_location(node_or_range, location)
+
+        # Since this range may be generated from Ruby code embedded in some
+        # template file, we convert it to location info in the original file.
+        range = range_for_original(range)
+
         if block.nil? && !support_autocorrect?
           super(range, message: message, severity: severity)
         else
@@ -45,17 +78,6 @@ module RuboCop
         self.class.support_autocorrect?
       end
 
-      def self.support_autocorrect?
-        method_defined?(:autocorrect)
-      end
-
-      def self.joining_forces
-        return unless method_defined?(:join_force?)
-
-        cop = new
-        Force.all.select { |force_class| cop.join_force?(force_class) }
-      end
-
       # @deprecated
       def corrections
         # warn 'Cop#corrections is deprecated' TODO
@@ -76,31 +98,21 @@ module RuboCop
         super
       end
 
-      ### Deprecated registry access
-
-      # @deprecated Use Registry.global
-      def self.registry
-        Registry.global
-      end
-
-      # @deprecated Use Registry.all
-      def self.all
-        Registry.all
-      end
+      # Called before any investigation
+      # @api private
+      def begin_investigation(processed_source, offset: 0, original: processed_source)
+        super
+        @offenses = current_offenses
+        @last_corrector = @current_corrector
 
-      # @deprecated Use Registry.qualified_cop_name
-      def self.qualified_cop_name(name, origin)
-        Registry.qualified_cop_name(name, origin)
+        # We need to keep track of the original source and offset,
+        # because `processed_source` here may be an embedded code in it.
+        @current_offset = offset
+        @current_original = original
       end
 
       private
 
-      def begin_investigation(processed_source)
-        super
-        @offenses = @current_offenses
-        @last_corrector = @current_corrector
-      end
-
       # Override Base
       def callback_argument(_range)
         @v0_argument
@@ -126,10 +138,10 @@ module RuboCop
       def correction_lambda
         return unless support_autocorrect?
 
-        dedup_on_node(@v0_argument) { autocorrect(@v0_argument) }
+        dedupe_on_node(@v0_argument) { autocorrect(@v0_argument) }
       end
 
-      def dedup_on_node(node)
+      def dedupe_on_node(node)
         @corrected_nodes ||= {}.compare_by_identity
         yield unless @corrected_nodes.key?(node)
       ensure
@@ -141,6 +153,14 @@ module RuboCop
       rescue ::Parser::ClobberingError
         # ignore Clobbering errors
       end
+
+      def range_for_original(range)
+        ::Parser::Source::Range.new(
+          @current_original.buffer,
+          range.begin_pos + @current_offset,
+          range.end_pos + @current_offset
+        )
+      end
     end
   end
 end