rubocop 1.50.2 → 1.68.0

data/lib/rubocop/config_validator.rb

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
-require 'pathname'
-
 module RuboCop
   # Handles validation of configuration, for example cop names, parameter
   # names, and Ruby versions.
   class ConfigValidator
-    extend Forwardable
+    extend SimpleForwardable
 
     # @api private
-    COMMON_PARAMS = %w[Exclude Include Severity inherit_mode AutoCorrect StyleGuide Details].freeze
+    COMMON_PARAMS = %w[Exclude Include Severity inherit_mode AutoCorrect StyleGuide Details
+                       Enabled].freeze
     # @api private
     INTERNAL_PARAMS = %w[Description StyleGuide
                          VersionAdded VersionChanged VersionRemoved
@@ -20,6 +19,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 +250,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
@@ -44,7 +49,9 @@ module RuboCop
       private
 
       def disable_offense(offense_range)
-        range = surrounding_heredoc(offense_range) || surrounding_percent_array(offense_range)
+        range = surrounding_heredoc(offense_range) ||
+                surrounding_percent_array(offense_range) ||
+                string_continuation(offense_range)
 
         if range
           disable_offense_before_and_after(range_by_lines(range))
@@ -82,7 +89,27 @@ 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|
+          range_overlaps_offense?(offense_range, range)
+        end
+      end
+
+      def string_continuation(offense_range)
+        return nil if offense_range.empty?
+
+        string_continuation_nodes = processed_source.ast.each_descendant.filter_map do |node|
+          range_by_lines(node.source_range) if string_continuation?(node)
+        end
+
+        string_continuation_nodes.find { |range| range_overlaps_offense?(offense_range, range) }
+      end
+
+      def range_overlaps_offense?(offense_range, range)
+        offense_range.begin_pos > range.begin_pos && range.overlaps?(offense_range)
+      end
+
+      def string_continuation?(node)
+        (node.str_type? || node.dstr_type? || node.xstr_type?) && node.source.match?(/\\\s*$/)
       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
@@ -240,7 +273,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 +292,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
@@ -284,8 +322,12 @@ module RuboCop
       # @api private
       def self.callbacks_needed
         @callbacks_needed ||= public_instance_methods.select do |m|
-          m.match?(/^on_|^after_/) &&
-            !Base.method_defined?(m) # exclude standard "callbacks" like 'on_begin_investigation'
+          # OPTIMIZE: Check method existence first to make fewer `start_with?` calls.
+          # At the time of writing this comment, this excludes 98 of ~104 methods.
+          # `start_with?` with two string arguments instead of a regex is faster
+          # in this specific case as well.
+          !Base.method_defined?(m) && # exclude standard "callbacks" like 'on_begin_investigation'
+            m.start_with?('on_', 'after_')
         end
       end
       # rubocop:enable Layout/ClassStructure
@@ -305,6 +347,21 @@ 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 Cop::Cop
@@ -352,16 +409,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
@@ -385,7 +432,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
@@ -477,6 +524,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

@@ -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) }
@@ -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

@@ -56,6 +56,7 @@ module RuboCop
 
         REQUIRED_MSG = 'Gem version specification is required.'
         FORBIDDEN_MSG = 'Gem version specification is forbidden.'
+        RESTRICT_ON_SEND = %i[gem].freeze
         VERSION_SPECIFICATION_REGEX = /^\s*[~<>=]*\s*[0-9.]+/.freeze
 
         # @!method includes_version_specification?(node)
@@ -90,13 +91,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
 
@@ -105,13 +104,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/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/cop.rb

@@ -22,6 +22,14 @@ module RuboCop
         end
       end
 
+      def self.inherited(_subclass)
+        super
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          Inheriting from `RuboCop::Cop::Cop` is deprecated. Use `RuboCop::Cop::Base` instead.
+          For more information, see https://docs.rubocop.org/rubocop/v1_upgrade_notes.html.
+        WARNING
+      end
+
       def self.support_autocorrect?
         method_defined?(:autocorrect)
       end
@@ -37,16 +45,28 @@ module RuboCop
 
       # @deprecated Use Registry.global
       def self.registry
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.registry` is deprecated. Use `Registry.global` instead.
+        WARNING
+
         Registry.global
       end
 
       # @deprecated Use Registry.all
       def self.all
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.all` is deprecated. Use `Registry.all` instead.
+        WARNING
+
         Registry.all
       end
 
       # @deprecated Use Registry.qualified_cop_name
       def self.qualified_cop_name(name, origin)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.qualified_cop_name` is deprecated. Use `Registry.qualified_cop_name` instead.
+        WARNING
+
         Registry.qualified_cop_name(name, origin)
       end
 
@@ -58,7 +78,7 @@ module RuboCop
         # template file, we convert it to location info in the original file.
         range = range_for_original(range)
 
-        if block.nil? && !support_autocorrect?
+        if block.nil? && !self.class.support_autocorrect?
           super(range, message: message, severity: severity)
         else
           super(range, message: message, severity: severity) do |corrector|
@@ -74,13 +94,19 @@ module RuboCop
 
       # @deprecated Use class method
       def support_autocorrect?
-        # warn 'deprecated, use cop.class.support_autocorrect?' TODO
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `support_autocorrect?` is deprecated. Use `cop.class.support_autocorrect?`.
+        WARNING
+
         self.class.support_autocorrect?
       end
 
       # @deprecated
       def corrections
-        # warn 'Cop#corrections is deprecated' TODO
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop#corrections` is deprecated.
+        WARNING
+
         return [] unless @last_corrector
 
         Legacy::CorrectionsProxy.new(@last_corrector)
@@ -136,7 +162,7 @@ module RuboCop
       end
 
       def correction_lambda
-        return unless support_autocorrect?
+        return unless self.class.support_autocorrect?
 
         dedupe_on_node(@v0_argument) { autocorrect(@v0_argument) }
       end

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

@@ -47,14 +47,14 @@ module RuboCop
           if column_delta.positive? && range.resize(1).source != "\n"
             corrector.insert_before(range, ' ' * column_delta)
           elsif /\A[ \t]+\z/.match?(range.source)
-            remove(range, corrector)
+            corrector.remove(range)
           end
         end
 
         def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 
-          node.each_node(:str, :dstr, :xstr).map { |n| inside_string_range(n) }.compact
+          node.each_node(:str, :dstr, :xstr).filter_map { |n| inside_string_range(n) }
         end
 
         def inside_string_range(node)
@@ -96,17 +96,6 @@ module RuboCop
           end
         end
 
-        def remove(range, corrector)
-          original_stderr = $stderr
-          $stderr = StringIO.new # Avoid error messages on console
-          corrector.remove(range)
-        rescue RuntimeError
-          range = range_between(range.begin_pos + 1, range.end_pos + 1)
-          retry if /^ +$/.match?(range.source)
-        ensure
-          $stderr = original_stderr
-        end
-
         def each_line(expr)
           line_begin_pos = expr.begin_pos
           expr.source.each_line do |line|

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