rubocop 1.54.1 → 1.64.1

data/lib/rubocop/cli.rb

@@ -11,8 +11,8 @@ module RuboCop
     STATUS_ERROR       = 2
     STATUS_INTERRUPTED = Signal.list['INT'] + 128
     DEFAULT_PARALLEL_OPTIONS = %i[
-      color debug display_style_guide display_time display_only_fail_level_offenses
-      display_only_failed except extra_details fail_level fix_layout format
+      color config debug display_style_guide display_time display_only_fail_level_offenses
+      display_only_failed editor_mode except extra_details fail_level fix_layout format
       ignore_disable_comments lint only only_guide_cops require safe
       autocorrect safe_autocorrect autocorrect_all
     ].freeze
@@ -57,6 +57,10 @@ module RuboCop
     rescue RuboCop::Error => e
       warn Rainbow("Error: #{e.message}").red
       STATUS_ERROR
+    rescue Interrupt
+      warn ''
+      warn 'Exiting...'
+      STATUS_INTERRUPTED
     rescue Finished
       STATUS_SUCCESS
     rescue OptionParser::InvalidOption => e
@@ -151,6 +155,7 @@ module RuboCop
 
     def act_on_options
       set_options_to_config_loader
+      handle_editor_mode
 
       @config_store.options_config = @options[:config] if @options[:config]
       @config_store.force_default_config! if @options[:force_default_config]
@@ -174,6 +179,10 @@ module RuboCop
       ConfigLoader.ignore_unrecognized_cops = @options[:ignore_unrecognized_cops]
     end
 
+    def handle_editor_mode
+      RuboCop::LSP.enable if @options[:editor_mode]
+    end
+
     # rubocop:disable Metrics/CyclomaticComplexity
     def handle_exiting_options
       return unless Options::EXITING_OPTIONS.any? { |o| @options.key? o }

data/lib/rubocop/config.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'pathname'
-
 # FIXME: Moving Rails department code to RuboCop Rails will remove
 # the following rubocop:disable comment.
 # rubocop:disable Metrics/ClassLength
@@ -246,6 +244,10 @@ module RuboCop
         end
     end
 
+    def parser_engine
+      @parser_engine ||= for_all_cops.fetch('ParserEngine', :parser_whitequark).to_sym
+    end
+
     def target_rails_version
       @target_rails_version ||=
         if for_all_cops['TargetRailsVersion']
@@ -261,6 +263,7 @@ module RuboCop
       PathUtil.smart_path(@loaded_path)
     end
 
+    # @return [String, nil]
     def bundler_lock_file_path
       return nil unless loaded_path
 
@@ -284,27 +287,48 @@ module RuboCop
       end
     end
 
+    # Returns target's locked gem versions (i.e. from Gemfile.lock or gems.locked)
+    # @returns [Hash{String => Gem::Version}] The locked gem versions, keyed by the gems' names.
+    def gem_versions_in_target
+      @gem_versions_in_target ||= read_gem_versions_from_target_lockfile
+    end
+
     def inspect # :nodoc:
       "#<#{self.class.name}:#{object_id} @loaded_path=#{loaded_path}>"
     end
 
     private
 
+    # @return [Float, nil] The Rails version as a `major.minor` Float.
     def target_rails_version_from_bundler_lock_file
       @target_rails_version_from_bundler_lock_file ||= read_rails_version_from_bundler_lock_file
     end
 
+    # @return [Float, nil] The Rails version as a `major.minor` Float.
     def read_rails_version_from_bundler_lock_file
-      lock_file_path = bundler_lock_file_path
-      return nil unless lock_file_path
-
-      File.foreach(lock_file_path) do |line|
-        # If Rails (or one of its frameworks) is in Gemfile.lock or gems.lock, there should be
-        # a line like:
-        #         railties (X.X.X)
-        result = line.match(/^\s+railties\s+\((\d+\.\d+)/)
-        return result.captures.first.to_f if result
-      end
+      return nil unless gem_versions_in_target
+
+      # Look for `railties` instead of `rails`, to support apps that only use a subset of `rails`
+      # See https://github.com/rubocop/rubocop/pull/11289
+      rails_version_in_target = gem_versions_in_target['railties']
+      return nil unless rails_version_in_target
+
+      gem_version_to_major_minor_float(rails_version_in_target)
+    end
+
+    # @param [Gem::Version] gem_version an object like `Gem::Version.new("7.1.2.3")`
+    # @return [Float] The major and minor version, like `7.1`
+    def gem_version_to_major_minor_float(gem_version)
+      segments = gem_version.segments
+      Float("#{segments[0]}.#{segments[1]}")
+    end
+
+    # @returns [Hash{String => Gem::Version}] The locked gem versions, keyed by the gems' names.
+    def read_gem_versions_from_target_lockfile
+      lockfile_path = bundler_lock_file_path
+      return nil unless lockfile_path
+
+      Lockfile.new(lockfile_path).gem_versions
     end
 
     def enable_cop?(qualified_cop_name, cop_options)

data/lib/rubocop/config_finder.rb

@@ -17,8 +17,8 @@ module RuboCop
       attr_writer :project_root
 
       def find_config_path(target_dir)
-        find_project_dotfile(target_dir) || find_user_dotfile || find_user_xdg_config ||
-          DEFAULT_FILE
+        find_project_dotfile(target_dir) || find_project_root_dot_config ||
+          find_user_dotfile || find_user_xdg_config || DEFAULT_FILE
       end
 
       # Returns the path RuboCop inferred as the root of the project. No file
@@ -41,19 +41,29 @@ module RuboCop
         find_file_upwards(DOTFILE, target_dir, project_root)
       end
 
+      def find_project_root_dot_config
+        return unless project_root
+
+        dotfile = File.join(project_root, '.config', DOTFILE)
+        return dotfile if File.exist?(dotfile)
+
+        xdg_config = File.join(project_root, '.config', 'rubocop', XDG_CONFIG)
+        xdg_config if File.exist?(xdg_config)
+      end
+
       def find_user_dotfile
         return unless ENV.key?('HOME')
 
         file = File.join(Dir.home, DOTFILE)
 
-        return file if File.exist?(file)
+        file if File.exist?(file)
       end
 
       def find_user_xdg_config
         xdg_config_home = expand_path(ENV.fetch('XDG_CONFIG_HOME', '~/.config'))
         xdg_config = File.join(xdg_config_home, 'rubocop', XDG_CONFIG)
 
-        return xdg_config if File.exist?(xdg_config)
+        xdg_config if File.exist?(xdg_config)
       end
 
       def expand_path(path)

data/lib/rubocop/config_loader.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'erb'
-require 'pathname'
 require 'yaml'
 require_relative 'config_finder'
 

data/lib/rubocop/config_obsoletion/parameter_rule.rb

@@ -19,7 +19,7 @@ module RuboCop
       end
 
       def violated?
-        config[cop]&.key?(parameter)
+        applies_to_current_ruby_version? && config[cop]&.key?(parameter)
       end
 
       def warning?
@@ -28,6 +28,14 @@ module RuboCop
 
       private
 
+      def applies_to_current_ruby_version?
+        minimum_ruby_version = metadata['minimum_ruby_version']
+
+        return true unless minimum_ruby_version
+
+        config.target_ruby_version >= minimum_ruby_version
+      end
+
       def alternative
         metadata['alternative']
       end

data/lib/rubocop/config_obsoletion.rb

@@ -15,6 +15,8 @@ module RuboCop
       'changed_parameters' => ChangedParameter,
       'changed_enforced_styles' => ChangedEnforcedStyles
     }.freeze
+    LOAD_RULES_CACHE = {} # rubocop:disable Style/MutableConstant
+    private_constant :LOAD_RULES_CACHE
 
     attr_reader :rules, :warnings
 
@@ -48,16 +50,17 @@ module RuboCop
     # Default rules for obsoletions are in config/obsoletion.yml
     # Additional rules files can be added with `RuboCop::ConfigObsoletion.files << filename`
     def load_rules # rubocop:disable Metrics/AbcSize
-      rules = self.class.files.each_with_object({}) do |filename, hash|
-        hash.merge!(YAML.safe_load(File.read(filename))) do |_key, first, second|
-          case first
-          when Hash
-            first.merge(second)
-          when Array
-            first.concat(second)
+      rules = LOAD_RULES_CACHE[self.class.files] ||=
+        self.class.files.each_with_object({}) do |filename, hash|
+          hash.merge!(YAML.safe_load(File.read(filename)) || {}) do |_key, first, second|
+            case first
+            when Hash
+              first.merge(second)
+            when Array
+              first.concat(second)
+            end
           end
         end
-      end
 
       cop_rules = rules.slice(*COP_RULE_CLASSES.keys)
       parameter_rules = rules.slice(*PARAMETER_RULE_CLASSES.keys)

data/lib/rubocop/config_validator.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'pathname'
-
 module RuboCop
   # Handles validation of configuration, for example cop names, parameter
   # names, and Ruby versions.
@@ -20,6 +18,7 @@ module RuboCop
     # @api private
     CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect].to_set.freeze
     CONFIG_CHECK_DEPARTMENTS = %w[pending override_department].freeze
+    CONFIG_CHECK_AUTOCORRECTS = %w[always contextual disabled].freeze
     private_constant :CONFIG_CHECK_KEYS, :CONFIG_CHECK_DEPARTMENTS
 
     def_delegators :@config, :smart_loaded_path, :for_all_cops
@@ -250,23 +249,31 @@ module RuboCop
       end
     end
 
+    # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
     def check_cop_config_value(hash, parent = nil)
       hash.each do |key, value|
         check_cop_config_value(value, key) if value.is_a?(Hash)
 
         next unless CONFIG_CHECK_KEYS.include?(key) && value.is_a?(String)
 
-        next if key == 'Enabled' && CONFIG_CHECK_DEPARTMENTS.include?(value)
+        if key == 'Enabled' && !CONFIG_CHECK_DEPARTMENTS.include?(value)
+          supposed_values = 'a boolean'
+        elsif key == 'AutoCorrect' && !CONFIG_CHECK_AUTOCORRECTS.include?(value)
+          supposed_values = '`always`, `contextual`, `disabled`, or a boolean'
+        else
+          next
+        end
 
-        raise ValidationError, msg_not_boolean(parent, key, value)
+        raise ValidationError, param_error_message(parent, key, value, supposed_values)
       end
     end
+    # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
     # FIXME: Handling colors in exception messages like this is ugly.
-    def msg_not_boolean(parent, key, value)
+    def param_error_message(parent, key, value, supposed_values)
       "#{Rainbow('').reset}" \
-        "Property #{Rainbow(key).yellow} of cop #{Rainbow(parent).yellow} " \
-        "is supposed to be a boolean and #{Rainbow(value).yellow} is not."
+        "Property #{Rainbow(key).yellow} of #{Rainbow(parent).yellow} cop " \
+        "is supposed to be #{supposed_values} and #{Rainbow(value).yellow} is not."
     end
   end
 end

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -32,7 +32,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, 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
@@ -82,7 +87,9 @@ module RuboCop
           node.array_type? && node.percent_literal?
         end
 
-        percent_array.map(&:source_range).find { |range| range.overlaps?(offense_range) }
+        percent_array.map(&:source_range).find do |range|
+          offense_range.begin_pos > range.begin_pos && range.overlaps?(offense_range)
+        end
       end
 
       def range_of_first_line(range)

data/lib/rubocop/cop/base.rb

@@ -53,23 +53,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 an 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
 
@@ -126,6 +130,29 @@ module RuboCop
         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 +189,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)
@@ -232,6 +261,10 @@ module RuboCop
         @config.target_ruby_version
       end
 
+      def parser_engine
+        @config.parser_engine
+      end
+
       def target_rails_version
         @config.target_rails_version
       end
@@ -241,6 +274,7 @@ module RuboCop
       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 +288,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
@@ -305,6 +339,17 @@ 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
@@ -356,16 +401,6 @@ 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
       end
@@ -389,7 +424,7 @@ module RuboCop
       def use_corrector(range, corrector)
         if autocorrect?
           attempt_correction(range, corrector)
-        elsif corrector && cop_config.fetch('AutoCorrect', true)
+        elsif corrector && (always_autocorrect? || (contextual_autocorrect? && !LSP.enabled?))
           :uncorrected
         else
           :unsupported
@@ -481,6 +516,18 @@ module RuboCop
           range.end_pos + @current_offset
         )
       end
+
+      def target_satisfies_all_gem_version_requirements?
+        self.class.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'

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

@@ -161,9 +161,9 @@ module RuboCop
         end
 
         def gem_options(node)
-          return [] unless node.arguments.last&.type == :hash
+          return [] unless node.last_argument&.type == :hash
 
-          node.arguments.last.keys.map(&:value)
+          node.last_argument.keys.map(&:value)
         end
       end
     end

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

@@ -90,13 +90,11 @@ module RuboCop
           Array(cop_config['AllowedGems'])
         end
 
-        def message(range)
-          gem_specification = range.source
-
+        def message(_range)
           if required_style?
-            format(REQUIRED_MSG, gem_specification: gem_specification)
+            REQUIRED_MSG
           elsif forbidden_style?
-            format(FORBIDDEN_MSG, gem_specification: gem_specification)
+            FORBIDDEN_MSG
           end
         end
 

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

@@ -19,7 +19,15 @@ module RuboCop
       #
       #   gem 'rspec'
       #
-      #   # good only if TreatCommentsAsGroupSeparators is true
+      # @example TreatCommentsAsGroupSeparators: true (default)
+      #   # good
+      #   # For code quality
+      #   gem 'rubocop'
+      #   # For tests
+      #   gem 'rspec'
+      #
+      # @example TreatCommentsAsGroupSeparators: false
+      #   # bad
       #   # For code quality
       #   gem 'rubocop'
       #   # For tests

data/lib/rubocop/cop/correctors/each_to_for_corrector.rb

@@ -34,18 +34,14 @@ module RuboCop
       end
 
       def offending_range
+        begin_range = block_node.source_range.begin
+
         if block_node.arguments?
-          replacement_range(argument_node.source_range.end_pos)
+          begin_range.join(argument_node.source_range.end)
         else
-          replacement_range(block_node.loc.begin.end_pos)
+          begin_range.join(block_node.loc.begin.end)
         end
       end
-
-      def replacement_range(end_pos)
-        Parser::Source::Range.new(block_node.source_range.source_buffer,
-                                  block_node.source_range.begin_pos,
-                                  end_pos)
-      end
     end
   end
 end