rubocop 0.73.0 → 0.74.0

data/lib/rubocop/config_obsoletion.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This class handles obsolete configuration.
+  class ConfigObsoletion
+    RENAMED_COPS = {
+      'Style/SingleSpaceBeforeFirstArg' => 'Layout/SpaceBeforeFirstArg',
+      'Style/MethodCallParentheses' => 'Style/MethodCallWithoutArgsParentheses',
+      'Style/DeprecatedHashMethods' => 'Style/PreferredHashMethods',
+      'Style/OpMethod' => 'Naming/BinaryOperatorParameterName',
+      'Layout/FirstParameterIndentation' => 'Layout/IndentFirstArgument',
+      'Layout/IndentArray' => 'Layout/IndentFirstArrayElement',
+      'Layout/IndentHash' => 'Layout/IndentFirstHashElement'
+    }.map do |old_name, new_name|
+      [old_name, "The `#{old_name}` cop has been renamed to `#{new_name}`."]
+    end
+
+    MOVED_COPS = {
+      'Security' => 'Lint/Eval',
+      'Naming' => %w[Style/ClassAndModuleCamelCase Style/ConstantName
+                     Style/FileName Style/MethodName Style/PredicateName
+                     Style/VariableName Style/VariableNumber
+                     Style/AccessorMethodName Style/AsciiIdentifiers],
+      'Layout' => %w[Lint/BlockAlignment Lint/EndAlignment
+                     Lint/DefEndAlignment],
+      'Lint' => 'Style/FlipFlop'
+    }.map do |new_department, old_names|
+      Array(old_names).map do |old_name|
+        [old_name, "The `#{old_name}` cop has been moved to " \
+                   "`#{new_department}/#{old_name.split('/').last}`."]
+      end
+    end
+
+    REMOVED_COPS = {
+      'Rails/DefaultScope' => nil,
+      'Layout/SpaceAfterControlKeyword' => 'Layout/SpaceAroundKeyword',
+      'Layout/SpaceBeforeModifierKeyword' => 'Layout/SpaceAroundKeyword',
+      'Style/SpaceAfterControlKeyword' => 'Layout/SpaceAroundKeyword',
+      'Style/SpaceBeforeModifierKeyword' => 'Layout/SpaceAroundKeyword',
+      'Style/TrailingComma' => 'Style/TrailingCommaInArguments, ' \
+                               'Style/TrailingCommaInArrayLiteral, and/or ' \
+                               'Style/TrailingCommaInHashLiteral',
+      'Style/TrailingCommaInLiteral' => 'Style/TrailingCommaInArrayLiteral ' \
+                                        'and/or ' \
+                                        'Style/TrailingCommaInHashLiteral',
+      'Lint/RescueWithoutErrorClass' => 'Style/RescueStandardError'
+    }.map do |old_name, other_cops|
+      if other_cops
+        more = ". Please use #{other_cops} instead".gsub(%r{[A-Z]\w+/\w+},
+                                                         '`\&`')
+      end
+      [old_name, "The `#{old_name}` cop has been removed#{more}."]
+    end
+
+    REMOVED_COPS_WITH_REASON = {
+      'Lint/InvalidCharacterLiteral' => 'it was never being actually triggered',
+      'Lint/SpaceBeforeFirstArg' =>
+        'it was a duplicate of `Layout/SpaceBeforeFirstArg`. Please use ' \
+        '`Layout/SpaceBeforeFirstArg` instead'
+    }.map do |cop_name, reason|
+      [cop_name, "The `#{cop_name}` cop has been removed since #{reason}."]
+    end
+
+    SPLIT_COPS = {
+      'Style/MethodMissing' =>
+        'The `Style/MethodMissing` cop has been split into ' \
+        '`Style/MethodMissingSuper` and `Style/MissingRespondToMissing`.'
+    }.to_a
+
+    OBSOLETE_COPS = Hash[*(RENAMED_COPS + MOVED_COPS + REMOVED_COPS +
+                           REMOVED_COPS_WITH_REASON + SPLIT_COPS).flatten]
+
+    OBSOLETE_PARAMETERS = [
+      {
+        cops: %w[Layout/SpaceAroundOperators Style/SpaceAroundOperators],
+        parameters: 'MultiSpaceAllowedForOperators',
+        alternative: 'If your intention was to allow extra spaces for ' \
+                     'alignment, please use AllowForAlignment: true instead.'
+      },
+      {
+        cops: 'Style/Encoding',
+        parameters: %w[EnforcedStyle SupportedStyles
+                       AutoCorrectEncodingComment],
+        alternative: 'Style/Encoding no longer supports styles. ' \
+                     'The "never" behavior is always assumed.'
+      },
+      {
+        cops: 'Style/IfUnlessModifier',
+        parameters: 'MaxLineLength',
+        alternative: '`Style/IfUnlessModifier: MaxLineLength` has been ' \
+                     'removed. Use `Metrics/LineLength: Max` instead'
+      },
+      {
+        cops: 'Style/WhileUntilModifier',
+        parameters: 'MaxLineLength',
+        alternative: '`Style/WhileUntilModifier: MaxLineLength` has been ' \
+                     'removed. Use `Metrics/LineLength: Max` instead'
+      },
+      {
+        cops: 'AllCops',
+        parameters: 'RunRailsCops',
+        alternative: "Use the following configuration instead:\n" \
+                     "Rails:\n  Enabled: true"
+      },
+      {
+        cops: 'Layout/CaseIndentation',
+        parameters: 'IndentWhenRelativeTo',
+        alternative: '`IndentWhenRelativeTo` has been renamed to ' \
+                     '`EnforcedStyle`'
+      },
+      {
+        cops: %w[Lint/BlockAlignment Layout/BlockAlignment Lint/EndAlignment
+                 Layout/EndAlignment Lint/DefEndAlignment
+                 Layout/DefEndAlignment],
+        parameters: 'AlignWith',
+        alternative: '`AlignWith` has been renamed to `EnforcedStyleAlignWith`'
+      },
+      {
+        cops: 'Rails/UniqBeforePluck',
+        parameters: 'EnforcedMode',
+        alternative: '`EnforcedMode` has been renamed to `EnforcedStyle`'
+      }
+    ].freeze
+
+    OBSOLETE_ENFORCED_STYLES = [
+      {
+        cop: 'Layout/IndentationConsistency',
+        parameter: 'EnforcedStyle',
+        enforced_style: 'rails',
+        alternative: '`EnforcedStyle: rails` has been renamed to ' \
+                     '`EnforcedStyle: indented_internal_methods`'
+      }
+    ].freeze
+
+    def initialize(config)
+      @config = config
+    end
+
+    def reject_obsolete_cops_and_parameters
+      messages = [obsolete_cops, obsolete_parameters,
+                  obsolete_enforced_style].flatten.compact
+      return if messages.empty?
+
+      raise ValidationError, messages.join("\n")
+    end
+
+    private
+
+    def obsolete_cops
+      OBSOLETE_COPS.map do |cop_name, message|
+        next unless @config.key?(cop_name) ||
+                    @config.key?(Cop::Badge.parse(cop_name).cop_name)
+
+        message + "\n(obsolete configuration found in " \
+                  "#{smart_loaded_path}, please update it)"
+      end
+    end
+
+    def obsolete_enforced_style
+      OBSOLETE_ENFORCED_STYLES.map do |params|
+        obsolete_enforced_style_message(params[:cop], params[:parameter],
+                                        params[:enforced_style],
+                                        params[:alternative])
+      end
+    end
+
+    def obsolete_enforced_style_message(cop, param, enforced_style, alternative)
+      style = @config[cop]&.detect { |key, _| key.start_with?(param) }
+
+      return unless style && style[1] == enforced_style
+
+      "obsolete `#{param}: #{enforced_style}` (for #{cop}) found in " \
+      "#{smart_loaded_path}\n#{alternative}"
+    end
+
+    def obsolete_parameters
+      OBSOLETE_PARAMETERS.map do |params|
+        obsolete_parameter_message(params[:cops], params[:parameters],
+                                   params[:alternative])
+      end
+    end
+
+    def obsolete_parameter_message(cops, parameters, alternative)
+      Array(cops).map do |cop|
+        obsolete_parameters = Array(parameters).select do |param|
+          @config[cop]&.key?(param)
+        end
+        next if obsolete_parameters.empty?
+
+        obsolete_parameters.map do |parameter|
+          "obsolete parameter #{parameter} (for #{cop}) found in " \
+          "#{smart_loaded_path}\n#{alternative}"
+        end
+      end
+    end
+
+    def smart_loaded_path
+      PathUtil.smart_path(@config.loaded_path)
+    end
+  end
+end

data/lib/rubocop/config_validator.rb

@@ -0,0 +1,239 @@
+# 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
+
+    COMMON_PARAMS = %w[Exclude Include Severity inherit_mode
+                       AutoCorrect StyleGuide Details].freeze
+    INTERNAL_PARAMS = %w[Description StyleGuide VersionAdded
+                         VersionChanged Reference Safe SafeAutoCorrect].freeze
+
+    # 2.3 is the oldest officially supported Ruby version.
+    DEFAULT_RUBY_VERSION = 2.3
+    KNOWN_RUBIES = [2.3, 2.4, 2.5, 2.6, 2.7].freeze
+    OBSOLETE_RUBIES = {
+      1.9 => '0.50', 2.0 => '0.50', 2.1 => '0.58', 2.2 => '0.69'
+    }.freeze
+    RUBY_VERSION_FILENAME = '.ruby-version'
+
+    def_delegators :@config,
+                   :smart_loaded_path, :for_all_cops, :find_file_upwards,
+                   :base_dir_for_path_parameters, :bundler_lock_file_path
+
+    def initialize(config)
+      @config = config
+      @config_obsoletion = ConfigObsoletion.new(config)
+    end
+
+    def validate
+      # Don't validate RuboCop's own files. Avoids infinite recursion.
+      base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME,
+                                                    'config'))
+      return if File.expand_path(@config.loaded_path)
+                    .start_with?(base_config_path)
+
+      valid_cop_names, invalid_cop_names = @config.keys.partition do |key|
+        ConfigLoader.default_configuration.key?(key)
+      end
+
+      @config_obsoletion.reject_obsolete_cops_and_parameters
+
+      warn_about_unrecognized_cops(invalid_cop_names)
+      check_target_ruby
+      validate_parameter_names(valid_cop_names)
+      validate_enforced_styles(valid_cop_names)
+      validate_syntax_cop
+      reject_mutually_exclusive_defaults
+    end
+
+    def target_ruby_version
+      @target_ruby_version ||= begin
+        if for_all_cops['TargetRubyVersion']
+          @target_ruby_version_source = :rubocop_yml
+
+          for_all_cops['TargetRubyVersion'].to_f
+        elsif target_ruby_version_from_version_file
+          @target_ruby_version_source = :ruby_version_file
+
+          target_ruby_version_from_version_file
+        elsif target_ruby_version_from_bundler_lock_file
+          @target_ruby_version_source = :bundler_lock_file
+
+          target_ruby_version_from_bundler_lock_file
+        else
+          DEFAULT_RUBY_VERSION
+        end
+      end
+    end
+
+    def validate_section_presence(name)
+      return unless @config.key?(name) && @config[name].nil?
+
+      raise ValidationError,
+            "empty section #{name} found in #{smart_loaded_path}"
+    end
+
+    private
+
+    def check_target_ruby
+      return if KNOWN_RUBIES.include?(target_ruby_version)
+
+      msg = if OBSOLETE_RUBIES.include?(target_ruby_version)
+              "RuboCop found unsupported Ruby version #{target_ruby_version} " \
+              "in #{target_ruby_source}. #{target_ruby_version}-compatible " \
+              'analysis was dropped after version ' \
+              "#{OBSOLETE_RUBIES[target_ruby_version]}."
+            else
+              'RuboCop found unknown Ruby version ' \
+              "#{target_ruby_version.inspect} in #{target_ruby_source}."
+            end
+
+      msg += "\nSupported versions: #{KNOWN_RUBIES.join(', ')}"
+
+      raise ValidationError, msg
+    end
+
+    def warn_about_unrecognized_cops(invalid_cop_names)
+      invalid_cop_names.each do |name|
+        # There could be a custom cop with this name. If so, don't warn
+        next if Cop::Cop.registry.contains_cop_matching?([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'
+
+        warn Rainbow("Warning: unrecognized cop #{name} found in " \
+                     "#{smart_loaded_path}").yellow
+      end
+    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
+
+      raise ValidationError,
+            "configuration for Syntax cop found in #{smart_loaded_path}\n" \
+            'It\'s not possible to disable this cop.'
+    end
+
+    def validate_parameter_names(valid_cop_names)
+      valid_cop_names.each do |name|
+        validate_section_presence(name)
+        default_config = ConfigLoader.default_configuration[name]
+
+        @config[name].each_key do |param|
+          next if COMMON_PARAMS.include?(param) || default_config.key?(param)
+
+          message =
+            "Warning: #{name} does not support #{param} parameter.\n\n" \
+            "Supported parameters are:\n\n" \
+            "  - #{(default_config.keys - INTERNAL_PARAMS).join("\n  - ")}\n"
+
+          warn Rainbow(message).yellow.to_s
+        end
+      end
+    end
+
+    def validate_enforced_styles(valid_cop_names)
+      valid_cop_names.each do |name|
+        styles = @config[name].select { |key, _| key.start_with?('Enforced') }
+
+        styles.each do |style_name, style|
+          supported_key = RuboCop::Cop::Util.to_supported_styles(style_name)
+          valid = ConfigLoader.default_configuration[name][supported_key]
+
+          next unless valid
+          next if valid.include?(style)
+          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(', ')}"
+          raise ValidationError, msg
+        end
+      end
+    end
+
+    def validate_support_and_has_list(name, formats, valid)
+      ConfigLoader.default_configuration[name]['AllowMultipleStyles'] &&
+        formats.is_a?(Array) &&
+        formats.all? { |format| valid.include?(format) }
+    end
+
+    def target_ruby_source
+      case @target_ruby_version_source
+      when :ruby_version_file
+        "`#{RUBY_VERSION_FILENAME}`"
+      when :bundler_lock_file
+        "`#{bundler_lock_file_path}`"
+      when :rubocop_yml
+        "`TargetRubyVersion` parameter (in #{smart_loaded_path})"
+      end
+    end
+
+    def ruby_version_file
+      @ruby_version_file ||=
+        find_file_upwards(RUBY_VERSION_FILENAME, base_dir_for_path_parameters)
+    end
+
+    def target_ruby_version_from_version_file
+      file = ruby_version_file
+      return unless file && File.file?(file)
+
+      @target_ruby_version_from_version_file ||=
+        File.read(file).match(/\A(ruby-)?(?<version>\d+\.\d+)/) do |md|
+          md[:version].to_f
+        end
+    end
+
+    def target_ruby_version_from_bundler_lock_file
+      @target_ruby_version_from_bundler_lock_file ||=
+        read_ruby_version_from_bundler_lock_file
+    end
+
+    def read_ruby_version_from_bundler_lock_file
+      lock_file_path = bundler_lock_file_path
+      return nil unless lock_file_path
+
+      in_ruby_section = false
+      File.foreach(lock_file_path) do |line|
+        # If ruby is in Gemfile.lock or gems.lock, there should be two lines
+        # towards the bottom of the file that look like:
+        #     RUBY VERSION
+        #       ruby W.X.YpZ
+        # We ultimately want to match the "ruby W.X.Y.pZ" line, but there's
+        # extra logic to make sure we only start looking once we've seen the
+        # "RUBY VERSION" line.
+        in_ruby_section ||= line.match(/^\s*RUBY\s*VERSION\s*$/)
+        next unless in_ruby_section
+
+        # We currently only allow this feature to work with MRI ruby. If jruby
+        # (or something else) is used by the project, it's lock file will have a
+        # line that looks like:
+        #     RUBY VERSION
+        #       ruby W.X.YpZ (jruby x.x.x.x)
+        # The regex won't match in this situation.
+        result = line.match(/^\s*ruby\s+(\d+\.\d+)[p.\d]*\s*$/)
+        return result.captures.first.to_f if result
+      end
+    end
+
+    def reject_mutually_exclusive_defaults
+      disabled_by_default = for_all_cops['DisabledByDefault']
+      enabled_by_default = for_all_cops['EnabledByDefault']
+      return unless disabled_by_default && enabled_by_default
+
+      msg = 'Cops cannot be both enabled by default and disabled by default'
+      raise ValidationError, msg
+    end
+  end
+end

data/lib/rubocop/cop/layout/extra_spacing.rb

@@ -41,12 +41,7 @@ module RuboCop
         def investigate(processed_source)
           return if processed_source.blank?
 
-          if force_equal_sign_alignment?
-            @asgn_tokens = assignment_tokens
-            @asgn_lines  = @asgn_tokens.map(&:line)
-            # Don't attempt to correct the same = more than once
-            @corrected   = Set.new
-          end
+          @corrected = Set.new if force_equal_sign_alignment?
 
           processed_source.tokens.each_cons(2) do |token1, token2|
             check_tokens(processed_source.ast, token1, token2)
@@ -65,24 +60,10 @@ module RuboCop
 
         private
 
-        def assignment_tokens
-          tokens = processed_source.tokens.select(&:equal_sign?)
-          # we don't want to operate on equals signs which are part of an
-          #   optarg in a method definition
-          # e.g.: def method(optarg = default_val); end
-          tokens = remove_optarg_equals(tokens, processed_source)
-
-          # Only attempt to align the first = on each line
-          Set.new(tokens.uniq(&:line))
-        end
-
         def check_tokens(ast, token1, token2)
           return if token2.type == :tNL
 
-          if force_equal_sign_alignment? &&
-             @asgn_tokens.include?(token2) &&
-             (@asgn_lines.include?(token2.line - 1) ||
-              @asgn_lines.include?(token2.line + 1))
+          if force_equal_sign_alignment? && assignment_tokens.include?(token2)
             check_assignment(token2)
           else
             check_other(token1, token2, ast)
@@ -90,24 +71,12 @@ module RuboCop
         end
 
         def check_assignment(token)
-          assignment_line = ''
-          message = ''
-          if should_aligned_with_preceding_line?(token)
-            assignment_line = processed_source.preceding_line(token)
-            message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
-          else
-            assignment_line = processed_source.following_line(token)
-            message = format(MSG_UNALIGNED_ASGN, location: 'following')
-          end
-          return if aligned_assignment?(token.pos, assignment_line)
+          return unless aligned_with_preceding_assignment(token) == :no
 
+          message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
           add_offense(token.pos, location: token.pos, message: message)
         end
 
-        def should_aligned_with_preceding_line?(token)
-          @asgn_lines.include?(token.line - 1)
-        end
-
         def check_other(token1, token2, ast)
           return false if allow_for_trailing_comments? &&
                           token2.text.start_with?('#')
@@ -188,8 +157,8 @@ module RuboCop
         end
 
         def align_equal_signs(range, corrector)
-          lines  = contiguous_assignment_lines(range)
-          tokens = @asgn_tokens.select { |t| lines.include?(t.line) }
+          lines  = all_relevant_assignment_lines(range.line)
+          tokens = assignment_tokens.select { |t| lines.include?(t.line) }
 
           columns  = tokens.map { |t| align_column(t) }
           align_to = columns.max
@@ -209,17 +178,15 @@ module RuboCop
           end
         end
 
-        def contiguous_assignment_lines(range)
-          result = [range.line]
-
-          range.line.downto(1) do |lineno|
-            @asgn_lines.include?(lineno) ? result << lineno : break
-          end
-          range.line.upto(processed_source.lines.size) do |lineno|
-            @asgn_lines.include?(lineno) ? result << lineno : break
-          end
+        def all_relevant_assignment_lines(line_number)
+          last_line_number = processed_source.lines.size
 
-          result.sort!
+          (
+            relevant_assignment_lines(line_number.downto(1)) +
+            relevant_assignment_lines(line_number.upto(last_line_number))
+          )
+            .uniq
+            .sort
         end
 
         def align_column(asgn_token)
@@ -231,12 +198,6 @@ module RuboCop
           asgn_token.pos.last_column - spaces + 1
         end
 
-        def remove_optarg_equals(asgn_tokens, processed_source)
-          optargs    = processed_source.ast.each_node(:optarg)
-          optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
-          asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
-        end
-
         def allow_for_trailing_comments?
           cop_config['AllowBeforeTrailingComments']
         end