rubocop 0.74.0 → 0.78.0

data/lib/rubocop/config_loader.rb

@@ -46,7 +46,7 @@ module RuboCop
 
         add_missing_namespaces(path, hash)
 
-        resolver.resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
+        resolver.resolve_inheritance_from_gems(hash)
         resolver.resolve_inheritance(path, hash, file, debug?)
 
         hash.delete('inherit_from')
@@ -199,6 +199,8 @@ module RuboCop
           raise(TypeError, "Malformed configuration in #{absolute_path}")
         end
 
+        check_cop_config_value(hash)
+
         hash
       end
 
@@ -220,6 +222,22 @@ module RuboCop
         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)
+
+          abort(
+            "Property #{Rainbow(key).yellow} of cop #{Rainbow(parent).yellow}" \
+            " is supposed to be a boolean and #{Rainbow(value).yellow} is not."
+          )
+        end
+      end
+
       # Read the specified file, or exit with a friendly, concise message on
       # stderr. Care is taken to use the standard OS exit code for a "file not
       # found" error.
@@ -240,11 +258,11 @@ module RuboCop
             yaml_code,
             permitted_classes: [Regexp, Symbol],
             permitted_symbols: [],
-            aliases: false,
+            aliases: true,
             filename: filename
           )
         else
-          YAML.safe_load(yaml_code, [Regexp, Symbol], [], false, filename)
+          YAML.safe_load(yaml_code, [Regexp, Symbol], [], true, filename)
         end
       end
     end

data/lib/rubocop/config_loader_resolver.rb

@@ -35,7 +35,8 @@ module RuboCop
       end
     end
 
-    def resolve_inheritance_from_gems(hash, gems)
+    def resolve_inheritance_from_gems(hash)
+      gems = hash.delete('inherit_gem')
       (gems || {}).each_pair do |gem_name, config_path|
         if gem_name == 'rubocop'
           raise ArgumentError,
@@ -73,7 +74,7 @@ module RuboCop
 
       opts = { inherit_mode: config['inherit_mode'] || {},
                unset_nil: unset_nil }
-      Config.new(merge(default_configuration, config, opts), config_file)
+      Config.new(merge(default_configuration, config, **opts), config_file)
     end
 
     # Return a recursive merge of two hashes. That is, a normal hash merge,
@@ -92,7 +93,7 @@ module RuboCop
         elsif should_union?(base_hash, key, opts[:inherit_mode])
           result[key] = base_hash[key] | derived_hash[key]
         elsif opts[:debug]
-          warn_on_duplicate_setting(base_hash, derived_hash, key, opts)
+          warn_on_duplicate_setting(base_hash, derived_hash, key, **opts)
         end
       end
       result

data/lib/rubocop/config_obsoletion.rb

@@ -4,13 +4,39 @@ module RuboCop
   # This class handles obsolete configuration.
   class ConfigObsoletion
     RENAMED_COPS = {
-      'Style/SingleSpaceBeforeFirstArg' => 'Layout/SpaceBeforeFirstArg',
-      'Style/MethodCallParentheses' => 'Style/MethodCallWithoutArgsParentheses',
+      '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',
-      'Layout/FirstParameterIndentation' => 'Layout/IndentFirstArgument',
-      'Layout/IndentArray' => 'Layout/IndentFirstArrayElement',
-      'Layout/IndentHash' => 'Layout/IndentFirstHashElement'
+      '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
@@ -22,7 +48,7 @@ module RuboCop
                      Style/VariableName Style/VariableNumber
                      Style/AccessorMethodName Style/AsciiIdentifiers],
       'Layout' => %w[Lint/BlockAlignment Lint/EndAlignment
-                     Lint/DefEndAlignment],
+                     Lint/DefEndAlignment Metrics/LineLength],
       'Lint' => 'Style/FlipFlop'
     }.map do |new_department, old_names|
       Array(old_names).map do |old_name|
@@ -32,9 +58,10 @@ module RuboCop
     end
 
     REMOVED_COPS = {
-      'Rails/DefaultScope' => nil,
       '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, ' \
@@ -42,8 +69,7 @@ module RuboCop
                                'Style/TrailingCommaInHashLiteral',
       'Style/TrailingCommaInLiteral' => 'Style/TrailingCommaInArrayLiteral ' \
                                         'and/or ' \
-                                        'Style/TrailingCommaInHashLiteral',
-      'Lint/RescueWithoutErrorClass' => 'Style/RescueStandardError'
+                                        'Style/TrailingCommaInHashLiteral'
     }.map do |old_name, other_cops|
       if other_cops
         more = ". Please use #{other_cops} instead".gsub(%r{[A-Z]\w+/\w+},
@@ -88,13 +114,13 @@ module RuboCop
         cops: 'Style/IfUnlessModifier',
         parameters: 'MaxLineLength',
         alternative: '`Style/IfUnlessModifier: MaxLineLength` has been ' \
-                     'removed. Use `Metrics/LineLength: Max` instead'
+                     'removed. Use `Layout/LineLength: Max` instead'
       },
       {
         cops: 'Style/WhileUntilModifier',
         parameters: 'MaxLineLength',
         alternative: '`Style/WhileUntilModifier: MaxLineLength` has been ' \
-                     'removed. Use `Metrics/LineLength: Max` instead'
+                     'removed. Use `Layout/LineLength: Max` instead'
       },
       {
         cops: 'AllCops',
@@ -119,6 +145,54 @@ module RuboCop
         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
 

data/lib/rubocop/config_validator.rb

@@ -10,8 +10,9 @@ module RuboCop
 
     COMMON_PARAMS = %w[Exclude Include Severity inherit_mode
                        AutoCorrect StyleGuide Details].freeze
-    INTERNAL_PARAMS = %w[Description StyleGuide VersionAdded
-                         VersionChanged Reference Safe SafeAutoCorrect].freeze
+    INTERNAL_PARAMS = %w[Description StyleGuide
+                         VersionAdded VersionChanged VersionRemoved
+                         Reference Safe SafeAutoCorrect].freeze
 
     # 2.3 is the oldest officially supported Ruby version.
     DEFAULT_RUBY_VERSION = 2.3
@@ -32,10 +33,7 @@ module RuboCop
 
     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)
+      return if @config.internal?
 
       valid_cop_names, invalid_cop_names = @config.keys.partition do |key|
         ConfigLoader.default_configuration.key?(key)
@@ -43,7 +41,7 @@ module RuboCop
 
       @config_obsoletion.reject_obsolete_cops_and_parameters
 
-      warn_about_unrecognized_cops(invalid_cop_names)
+      alert_about_unrecognized_cops(invalid_cop_names)
       check_target_ruby
       validate_parameter_names(valid_cop_names)
       validate_enforced_styles(valid_cop_names)
@@ -98,7 +96,8 @@ module RuboCop
       raise ValidationError, msg
     end
 
-    def warn_about_unrecognized_cops(invalid_cop_names)
+    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])
@@ -108,9 +107,10 @@ module RuboCop
         # 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
+        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
@@ -128,21 +128,30 @@ module RuboCop
     def validate_parameter_names(valid_cop_names)
       valid_cop_names.each do |name|
         validate_section_presence(name)
-        default_config = ConfigLoader.default_configuration[name]
+        each_invalid_parameter(name) do |param, supported_params|
+          warn Rainbow(<<~MESSAGE).yellow
+            Warning: #{name} does not support #{param} parameter.
 
-        @config[name].each_key do |param|
-          next if COMMON_PARAMS.include?(param) || default_config.key?(param)
+            Supported parameters are:
 
-          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
+              - #{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') }

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -39,7 +39,7 @@ module RuboCop
 
       def disable_offense(node)
         range = node.location.expression
-        eol_comment = " # rubocop:disable #{cop_name}"
+        eol_comment = " # rubocop:todo #{cop_name}"
         needed_line_length = range.column +
                              (range.source_line + eol_comment).length
         if needed_line_length <= max_line_length
@@ -76,7 +76,7 @@ module RuboCop
       end
 
       def max_line_length
-        config.for_cop('Metrics/LineLength')['Max'] || 80
+        config.for_cop('Layout/LineLength')['Max'] || 80
       end
 
       def disable_offense_at_end_of_line(range, eol_comment)
@@ -90,7 +90,7 @@ module RuboCop
 
           corrector.insert_before(
             range_with_newline,
-            "#{leading_whitespace}# rubocop:disable #{cop_name}\n"
+            "#{leading_whitespace}# rubocop:todo #{cop_name}\n"
           )
           corrector.insert_after(
             range_with_newline,

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -24,7 +24,7 @@ module RuboCop
 
         def on_send(node)
           return unless gem_declaration?(node)
-          return if whitelisted_gem?(node)
+          return if ignored_gem?(node)
           return if commented?(node)
 
           add_offense(node)
@@ -54,9 +54,9 @@ module RuboCop
             comment_line?(node2.loc.expression.source)
         end
 
-        def whitelisted_gem?(node)
-          whitelist = Array(cop_config['Whitelist'])
-          whitelist.include?(node.first_argument.value)
+        def ignored_gem?(node)
+          ignored_gems = Array(cop_config['IgnoredGems'])
+          ignored_gems.include?(node.first_argument.value)
         end
       end
     end

data/lib/rubocop/cop/bundler/insecure_protocol_source.rb

@@ -13,8 +13,8 @@ module RuboCop
       #
       # However, it don't replace all `sources` of `http://` with `https://`.
       # For example, when specifying an internal gem server using HTTP on the
-      # intranet, a use case where HTTPS can not be specified was considered.
-      # Consider using HTTP only if you can not use HTTPS.
+      # intranet, a use case where HTTPS cannot be specified was considered.
+      # Consider using HTTP only if you cannot use HTTPS.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/commissioner.rb

@@ -64,17 +64,25 @@ module RuboCop
       end
 
       def remove_irrelevant_cops(filename)
-        @cops.reject! { |cop| cop.excluded_file?(filename) }
         @cops.reject! do |cop|
-          cop.class.respond_to?(:support_target_ruby_version?) &&
-            !cop.class.support_target_ruby_version?(cop.target_ruby_version)
-        end
-        @cops.reject! do |cop|
-          cop.class.respond_to?(:support_target_rails_version?) &&
-            !cop.class.support_target_rails_version?(cop.target_rails_version)
+          cop.excluded_file?(filename) ||
+            !support_target_ruby_version?(cop) ||
+            !support_target_rails_version?(cop)
         end
       end
 
+      def support_target_ruby_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_ruby_version?)
+
+        cop.class.support_target_ruby_version?(cop.target_ruby_version)
+      end
+
+      def support_target_rails_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_rails_version?)
+
+        cop.class.support_target_rails_version?(cop.target_rails_version)
+      end
+
       def reset_callbacks
         @callbacks.clear
       end

data/lib/rubocop/cop/cop.rb

@@ -123,23 +123,19 @@ module RuboCop
         self.class::MSG
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity
       def add_offense(node, location: :expression, message: nil, severity: nil)
         loc = find_location(node, location)
 
         return if duplicate_location?(loc)
 
-        severity = custom_severity || severity || default_severity
-
-        message ||= message(node)
-        message = annotate(message)
+        severity = find_severity(node, severity)
+        message = find_message(node, message)
 
         status = enabled_line?(loc.line) ? correct(node) : :disabled
 
         @offenses << Offense.new(severity, loc, message, name, status)
         yield if block_given? && status != :disabled
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       def find_location(node, loc)
         # Location can be provided as a symbol, e.g.: `:keyword`
@@ -160,10 +156,11 @@ module RuboCop
           return :uncorrected unless correction
 
           @corrections << Correction.new(correction, node, self)
+          :corrected
         elsif disable_uncorrectable?
           disable_uncorrectable(node)
+          :corrected_with_todo
         end
-        :corrected
       end
 
       def reason_to_not_correct(node)
@@ -175,6 +172,8 @@ module RuboCop
       end
 
       def disable_uncorrectable(node)
+        return unless node
+
         @disabled_lines ||= {}
         line = node.location.line
         return if @disabled_lines.key?(line)
@@ -220,12 +219,35 @@ module RuboCop
         !relevant_file?(file)
       end
 
+      # This method should be overridden when a cop's behavior depends
+      # on state that lives outside of these locations:
+      #
+      #   (1) the file under inspection
+      #   (2) the cop's source code
+      #   (3) the config (eg a .rubocop.yml file)
+      #
+      # For example, some cops may want to look at other parts of
+      # the codebase being inspected to find violations. A cop may
+      # use the presence or absence of file `foo.rb` to determine
+      # whether a certain violation exists in `bar.rb`.
+      #
+      # Overriding this method allows the cop to indicate to RuboCop's
+      # ResultCache system when those external dependencies change,
+      # ie when the ResultCache should be invalidated.
+      def external_dependency_checksum
+        nil
+      end
+
       private
 
+      def find_message(node, message)
+        annotate(message || message(node))
+      end
+
       def annotate(message)
         RuboCop::Cop::MessageAnnotator.new(
-          config, cop_config, @options
-        ).annotate(message, name)
+          config, cop_name, cop_config, @options
+        ).annotate(message)
       end
 
       def file_name_matches_any?(file, parameter, default_result)
@@ -249,6 +271,10 @@ module RuboCop
         @processed_source.comment_config.cop_enabled_at_line?(self, line_number)
       end
 
+      def find_severity(_node, severity)
+        custom_severity || severity || default_severity
+      end
+
       def default_severity
         self.class.lint? ? :warning : :convention
       end