rubocop 0.51.0 → 0.87.0

data/lib/rubocop/config_obsoletion.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This class handles obsolete configuration.
+  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/Tab' => 'Layout/IndentationStyle',
+      'Layout/TrailingBlankLines' => 'Layout/TrailingEmptyLines',
+      'Lint/DuplicatedKey' => 'Lint/DuplicateHashKey',
+      'Lint/EndInMethod' => 'Style/EndBlock',
+      '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',
+      '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+},
+                                                         '`\&`')
+      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
+
+    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_store.rb

@@ -29,14 +29,24 @@ module RuboCop
       @options_config = ConfigLoader.default_configuration
     end
 
-    def for(file_or_dir)
-      return @options_config if @options_config
+    def for_file(file)
+      for_dir(File.dirname(file))
+    end
 
+    # If type (file/dir) is known beforehand,
+    # prefer using #for_file or #for_dir for improved performance
+    def for(file_or_dir)
       dir = if File.directory?(file_or_dir)
               file_or_dir
             else
               File.dirname(file_or_dir)
             end
+      for_dir(dir)
+    end
+
+    def for_dir(dir)
+      return @options_config if @options_config
+
       @path_cache[dir] ||= ConfigLoader.configuration_file_for(dir)
       path = @path_cache[dir]
       @object_cache[path] ||= begin

data/lib/rubocop/config_validator.rb

@@ -0,0 +1,223 @@
+# 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 VersionRemoved
+                         Reference Safe SafeAutoCorrect].freeze
+    NEW_COPS_VALUES = %w[pending disable enable].freeze
+
+    def_delegators :@config, :smart_loaded_path, :for_all_cops
+
+    def initialize(config)
+      @config = config
+      @config_obsoletion = ConfigObsoletion.new(config)
+      @target_ruby = TargetRuby.new(config)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def validate
+      check_cop_config_value(@config)
+      reject_conflicting_safe_settings
+
+      # Don't validate RuboCop's own files further. Avoids infinite recursion.
+      return if @config.internal?
+
+      valid_cop_names, invalid_cop_names = @config.keys.partition do |key|
+        ConfigLoader.default_configuration.key?(key)
+      end
+
+      @config_obsoletion.reject_obsolete_cops_and_parameters
+
+      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)
+      validate_syntax_cop
+      reject_mutually_exclusive_defaults
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def target_ruby_version
+      target_ruby.version
+    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
+
+    attr_reader :target_ruby
+
+    def check_target_ruby
+      return if target_ruby.supported?
+
+      source = target_ruby.source
+      last_version = target_ruby.rubocop_version_with_support
+
+      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}."
+            else
+              'RuboCop found unknown Ruby version ' \
+              "#{target_ruby_version.inspect} in #{source}."
+            end
+
+      msg += "\nSupported versions: #{TargetRuby.supported_versions.join(', ')}"
+
+      raise ValidationError, msg
+    end
+
+    def alert_about_unrecognized_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::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'
+
+        unknown_cops << "unrecognized cop #{name} found in " \
+          "#{smart_loaded_path}"
+      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
+
+      raise ValidationError,
+            "configuration for 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)
+
+      message = "invalid #{new_cop_parameter} for `NewCops` found in" \
+                "#{smart_loaded_path}\n" \
+                "Valid choices are: #{NEW_COPS_VALUES.join(', ')}"
+
+      raise ValidationError, message
+    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.
+
+            Supported parameters are:
+
+              - #{supported_params.join("\n  - ")}
+          MESSAGE
+        end
+      end
+    end
+
+    def each_invalid_parameter(cop_name)
+      default_config = ConfigLoader.default_configuration[cop_name]
+
+      @config[cop_name].each_key do |param|
+        next if COMMON_PARAMS.include?(param) || default_config.key?(param)
+
+        supported_params = default_config.keys - INTERNAL_PARAMS
+
+        yield param, supported_params
+      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 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
+
+    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
+
+        msg = 'Unsafe cops cannot have a safe auto-correction ' \
+              "(section #{name} in #{smart_loaded_path})"
+        raise ValidationError, msg
+      end
+    end
+
+    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 %w[Enabled
+                       Safe
+                       SafeAutoCorrect
+                       AutoCorrect].include?(key) && value.is_a?(String)
+
+        next if key == 'Enabled' &&
+                %w[pending override_department].include?(value)
+
+        raise ValidationError, msg_not_boolean(parent, key, value)
+      end
+    end
+
+    # FIXME: Handling colors in exception messages like this is ugly.
+    def msg_not_boolean(parent, key, value)
+      "#{Rainbow('').reset}" \
+        "Property #{Rainbow(key).yellow} of cop #{Rainbow(parent).yellow}" \
+        " is supposed to be a boolean and #{Rainbow(value).yellow} is not."
+    end
+  end
+end

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -5,21 +5,90 @@ module RuboCop
     # This module encapsulates the logic for autocorrect behavior for a cop.
     module AutocorrectLogic
       def autocorrect?
-        autocorrect_requested? && support_autocorrect? && autocorrect_enabled?
+        autocorrect_requested? && correctable? && autocorrect_enabled?
       end
 
       def autocorrect_requested?
         @options.fetch(:auto_correct, false)
       end
 
-      def support_autocorrect?
-        respond_to?(:autocorrect, true)
+      def correctable?
+        self.class.support_autocorrect? || disable_uncorrectable?
+      end
+
+      def disable_uncorrectable?
+        @options[:disable_uncorrectable] == true
+      end
+
+      def safe_autocorrect?
+        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
-        cop_config['AutoCorrect'] != false
+
+        return false if cop_config['AutoCorrect'] == false
+
+        return safe_autocorrect? if @options.fetch(:safe_auto_correct, 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)
+        else
+          disable_offense_before_and_after(range_by_lines(range))
+        end
+      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)
+      end
+
+      # Expand the given range to include all of any lines it covers. Does not
+      # include newline at end of the last line.
+      def range_by_lines(range)
+        begin_of_first_line = range.begin_pos - range.column
+
+        last_line = range.source_buffer.source_line(range.last_line)
+        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)
+      end
+
+      def max_line_length
+        config.for_cop('Layout/LineLength')['Max'] || 80
+      end
+
+      def disable_offense_at_end_of_line(range, eol_comment)
+        Corrector.new(range).insert_after(range, eol_comment)
+      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*/]
+
+        Corrector.new(range_by_lines).wrap(
+          range_with_newline,
+          "#{leading_whitespace}# rubocop:todo #{cop_name}\n",
+          "#{leading_whitespace}# rubocop:enable #{cop_name}\n"
+        )
       end
     end
   end

data/lib/rubocop/cop/badge.rb

@@ -4,16 +4,16 @@ module RuboCop
   module Cop
     # Identifier of all cops containing a department and cop name.
     #
-    # All cops are identified by their badge. For example, the badge
-    # for `RuboCop::Cop::Layout::Tab` is `Layout/Tab`. Badges can be
-    # parsed as either `Department/CopName` or just `CopName` to allow
-    # for badge references in source files that omit the department
-    # for RuboCop to infer.
+    # All cops are identified by their badge. For example, the badge for
+    # `RuboCop::Cop::Layout::IndentationStyle` is `Layout/IndentationStyle`.
+    # Badges can be parsed as either `Department/CopName` or just `CopName` to
+    # 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`.'.freeze
+              'Expected `Department/CopName` or `CopName`.'
 
         def initialize(token)
           super(format(MSG, badge: token))