rubocop 0.80.0 → 1.42.0

data/lib/rubocop/config_obsoletion/changed_enforced_styles.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for changing a parameter
+    # @api private
+    class ChangedEnforcedStyles < ParameterRule
+      BASE_MESSAGE = 'obsolete `%<parameter>s: %<value>s` (for `%<cop>s`) found in %<path>s'
+
+      def violated?
+        super && config[cop][parameter] == value
+      end
+
+      def message
+        base = format(BASE_MESSAGE,
+                      parameter: parameter, value: value, cop: cop, path: smart_loaded_path)
+
+        if alternative
+          "#{base}\n`#{parameter}: #{value}` has been renamed to " \
+            "`#{parameter}: #{alternative.chomp}`."
+        else
+          "#{base}\n#{reason.chomp}"
+        end
+      end
+
+      private
+
+      def value
+        metadata['value']
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/changed_parameter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for changing a parameter
+    # @api private
+    class ChangedParameter < ParameterRule
+      BASE_MESSAGE = 'obsolete parameter `%<parameter>s` (for `%<cop>s`) found in %<path>s'
+
+      def message
+        base = format(BASE_MESSAGE, parameter: parameter, cop: cop, path: smart_loaded_path)
+
+        if alternative
+          "#{base}\n`#{parameter}` has been renamed to `#{alternative.chomp}`."
+        elsif alternatives
+          "#{base}\n`#{parameter}` has been renamed to #{to_sentence(alternatives.map do |item|
+                                                                       "`#{item}`"
+                                                                     end,
+                                                                     connector: 'and/or')}."
+        else
+          "#{base}\n#{reason.chomp}"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/cop_rule.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Base class for ConfigObsoletion rules relating to cops
+    # @api private
+    class CopRule < Rule
+      attr_reader :old_name
+
+      def initialize(config, old_name)
+        super(config)
+        @old_name = old_name
+      end
+
+      def cop_rule?
+        true
+      end
+
+      def message
+        rule_message + "\n(obsolete configuration found in #{smart_loaded_path}, please update it)"
+      end
+
+      # Cop rules currently can only be failures, not warnings
+      def warning?
+        false
+      end
+
+      def violated?
+        config.key?(old_name) || config.key?(Cop::Badge.parse(old_name).cop_name)
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/extracted_cop.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for splitting a cop's
+    # functionality into multiple new cops.
+    # @api private
+    class ExtractedCop < CopRule
+      attr_reader :gem, :department
+
+      def initialize(config, old_name, gem)
+        super(config, old_name)
+        @department, * = old_name.rpartition('/')
+        @gem = gem
+      end
+
+      def violated?
+        return false if feature_loaded?
+
+        affected_cops.any?
+      end
+
+      def rule_message
+        msg = '%<name>s been extracted to the `%<gem>s` gem.'
+        format(msg,
+               name: affected_cops.size > 1 ? "`#{department}` cops have" : "`#{old_name}` has",
+               gem: gem)
+      end
+
+      private
+
+      def affected_cops
+        return old_name unless old_name.end_with?('*')
+
+        # Handle whole departments (expressed as `Department/*`)
+        config.keys.select do |key|
+          key == department || key.start_with?("#{department}/")
+        end
+      end
+
+      def feature_loaded?
+        config.loaded_features.include?(gem)
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/parameter_rule.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Base class for ConfigObsoletion rules relating to parameters
+    # @api private
+    class ParameterRule < Rule
+      attr_reader :cop, :parameter, :metadata
+
+      def initialize(config, cop, parameter, metadata)
+        super(config)
+        @cop = cop
+        @parameter = parameter
+        @metadata = metadata
+      end
+
+      def parameter_rule?
+        true
+      end
+
+      def violated?
+        config[cop]&.key?(parameter)
+      end
+
+      def warning?
+        severity == 'warning'
+      end
+
+      private
+
+      def alternative
+        metadata['alternative']
+      end
+
+      def alternatives
+        metadata['alternatives']
+      end
+
+      def reason
+        metadata['reason']
+      end
+
+      def severity
+        metadata['severity']
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/removed_cop.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for removing
+    # a previously defined cop.
+    # @api private
+    class RemovedCop < CopRule
+      attr_reader :old_name, :metadata
+
+      BASE_MESSAGE = 'The `%<old_name>s` cop has been removed'
+
+      def initialize(config, old_name, metadata)
+        super(config, old_name)
+        @metadata = metadata.is_a?(Hash) ? metadata : {}
+      end
+
+      def rule_message
+        base = format(BASE_MESSAGE, old_name: old_name)
+
+        if reason
+          "#{base} since #{reason.chomp}."
+        elsif alternatives
+          "#{base}. Please use #{to_sentence(alternatives, connector: 'and/or')} instead."
+        else
+          "#{base}."
+        end
+      end
+
+      private
+
+      def reason
+        metadata['reason']
+      end
+
+      def alternatives
+        Array(metadata['alternatives']).map { |name| "`#{name}`" }
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/renamed_cop.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for renaming
+    # a cop or moving it to a new department.
+    # @api private
+    class RenamedCop < CopRule
+      attr_reader :new_name
+
+      def initialize(config, old_name, new_name)
+        super(config, old_name)
+        @new_name = new_name
+      end
+
+      def rule_message
+        "The `#{old_name}` cop has been #{verb} to `#{new_name}`."
+      end
+
+      private
+
+      def moved?
+        old_badge = Cop::Badge.parse(old_name)
+        new_badge = Cop::Badge.parse(new_name)
+
+        old_badge.department != new_badge.department && old_badge.cop_name == new_badge.cop_name
+      end
+
+      def verb
+        moved? ? 'moved' : 'renamed'
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/rule.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Abstract base class for ConfigObsoletion rules
+    # @api private
+    class Rule
+      def initialize(config)
+        @config = config
+      end
+
+      # Does this rule relate to cops?
+      def cop_rule?
+        false
+      end
+
+      # Does this rule relate to parameters?
+      def parameter_rule?
+        false
+      end
+
+      def violated?
+        raise NotImplementedError
+      end
+
+      private
+
+      attr_reader :config
+
+      def to_sentence(collection, connector: 'and')
+        return collection.first if collection.size == 1
+
+        [collection[0..-2].join(', '), collection[-1]].join(" #{connector} ")
+      end
+
+      def smart_loaded_path
+        PathUtil.smart_path(config.loaded_path)
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/split_cop.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for splitting a cop's
+    # functionality into multiple new cops.
+    # @api private
+    class SplitCop < CopRule
+      attr_reader :metadata
+
+      def initialize(config, old_name, metadata)
+        super(config, old_name)
+        @metadata = metadata
+      end
+
+      def rule_message
+        "The `#{old_name}` cop has been split into #{to_sentence(alternatives)}."
+      end
+
+      private
+
+      def alternatives
+        Array(metadata['alternatives']).map { |name| "`#{name}`" }
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion.rb

@@ -2,218 +2,42 @@
 
 module RuboCop
   # This class handles obsolete configuration.
+  # @api private
   class ConfigObsoletion
-    RENAMED_COPS = {
-      'Layout/AlignArguments' => 'Layout/ArgumentAlignment',
-      'Layout/AlignArray' => 'Layout/ArrayAlignment',
-      'Layout/AlignHash' => 'Layout/HashAlignment',
-      'Layout/AlignParameters' => 'Layout/ParameterAlignment',
-      'Layout/IndentArray' => 'Layout/FirstArrayElementIndentation',
-      'Layout/IndentAssignment' => 'Layout/AssignmentIndentation',
-      'Layout/IndentFirstArgument' => 'Layout/FirstArgumentIndentation',
-      'Layout/IndentFirstArrayElement' => 'Layout/FirstArrayElementIndentation',
-      'Layout/IndentFirstHashElement' => 'Layout/FirstHashElementIndentation',
-      'Layout/IndentFirstParameter' => 'Layout/FirstParameterIndentation',
-      'Layout/IndentHash' => 'Layout/FirstHashElementIndentation',
-      'Layout/IndentHeredoc' => 'Layout/HeredocIndentation',
-      'Layout/LeadingBlankLines' => 'Layout/LeadingEmptyLines',
-      'Layout/TrailingBlankLines' => 'Layout/TrailingEmptyLines',
-      'Lint/DuplicatedKey' => 'Lint/DuplicateHashKey',
-      'Lint/HandleExceptions' => 'Lint/SuppressedException',
-      'Lint/MultipleCompare' => 'Lint/MultipleComparison',
-      'Lint/StringConversionInInterpolation' => 'Lint/RedundantStringCoercion',
-      'Lint/UnneededCopDisableDirective' => 'Lint/RedundantCopDisableDirective',
-      'Lint/UnneededCopEnableDirective' => 'Lint/RedundantCopEnableDirective',
-      'Lint/UnneededRequireStatement' => 'Lint/RedundantRequireStatement',
-      'Lint/UnneededSplatExpansion' => 'Lint/RedundantSplatExpansion',
-      'Naming/UncommunicativeBlockParamName' => 'Naming/BlockParameterName',
-      'Naming/UncommunicativeMethodParamName' => 'Naming/MethodParameterName',
-      'Style/DeprecatedHashMethods' => 'Style/PreferredHashMethods',
-      'Style/MethodCallParentheses' => 'Style/MethodCallWithoutArgsParentheses',
-      'Style/OpMethod' => 'Naming/BinaryOperatorParameterName',
-      'Style/SingleSpaceBeforeFirstArg' => 'Layout/SpaceBeforeFirstArg',
-      'Style/UnneededCapitalW' => 'Style/RedundantCapitalW',
-      'Style/UnneededCondition' => 'Style/RedundantCondition',
-      'Style/UnneededInterpolation' => 'Style/RedundantInterpolation',
-      'Style/UnneededPercentQ' => 'Style/RedundantPercentQ',
-      'Style/UnneededSort' => 'Style/RedundantSort'
-    }.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 Metrics/LineLength],
-      '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 = {
-      'Layout/SpaceAfterControlKeyword' => 'Layout/SpaceAroundKeyword',
-      'Layout/SpaceBeforeModifierKeyword' => 'Layout/SpaceAroundKeyword',
-      'Lint/RescueWithoutErrorClass' => 'Style/RescueStandardError',
-      'Rails/DefaultScope' => nil,
-      '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',
-      'Style/BracesAroundHashParameters' => nil
-    }.map do |old_name, other_cops|
-      if other_cops
-        more = ". Please use #{other_cops} instead".gsub(%r{[A-Z]\w+/\w+},
-                                                         '`\&`')
+    DEFAULT_RULES_FILE = File.join(ConfigLoader::RUBOCOP_HOME, 'config', 'obsoletion.yml')
+    COP_RULE_CLASSES = {
+      'renamed' => RenamedCop,
+      'removed' => RemovedCop,
+      'split' => SplitCop,
+      'extracted' => ExtractedCop
+    }.freeze
+    PARAMETER_RULE_CLASSES = {
+      'changed_parameters' => ChangedParameter,
+      'changed_enforced_styles' => ChangedEnforcedStyles
+    }.freeze
+
+    attr_reader :rules, :warnings
+
+    class << self
+      attr_accessor :files
+
+      def legacy_cop_names
+        # Used by DepartmentName#qualified_legacy_cop_name
+        new(Config.new).rules.select(&:cop_rule?).map(&:old_name)
       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 `Layout/LineLength: Max` instead'
-      },
-      {
-        cops: 'Style/WhileUntilModifier',
-        parameters: 'MaxLineLength',
-        alternative: '`Style/WhileUntilModifier: MaxLineLength` has been ' \
-                     'removed. Use `Layout/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`'
-      },
-      {
-        cops: 'Style/MethodCallWithArgsParentheses',
-        parameters: 'IgnoredMethodPatterns',
-        alternative: '`IgnoredMethodPatterns` has been renamed to ' \
-                     '`IgnoredPatterns`'
-      },
-      {
-        cops: %w[Performance/Count Performance/Detect],
-        parameters: 'SafeMode',
-        alternative: '`SafeMode` has been removed. ' \
-                     'Use `SafeAutoCorrect` instead.'
-      },
-      {
-        cops: 'Bundler/GemComment',
-        parameters: 'Whitelist',
-        alternative: '`Whitelist` has been renamed to `IgnoredGems`.'
-      },
-      {
-        cops: %w[
-          Lint/SafeNavigationChain Lint/SafeNavigationConsistency
-          Style/NestedParenthesizedCalls Style/SafeNavigation
-          Style/TrivialAccessors
-        ],
-        parameters: 'Whitelist',
-        alternative: '`Whitelist` has been renamed to `AllowedMethods`.'
-      },
-      {
-        cops: 'Style/IpAddresses',
-        parameters: 'Whitelist',
-        alternative: '`Whitelist` has been renamed to `AllowedAddresses`.'
-      },
-      {
-        cops: 'Naming/HeredocDelimiterNaming',
-        parameters: 'Blacklist',
-        alternative: '`Blacklist` has been renamed to `ForbiddenDelimiters`.'
-      },
-      {
-        cops: 'Naming/PredicateName',
-        parameters: 'NamePrefixBlacklist',
-        alternative: '`NamePrefixBlacklist` has been renamed to ' \
-                     '`ForbiddenPrefixes`.'
-      },
-      {
-        cops: 'Naming/PredicateName',
-        parameters: 'NameWhitelist',
-        alternative: '`NameWhitelist` has been renamed to ' \
-                     '`AllowedMethods`.'
-      }
-    ].freeze
-
-    OBSOLETE_ENFORCED_STYLES = [
-      {
-        cop: 'Layout/IndentationConsistency',
-        parameter: 'EnforcedStyle',
-        enforced_style: 'rails',
-        alternative: '`EnforcedStyle: rails` has been renamed to ' \
-                     '`EnforcedStyle: indented_internal_methods`'
-      }
-    ].freeze
+    # Can be extended by extension libraries to add their own obsoletions
+    self.files = [DEFAULT_RULES_FILE]
 
     def initialize(config)
       @config = config
+      @rules = load_rules
+      @warnings = []
     end
 
-    def reject_obsolete_cops_and_parameters
-      messages = [obsolete_cops, obsolete_parameters,
-                  obsolete_enforced_style].flatten.compact
+    def reject_obsolete!
+      messages = obsoletions.flatten.compact
       return if messages.empty?
 
       raise ValidationError, messages.join("\n")
@@ -221,56 +45,64 @@ module RuboCop
 
     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)"
+    # 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)
+          end
+        end
       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
+      cop_rules = rules.slice(*COP_RULE_CLASSES.keys)
+      parameter_rules = rules.slice(*PARAMETER_RULE_CLASSES.keys)
 
-    def obsolete_enforced_style_message(cop, param, enforced_style, alternative)
-      style = @config[cop]&.detect { |key, _| key.start_with?(param) }
+      load_cop_rules(cop_rules).concat(load_parameter_rules(parameter_rules))
+    end
 
-      return unless style && style[1] == enforced_style
+    # Cop rules are keyed by the name of the original cop
+    def load_cop_rules(rules)
+      rules.flat_map do |rule_type, data|
+        data.map do |cop_name, configuration|
+          next unless configuration # allow configurations to be disabled with `CopName: ~`
 
-      "obsolete `#{param}: #{enforced_style}` (for #{cop}) found in " \
-      "#{smart_loaded_path}\n#{alternative}"
+          COP_RULE_CLASSES[rule_type].new(@config, cop_name, configuration)
+        end.compact
+      end
     end
 
-    def obsolete_parameters
-      OBSOLETE_PARAMETERS.map do |params|
-        obsolete_parameter_message(params[:cops], params[:parameters],
-                                   params[:alternative])
+    # Parameter rules may apply to multiple cops and multiple parameters
+    # and are given as an array. Each combination is turned into a separate
+    # rule object.
+    def load_parameter_rules(rules)
+      rules.flat_map do |rule_type, data|
+        data.flat_map do |configuration|
+          cops = Array(configuration['cops'])
+          parameters = Array(configuration['parameters'])
+
+          cops.product(parameters).map do |cop, parameter|
+            PARAMETER_RULE_CLASSES[rule_type].new(@config, cop, parameter, configuration)
+          end
+        end
       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?
+    def obsoletions
+      rules.map do |rule|
+        next unless rule.violated?
 
-        obsolete_parameters.map do |parameter|
-          "obsolete parameter #{parameter} (for #{cop}) found in " \
-          "#{smart_loaded_path}\n#{alternative}"
+        if rule.warning?
+          @warnings.push(rule.message)
+          next
         end
-      end
-    end
 
-    def smart_loaded_path
-      PathUtil.smart_path(@config.loaded_path)
+        rule.message
+      end
     end
   end
 end