rubocop 0.93.1 → 1.79.2

data/lib/rubocop/config_validator.rb

@@ -1,23 +1,28 @@
 # frozen_string_literal: true
 
-require 'pathname'
-
 module RuboCop
   # Handles validation of configuration, for example cop names, parameter
   # names, and Ruby versions.
+  # rubocop:disable Metrics/ClassLength
   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 Reference References].freeze
     # @api private
     INTERNAL_PARAMS = %w[Description StyleGuide
                          VersionAdded VersionChanged VersionRemoved
-                         Reference Safe SafeAutoCorrect].freeze
+                         Reference References Safe SafeAutoCorrect].freeze
     # @api private
     NEW_COPS_VALUES = %w[pending disable enable].freeze
 
+    # @api private
+    CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect References].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
 
     def initialize(config)
@@ -37,10 +42,10 @@ module RuboCop
         ConfigLoader.default_configuration.key?(key)
       end
 
-      @config_obsoletion.reject_obsolete_cops_and_parameters
+      validate_parameter_shape(valid_cop_names)
 
+      check_obsoletions
       alert_about_unrecognized_cops(invalid_cop_names)
-      check_target_ruby
       validate_new_cops_parameter
       validate_parameter_names(valid_cop_names)
       validate_enforced_styles(valid_cop_names)
@@ -48,21 +53,30 @@ module RuboCop
       reject_mutually_exclusive_defaults
     end
 
-    def target_ruby_version
-      target_ruby.version
+    # Validations that should only be run after all config resolving has
+    # taken place:
+    # * The target ruby version is only checked once the entire inheritance
+    # chain has been loaded so that only the final value is validated, and
+    # any obsolete but overridden values are ignored.
+    def validate_after_resolution
+      check_target_ruby
     end
 
-    def validate_section_presence(name)
-      return unless @config.key?(name) && @config[name].nil?
-
-      raise ValidationError,
-            "empty section #{name} found in #{smart_loaded_path}"
+    def target_ruby_version
+      target_ruby.version
     end
 
     private
 
     attr_reader :target_ruby
 
+    def check_obsoletions
+      @config_obsoletion.reject_obsolete!
+      return unless @config_obsoletion.warnings.any?
+
+      warn Rainbow("Warning: #{@config_obsoletion.warnings.join("\n")}").yellow
+    end
+
     def check_target_ruby
       return if target_ruby.supported?
 
@@ -71,11 +85,11 @@ module RuboCop
 
       msg = if last_version
               "RuboCop found unsupported Ruby version #{target_ruby_version} " \
-              "in #{source}. #{target_ruby_version}-compatible " \
-              "analysis was dropped after version #{last_version}."
+                "in #{source}. #{target_ruby_version}-compatible " \
+                "analysis was dropped after version #{last_version}."
             else
               'RuboCop found unknown Ruby version ' \
-              "#{target_ruby_version.inspect} in #{source}."
+                "#{target_ruby_version.inspect} in #{source}."
             end
 
       msg += "\nSupported versions: #{TargetRuby.supported_versions.join(', ')}"
@@ -84,38 +98,74 @@ module RuboCop
     end
 
     def alert_about_unrecognized_cops(invalid_cop_names)
+      unknown_cops = list_unknown_cops(invalid_cop_names)
+
+      return if unknown_cops.empty?
+
+      if ConfigLoader.ignore_unrecognized_cops
+        warn Rainbow('The following cops or departments are not ' \
+                     'recognized and will be ignored:').yellow
+        warn unknown_cops.join("\n")
+
+        return
+      end
+
+      raise ValidationError, unknown_cops.join("\n")
+    end
+
+    def list_unknown_cops(invalid_cop_names)
       unknown_cops = []
       invalid_cop_names.each do |name|
         # There could be a custom cop with this name. If so, don't warn
         next if Cop::Registry.global.contains_cop_matching?([name])
+        next if ConfigObsoletion.deprecated_cop_name?(name)
 
         # Special case for inherit_mode, which is a directive that we keep in
         # the configuration (even though it's not a cop), because it's easier
         # to do so than to pass the value around to various methods.
         next if name == 'inherit_mode'
 
-        unknown_cops << "unrecognized cop #{name} found in " \
-          "#{smart_loaded_path}"
+        message = <<~MESSAGE.rstrip
+          unrecognized cop or department #{name} found in #{smart_loaded_path}
+          #{suggestion(name)}
+        MESSAGE
+
+        unknown_cops << message
+      end
+
+      unknown_cops
+    end
+
+    def suggestion(name)
+      registry = Cop::Registry.global
+      departments = registry.departments.map(&:to_s)
+      suggestions = NameSimilarity.find_similar_names(name, departments + registry.map(&:cop_name))
+      if suggestions.any?
+        "Did you mean `#{suggestions.join('`, `')}`?"
+      else
+        # Department names can contain slashes, e.g. Chef/Correctness, but there's no support for
+        # the concept of higher level departments in RuboCop. It's a flat structure. So if the user
+        # tries to configure a "top level department", we hint that it's the bottom level
+        # departments that should be configured.
+        suggestions = departments.select { |department| department.start_with?("#{name}/") }
+        "#{name} is not a department. Use `#{suggestions.join('`, `')}`." if suggestions.any?
       end
-      raise ValidationError, unknown_cops.join(', ') if unknown_cops.any?
     end
 
     def validate_syntax_cop
       syntax_config = @config['Lint/Syntax']
       default_config = ConfigLoader.default_configuration['Lint/Syntax']
 
-      return unless syntax_config &&
-                    default_config.merge(syntax_config) != default_config
+      return unless syntax_config && default_config.merge(syntax_config) != default_config
 
       raise ValidationError,
-            "configuration for Syntax cop found in #{smart_loaded_path}\n" \
+            "configuration for Lint/Syntax cop found in #{smart_loaded_path}\n" \
             'It\'s not possible to disable this cop.'
     end
 
     def validate_new_cops_parameter
       new_cop_parameter = @config.for_all_cops['NewCops']
-      return if new_cop_parameter.nil? ||
-                NEW_COPS_VALUES.include?(new_cop_parameter)
+      return if new_cop_parameter.nil? || NEW_COPS_VALUES.include?(new_cop_parameter)
 
       message = "invalid #{new_cop_parameter} for `NewCops` found in" \
                 "#{smart_loaded_path}\n" \
@@ -124,9 +174,22 @@ module RuboCop
       raise ValidationError, message
     end
 
+    def validate_parameter_shape(valid_cop_names)
+      valid_cop_names.each do |name|
+        if @config[name].nil?
+          raise ValidationError, "empty section #{name.inspect} found in #{smart_loaded_path}"
+        elsif !@config[name].is_a?(Hash)
+          raise ValidationError, <<~MESSAGE
+            The configuration for #{name.inspect} in #{smart_loaded_path} is not a Hash.
+
+            Found: #{@config[name].inspect}
+          MESSAGE
+        end
+      end
+    end
+
     def validate_parameter_names(valid_cop_names)
       valid_cop_names.each do |name|
-        validate_section_presence(name)
         each_invalid_parameter(name) do |param, supported_params|
           warn Rainbow(<<~MESSAGE).yellow
             Warning: #{name} does not support #{param} parameter.
@@ -164,8 +227,8 @@ module RuboCop
           next if validate_support_and_has_list(name, style, valid)
 
           msg = "invalid #{style_name} '#{style}' for #{name} found in " \
-            "#{smart_loaded_path}\n" \
-            "Valid choices are: #{valid.join(', ')}"
+                "#{smart_loaded_path}\n" \
+                "Valid choices are: #{valid.join(', ')}"
           raise ValidationError, msg
         end
       end
@@ -189,36 +252,40 @@ module RuboCop
     def reject_conflicting_safe_settings
       @config.each do |name, cop_config|
         next unless cop_config.is_a?(Hash)
-        next unless cop_config['Safe'] == false &&
-                    cop_config['SafeAutoCorrect'] == true
+        next unless cop_config['Safe'] == false && cop_config['SafeAutoCorrect'] == true
 
-        msg = 'Unsafe cops cannot have a safe auto-correction ' \
+        msg = 'Unsafe cops cannot have a safe autocorrection ' \
               "(section #{name} in #{smart_loaded_path})"
         raise ValidationError, msg
       end
     end
 
-    def check_cop_config_value(hash, parent = nil)
+    def check_cop_config_value(hash, parent = nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       hash.each do |key, value|
         check_cop_config_value(value, key) if value.is_a?(Hash)
 
-        next unless %w[Enabled
-                       Safe
-                       SafeAutoCorrect
-                       AutoCorrect].include?(key) && value.is_a?(String)
+        next unless CONFIG_CHECK_KEYS.include?(key) && value.is_a?(String)
 
-        next if key == 'Enabled' &&
-                %w[pending override_department].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'
+        elsif key == 'References'
+          supposed_values = 'an array of strings'
+        else
+          next
+        end
 
-        raise ValidationError, msg_not_boolean(parent, key, value)
+        raise ValidationError, param_error_message(parent, key, value, supposed_values)
       end
     end
 
     # 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
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -8,8 +8,12 @@ module RuboCop
         autocorrect_requested? && correctable? && autocorrect_enabled?
       end
 
+      def autocorrect_with_disable_uncorrectable?
+        autocorrect_requested? && disable_uncorrectable? && autocorrect_enabled?
+      end
+
       def autocorrect_requested?
-        @options.fetch(:auto_correct, false)
+        @options.fetch(:autocorrect, false)
       end
 
       def correctable?
@@ -21,41 +25,99 @@ module RuboCop
       end
 
       def safe_autocorrect?
-        cop_config.fetch('Safe', true) &&
-          cop_config.fetch('SafeAutoCorrect', true)
+        cop_config.fetch('Safe', true) && cop_config.fetch('SafeAutoCorrect', true)
       end
 
       def autocorrect_enabled?
         # 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'])
 
-        return safe_autocorrect? if @options.fetch(:safe_auto_correct, false)
+        # 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
+        return safe_autocorrect? if @options.fetch(:safe_autocorrect, false)
 
         true
       end
 
       private
 
-      def disable_offense(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)
+      def disable_offense(offense_range)
+        unbreakable_range = multiline_ranges(offense_range)&.find do |range|
+          eol_comment_would_be_inside_literal?(offense_range, range)
+        end
+
+        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 multiline_ranges(offense_range)
+        return if offense_range.empty?
+
+        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 eol_comment_would_be_inside_literal?(offense_range, literal_range)
+        return true if line_with_eol_comment_too_long?(offense_range)
+
+        offense_line = offense_range.line
+        offense_line >= literal_range.first_line && offense_line < literal_range.last_line
+      end
+
+      def line_with_eol_comment_too_long?(range)
+        (range.source_line + eol_comment).length > max_line_length
+      end
+
+      def surrounding_heredoc?(node)
+        node.type?(:str, :dstr, :xstr) && node.heredoc?
+      end
+
+      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.type?(:str, :dstr, :xstr) && node.source.match?(/\\\s*$/)
+      end
+
+      def multiline_string?(node)
+        node.dstr_type? && node.multiline?
+      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
 
-        Parser::Source::Range.new(range.source_buffer,
-                                  begin_of_first_line,
-                                  end_of_first_line)
+        Parser::Source::Range.new(range.source_buffer, begin_of_first_line, end_of_first_line)
       end
 
       # Expand the given range to include all of any lines it covers. Does not
@@ -67,19 +129,21 @@ module RuboCop
         last_line_offset = last_line.length - range.last_column
         end_of_last_line = range.end_pos + last_line_offset
 
-        Parser::Source::Range.new(range.source_buffer,
-                                  begin_of_first_line,
-                                  end_of_last_line)
+        Parser::Source::Range.new(range.source_buffer, begin_of_first_line, end_of_last_line)
       end
 
       def max_line_length
         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

@@ -10,37 +10,32 @@ module RuboCop
     # allow for badge references in source files that omit the department for
     # RuboCop to infer.
     class Badge
-      # Error raised when a badge parse fails.
-      class InvalidBadge < Error
-        MSG = 'Invalid badge %<badge>p. ' \
-              'Expected `Department/CopName` or `CopName`.'
-
-        def initialize(token)
-          super(format(MSG, badge: token))
-        end
-      end
-
-      attr_reader :department, :cop_name
+      attr_reader :department, :department_name, :cop_name
 
       def self.for(class_name)
-        new(*class_name.split('::').last(2))
+        parts = class_name.split('::')
+        name_deep_enough = parts.length >= 4
+        new(name_deep_enough ? parts[2..] : parts.last(2))
       end
 
+      @parse_cache = {}
+
       def self.parse(identifier)
-        parts = identifier.split('/', 2)
+        @parse_cache[identifier] ||= new(identifier.split('/').map! { |i| camel_case(i) })
+      end
 
-        raise InvalidBadge, identifier if parts.size > 2
+      def self.camel_case(name_part)
+        return 'RSpec' if name_part == 'rspec'
+        return name_part unless name_part.match?(/^[a-z]|_[a-z]/)
 
-        if parts.one?
-          new(nil, *parts)
-        else
-          new(*parts)
-        end
+        name_part.gsub(/^[a-z]|_[a-z]/) { |match| match[-1, 1].upcase }
       end
 
-      def initialize(department, cop_name)
-        @department = department.to_sym if department
-        @cop_name   = cop_name
+      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
 
       def ==(other)
@@ -49,12 +44,12 @@ 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)
-        cop_name == other.cop_name &&
-          (!qualified? || department == other.department)
+        cop_name == other.cop_name && (!qualified? || department == other.department)
       end
 
       def to_s
@@ -66,7 +61,7 @@ module RuboCop
       end
 
       def with_department(department)
-        self.class.new(department, cop_name)
+        self.class.new([department.to_s.split('/'), cop_name].flatten)
       end
     end
   end