rubocop 1.53.1 → 1.90.0

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -12,6 +12,14 @@ module RuboCop
         autocorrect_requested? && disable_uncorrectable? && autocorrect_enabled?
       end
 
+      # Whether a correction exists but is skipped because it is unsafe in a
+      # safe autocorrect run, while `--disable-uncorrectable` asks for a todo
+      # comment on everything this run cannot correct.
+      def skipped_unsafe_correction_with_disable_uncorrectable?
+        autocorrect_requested? && disable_uncorrectable? &&
+          @options.fetch(:safe_autocorrect, false) && !safe_autocorrect?
+      end
+
       def autocorrect_requested?
         @options.fetch(:autocorrect, false)
       end
@@ -32,7 +40,12 @@ module RuboCop
         # allow turning off autocorrect on a cop by cop basis
         return true unless cop_config
 
-        return false if cop_config['AutoCorrect'] == false
+        # `false` is the same as `disabled` for backward compatibility.
+        return false if ['disabled', false].include?(cop_config['AutoCorrect'])
+
+        # When LSP is enabled or the `--editor-mode` option is on, it is considered as editing
+        # source code, and autocorrection with `AutoCorrect: contextual` will not be performed.
+        return false if contextual_autocorrect? && LSP.enabled?
 
         # :safe_autocorrect is a derived option based on several command-line
         # arguments - see RuboCop::Options#add_autocorrection_options
@@ -44,45 +57,71 @@ module RuboCop
       private
 
       def disable_offense(offense_range)
-        range = surrounding_heredoc(offense_range) || surrounding_percent_array(offense_range)
+        unbreakable_range = multiline_ranges(offense_range)&.find do |range|
+          offense_range.overlaps?(range) &&
+            eol_comment_would_be_inside_literal?(offense_range, range)
+        end
 
-        if range
-          disable_offense_before_and_after(range_by_lines(range))
+        if unbreakable_range
+          disable_offense_before_and_after(range_by_lines(unbreakable_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
+      def multiline_ranges(offense_range)
+        return if offense_range.empty?
 
-        if needed_line_length <= max_line_length
-          disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
-        else
+        processed_source.ast.each_node.filter_map do |node|
+          if surrounding_heredoc?(node)
+            heredoc_range(node)
+          elsif string_continuation?(node)
+            range_by_lines(node.source_range)
+          elsif surrounding_percent_array?(node) || multiline_string?(node)
+            node.source_range
+          end
+        end
+      end
+
+      def disable_offense_with_eol_or_surround_comment(range)
+        if line_with_eol_comment_too_long?(range)
           disable_offense_before_and_after(range_by_lines(range))
+        else
+          disable_offense_at_end_of_line(range_of_first_line(range))
         end
       end
 
-      def surrounding_heredoc(offense_range)
-        # The empty offense range is an edge case that can be reached from the Lint/Syntax cop.
-        return nil if offense_range.empty?
+      def eol_comment_would_be_inside_literal?(offense_range, literal_range)
+        return true if line_with_eol_comment_too_long?(offense_range)
 
-        heredoc_nodes = processed_source.ast.each_descendant.select do |node|
-          node.respond_to?(:heredoc?) && node.heredoc?
-        end
-        heredoc_nodes.map { |node| node.source_range.join(node.loc.heredoc_end) }
-                     .find { |range| range.contains?(offense_range) }
+        offense_line = offense_range.line
+        offense_line >= literal_range.first_line && offense_line < literal_range.last_line
       end
 
-      def surrounding_percent_array(offense_range)
-        return nil if offense_range.empty?
+      def line_with_eol_comment_too_long?(range)
+        return false unless max_line_length
 
-        percent_array = processed_source.ast.each_descendant.select do |node|
-          node.array_type? && node.percent_literal?
-        end
+        (range.source_line + eol_comment).length > max_line_length
+      end
+
+      def surrounding_heredoc?(node)
+        node.any_str_type? && node.heredoc?
+      end
 
-        percent_array.map(&:source_range).find { |range| range.overlaps?(offense_range) }
+      def heredoc_range(node)
+        node.source_range.join(node.loc.heredoc_end)
+      end
+
+      def surrounding_percent_array?(node)
+        node.array_type? && node.percent_literal?
+      end
+
+      def string_continuation?(node)
+        node.any_str_type? && node.source.match?(/\\\s*$/)
+      end
+
+      def multiline_string?(node)
+        node.dstr_type? && node.multiline?
       end
 
       def range_of_first_line(range)
@@ -105,13 +144,19 @@ module RuboCop
       end
 
       def max_line_length
+        return unless config.cop_enabled?('Layout/LineLength')
+
         config.for_cop('Layout/LineLength')['Max'] || 120
       end
 
-      def disable_offense_at_end_of_line(range, eol_comment)
+      def disable_offense_at_end_of_line(range)
         Corrector.new(range).insert_after(range, eol_comment)
       end
 
+      def eol_comment
+        " # rubocop:todo #{cop_name}"
+      end
+
       def disable_offense_before_and_after(range_by_lines)
         range_with_newline = range_by_lines.resize(range_by_lines.size + 1)
         leading_whitespace = range_by_lines.source_line[/^\s*/]

data/lib/rubocop/cop/badge.rb

@@ -52,6 +52,14 @@ module RuboCop
         cop_name == other.cop_name && (!qualified? || department == other.department)
       end
 
+      # Returns true if the badge's qualified name or the badge's department
+      # matches any of the given names.
+      def match_name?(given_names)
+        return false unless given_names
+
+        given_names.include?(to_s) || given_names.include?(department_name)
+      end
+
       def to_s
         @to_s ||= qualified? ? "#{department}/#{cop_name}" : cop_name
       end

data/lib/rubocop/cop/base.rb

@@ -41,6 +41,7 @@ module RuboCop
       include AutocorrectLogic
 
       attr_reader :config, :processed_source
+      attr_accessor :project_index
 
       # Reports of an investigation.
       # Immutable
@@ -53,23 +54,27 @@ module RuboCop
       # List of cops that should not try to autocorrect at the same
       # time as this cop
       #
-      # @return [Array<RuboCop::Cop::Cop>]
+      # @return [Array<RuboCop::Cop::Base>]
       #
       # @api public
       def self.autocorrect_incompatible_with
         []
       end
 
-      # Cops (other than builtin) are encouraged to implement this
+      # Returns a url to view this cops documentation online.
+      # Requires 'DocumentationBaseURL' to be set for your department.
+      # Will follow the convention of RuboCops own documentation structure,
+      # overwrite this method to accommodate your custom layout.
       # @return [String, nil]
       #
       # @api public
-      def self.documentation_url
-        Documentation.url_for(self) if builtin?
+      def self.documentation_url(config = nil)
+        Documentation.url_for(self, config)
       end
 
       def self.inherited(subclass)
         super
+        subclass.instance_variable_set(:@gem_requirements, gem_requirements.dup)
         Registry.global.enlist(subclass)
       end
 
@@ -122,10 +127,35 @@ module RuboCop
       # 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.
+      # Note that under `--parallel` each worker process has its own cop
+      # instances, so state persists only within a worker's share of the files.
       def self.support_multiple_source?
         false
       end
 
+      ## Gem requirements
+
+      @gem_requirements = {}
+
+      class << self
+        attr_reader :gem_requirements
+
+        # Register a version requirement for the given gem name.
+        # This cop will be skipped unless the target satisfies *all* requirements.
+        # @param [String] gem_name
+        # @param [Array<String>] version_requirements The version requirements,
+        #   using the same syntax as a Gemfile, e.g. ">= 1.2.3"
+        #
+        #   If omitted, any version of the gem will be accepted.
+        #
+        #   https://guides.rubygems.org/patterns/#declaring-dependencies
+        #
+        # @api public
+        def requires_gem(gem_name, *version_requirements)
+          @gem_requirements[gem_name] = Gem::Requirement.new(version_requirements)
+        end
+      end
+
       def initialize(config = nil, options = nil)
         @config = config || Config.new
         @options = options || { debug: false }
@@ -162,7 +192,9 @@ 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)
+        range = Offense::NO_LOCATION
+        status = enabled_line?(range.line) ? :unsupported : :disabled
+        current_offenses << Offense.new(severity, range, message, name, status)
       end
 
       # Adds an offense on the specified range (or node with an expression)
@@ -178,13 +210,15 @@ module RuboCop
         severity = find_severity(range_to_pass, severity)
         message = find_message(range_to_pass, message)
 
-        status, corrector = enabled_line?(range.line) ? correct(range, &block) : :disabled
+        status, corrector = enabled_lines?(range) ? correct(range, &block) : :disabled
+        justification = suppression_reason(range) if status == :disabled
 
         # 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)
+        current_offenses << Offense.new(severity, range, message, name, status, corrector,
+                                        justification: justification)
       end
 
       # This method should be overridden when a cop's behavior depends
@@ -232,6 +266,16 @@ module RuboCop
         @config.target_ruby_version
       end
 
+      # Returns a gems locked versions (i.e. from Gemfile.lock or gems.locked)
+      # @returns [Gem::Version | nil] The locked gem version, or nil if the gem is not present.
+      def target_gem_version(gem_name)
+        @config.gem_versions_in_target && @config.gem_versions_in_target[gem_name]
+      end
+
+      def parser_engine
+        @config.parser_engine
+      end
+
       def target_rails_version
         @config.target_rails_version
       end
@@ -240,7 +284,12 @@ module RuboCop
         @config.active_support_extensions_enabled?
       end
 
+      def string_literals_frozen_by_default?
+        @config.string_literals_frozen_by_default?
+      end
+
       def relevant_file?(file)
+        return false unless target_satisfies_all_gem_version_requirements?
         return true unless @config.clusivity_config_for_badge?(self.class.badge)
 
         file == RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME ||
@@ -254,7 +303,7 @@ module RuboCop
 
       # There should be very limited reasons for a Cop to do it's own parsing
       def parse(source, path = nil)
-        ProcessedSource.new(source, target_ruby_version, path)
+        ProcessedSource.new(source, target_ruby_version, path, parser_engine: parser_engine)
       end
 
       # @api private
@@ -262,7 +311,9 @@ module RuboCop
       def ready
         return self if self.class.support_multiple_source?
 
-        self.class.new(@config, @options)
+        self.class.new(@config, @options).tap do |fresh|
+          fresh.project_index = @project_index
+        end
       end
 
       ### Reserved for Cop::Cop
@@ -284,8 +335,11 @@ module RuboCop
       # @api private
       def self.callbacks_needed
         @callbacks_needed ||= public_instance_methods.select do |m|
-          m.start_with?(/on_|after_/) &&
-            !Base.method_defined?(m) # exclude standard "callbacks" like 'on_begin_investigation'
+          # OPTIMIZE: `start_with?` with two string arguments instead of a regex
+          # is faster in this specific case.
+          m.start_with?('on_', 'after_') &&
+            # exclude standard "callbacks" like 'on_new_investigation' unless refined
+            instance_method(m).owner != Base
         end
       end
       # rubocop:enable Layout/ClassStructure
@@ -305,12 +359,29 @@ module RuboCop
         @current_original = original
       end
 
+      # @api private
+      def always_autocorrect?
+        # `true` is the same as `'always'` for backward compatibility.
+        ['always', true].include?(cop_config.fetch('AutoCorrect', 'always'))
+      end
+
+      # @api private
+      def contextual_autocorrect?
+        cop_config.fetch('AutoCorrect', 'always') == 'contextual'
+      end
+
       def inspect # :nodoc:
         "#<#{self.class.name}:#{object_id} @config=#{@config} @options=#{@options}>"
       end
 
       private
 
+      ### Reserved for Commissioner
+
+      private_class_method def self.restrict_on_send
+        @restrict_on_send ||= self::RESTRICT_ON_SEND.to_a.freeze
+      end
+
       ### Reserved for Cop::Cop
 
       def callback_argument(range)
@@ -339,10 +410,6 @@ module RuboCop
         @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
@@ -356,18 +423,11 @@ module RuboCop
 
       ### Actually private methods
 
-      # rubocop:disable Layout/ClassStructure
-      def self.builtin?
-        return false unless (m = instance_methods(false).first) # any custom method will do
-
-        path, _line = instance_method(m).source_location
-        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
+        @currently_disabled_lines = nil
+        @current_offenses = nil
+        @processed_source = nil
+        @current_corrector = nil
       end
 
       # @return [Symbol, Corrector] offense status
@@ -389,7 +449,11 @@ module RuboCop
       def use_corrector(range, corrector)
         if autocorrect?
           attempt_correction(range, corrector)
-        elsif corrector && cop_config.fetch('AutoCorrect', true)
+        elsif skipped_unsafe_correction_with_disable_uncorrectable?
+          # The unsafe correction will not run, so the offense is
+          # uncorrectable for this run and gets a todo comment.
+          attempt_correction(range, nil)
+        elsif corrector && (always_autocorrect? || (contextual_autocorrect? && !LSP.enabled?))
           :uncorrected
         else
           :unsupported
@@ -443,8 +507,23 @@ module RuboCop
         patterns = cop_config[parameter]
         return default_result unless patterns
 
-        patterns = FilePatterns.from(patterns)
-        patterns.match?(config.path_relative_to_config(file)) || patterns.match?(file)
+        file_patterns = FilePatterns.from(patterns)
+        relative_file_path = config.path_relative_to_config(file)
+        return true if file_patterns.match?(relative_file_path)
+
+        if parameter == 'Include' && !relative_file_path.start_with?('..')
+          matches_absolute_include_pattern?(patterns, file)
+        else
+          file_patterns.match?(file)
+        end
+      end
+
+      def matches_absolute_include_pattern?(patterns, file)
+        absolute_file_path = absolute?(file) ? file : File.expand_path(file)
+        patterns.any? do |pattern|
+          (absolute?(pattern.to_s) || pattern.to_s.start_with?('..')) &&
+            match_path?(pattern, absolute_file_path)
+        end
       end
 
       def enabled_line?(line_number)
@@ -453,6 +532,30 @@ module RuboCop
         @processed_source.comment_config.cop_enabled_at_line?(self, line_number)
       end
 
+      # A multi-line offense is suppressed by a directive on any line of its
+      # range, not only its first line, matching the intuition that the
+      # directive is attached to the offending code.
+      def enabled_lines?(range)
+        return true if @options[:ignore_disable_comments] || !@processed_source
+
+        comment_config = @processed_source.comment_config
+        comment_config.cop_enabled_at_lines?(self, range.first_line, range.last_line)
+      end
+
+      # The `--` reason on the directive that suppresses offenses on this
+      # range, or `nil` when the directive carries none.
+      def suppression_reason(range)
+        covering = covering_disabled_range(range)
+        covering.directive.reason if covering.respond_to?(:directive)
+      end
+
+      def covering_disabled_range(range)
+        disabled_ranges = @processed_source.comment_config.cop_disabled_line_ranges[cop_name]
+        disabled_ranges&.find do |disabled_range|
+          disabled_range.end >= range.first_line && disabled_range.begin <= range.last_line
+        end
+      end
+
       def find_severity(_range, severity)
         custom_severity || severity || default_severity
       end
@@ -475,12 +578,30 @@ module RuboCop
       end
 
       def range_for_original(range)
+        buffer = @current_original.buffer
+        return range if @current_offset.zero? && range.source_buffer.equal?(buffer)
+
         ::Parser::Source::Range.new(
-          @current_original.buffer,
+          buffer,
           range.begin_pos + @current_offset,
           range.end_pos + @current_offset
         )
       end
+
+      def target_satisfies_all_gem_version_requirements?
+        gem_requirements = self.class.gem_requirements
+        return true if gem_requirements.empty?
+
+        gem_requirements.all? do |gem_name, version_req|
+          all_gem_versions_in_target = @config.gem_versions_in_target
+          next false unless all_gem_versions_in_target
+
+          gem_version_in_target = all_gem_versions_in_target[gem_name]
+          next false unless gem_version_in_target
+
+          version_req.satisfied_by?(gem_version_in_target)
+        end
+      end
     end
   end
 end

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Bundler
       # A Gem's requirements should be listed only once in a Gemfile.
+      #
       # @example
       #   # bad
       #   gem 'rubocop'
@@ -65,14 +66,14 @@ module RuboCop
 
         def conditional_declaration?(nodes)
           parent = nodes[0].each_ancestor.find { |ancestor| !ancestor.begin_type? }
-          return false unless parent&.if_type? || parent&.when_type?
+          return false unless parent&.type?(:if, :when)
 
           root_conditional_node = parent.if_type? ? parent : parent.parent
           nodes.all? { |node| within_conditional?(node, root_conditional_node) }
         end
 
         def within_conditional?(node, conditional_node)
-          conditional_node.branches.any? do |branch|
+          conditional_node.branches.compact.any? do |branch|
             branch == node || branch.child_nodes.include?(node)
           end
         end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # A Gem group, or a set of groups, should be listed only once in a Gemfile.
+      #
+      # For example, if the values of `source`, `git`, `platforms`, or `path`
+      # surrounding `group` are different, no offense will be registered:
+      #
+      # [source,ruby]
+      # -----
+      # platforms :ruby do
+      #   group :default do
+      #     gem 'openssl'
+      #   end
+      # end
+      #
+      # platforms :jruby do
+      #   group :default do
+      #     gem 'jruby-openssl'
+      #   end
+      # end
+      # -----
+      #
+      # @example
+      #   # bad
+      #   group :development do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   group :development do
+      #     gem 'rubocop-rails'
+      #   end
+      #
+      #   # bad (same set of groups declared twice)
+      #   group :development, :test do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   group :test, :development do
+      #     gem 'rspec'
+      #   end
+      #
+      #   # good
+      #   group :development do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   group :development, :test do
+      #     gem 'rspec'
+      #   end
+      #
+      #   # good
+      #   gem 'rubocop', groups: [:development, :test]
+      #   gem 'rspec', groups: [:development, :test]
+      #
+      class DuplicatedGroup < Base
+        include RangeHelp
+
+        MSG = 'Gem group `%<group_name>s` already defined on line ' \
+              '%<line_of_first_occurrence>d of the Gemfile.'
+        SOURCE_BLOCK_NAMES = %i[source git platforms path].freeze
+
+        # @!method group_declarations(node)
+        def_node_search :group_declarations, '(send nil? :group ...)'
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          duplicated_group_nodes.each do |nodes|
+            nodes[1..].each do |node|
+              group_name = node.arguments.map(&:source).join(', ')
+
+              register_offense(node, group_name, nodes.first.first_line)
+            end
+          end
+        end
+
+        private
+
+        def duplicated_group_nodes
+          group_declarations = group_declarations(processed_source.ast)
+          group_keys = group_declarations.group_by do |node|
+            source_key = find_source_key(node)
+            group_attributes = group_attributes(node).sort.join
+
+            "#{source_key}#{group_attributes}"
+          end
+
+          group_keys.values.select { |nodes| nodes.size > 1 }
+        end
+
+        def register_offense(node, group_name, line_of_first_occurrence)
+          line_range = node.loc.column...node.loc.last_column
+          offense_location = source_range(processed_source.buffer, node.first_line, line_range)
+          message = format(
+            MSG,
+            group_name: group_name,
+            line_of_first_occurrence: line_of_first_occurrence
+          )
+          add_offense(offense_location, message: message)
+        end
+
+        def find_source_key(node)
+          source_block = node.each_ancestor(:block).find do |block_node|
+            SOURCE_BLOCK_NAMES.include?(block_node.method_name)
+          end
+
+          return unless source_block
+
+          "#{source_block.method_name}#{source_block.send_node.first_argument&.source}"
+        end
+
+        def group_attributes(node)
+          node.arguments.map do |argument|
+            if argument.hash_type?
+              argument.pairs.map(&:source).sort.join(', ')
+            else
+              argument.respond_to?(:value) ? argument.value.to_s : argument.source
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -128,8 +128,8 @@ module RuboCop
         end
 
         def ignored_gem?(node)
-          ignored_gems = Array(cop_config['IgnoredGems'])
-          ignored_gems.include?(node.first_argument.value)
+          allowed_gems = Array(cop_config['AllowedGems'])
+          allowed_gems.include?(node.first_argument.value)
         end
 
         def checked_options_present?(node)
@@ -161,9 +161,11 @@ module RuboCop
         end
 
         def gem_options(node)
-          return [] unless node.arguments.last&.type == :hash
+          return [] unless node.last_argument&.hash_type?
 
-          node.arguments.last.keys.map(&:value)
+          # Only literal keys carry an option name to check; a non-literal key
+          # (e.g. a variable or method call) has no `value` and must be skipped.
+          node.last_argument.keys.filter_map { |key| key.value if key.type?(:sym, :str) }
         end
       end
     end

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

@@ -27,7 +27,6 @@ module RuboCop
       #   Project contains gems.rb and gems.locked files
       class GemFilename < Base
         include ConfigurableEnforcedStyle
-        include RangeHelp
 
         MSG_GEMFILE_REQUIRED = '`gems.rb` file was found but `Gemfile` is required ' \
                                '(file path: %<file_path>s).'