rubocop 0.76.0 → 0.80.1

data/lib/rubocop/config_validator.rb

@@ -14,25 +14,19 @@ module RuboCop
                          VersionAdded VersionChanged VersionRemoved
                          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_delegators :@config, :smart_loaded_path, :for_all_cops
 
     def initialize(config)
       @config = config
       @config_obsoletion = ConfigObsoletion.new(config)
+      @target_ruby = TargetRuby.new(config)
     end
 
     def validate
-      # Don't validate RuboCop's own files. Avoids infinite recursion.
+      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|
@@ -41,7 +35,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)
@@ -50,23 +44,7 @@ module RuboCop
     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
+      target_ruby.version
     end
 
     def validate_section_presence(name)
@@ -78,25 +56,30 @@ module RuboCop
 
     private
 
+    attr_reader :target_ruby
+
     def check_target_ruby
-      return if KNOWN_RUBIES.include?(target_ruby_version)
+      return if target_ruby.supported?
 
-      msg = if OBSOLETE_RUBIES.include?(target_ruby_version)
+      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 #{target_ruby_source}. #{target_ruby_version}-compatible " \
-              'analysis was dropped after version ' \
-              "#{OBSOLETE_RUBIES[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 #{target_ruby_source}."
+              "#{target_ruby_version.inspect} in #{source}."
             end
 
-      msg += "\nSupported versions: #{KNOWN_RUBIES.join(', ')}"
+      msg += "\nSupported versions: #{TargetRuby.supported_versions.join(', ')}"
 
       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])
@@ -106,9 +89,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
@@ -127,9 +111,7 @@ module RuboCop
       valid_cop_names.each do |name|
         validate_section_presence(name)
         each_invalid_parameter(name) do |param, supported_params|
-          # FIXME: Remove .to_s, which works around a JRuby bug:
-          #   https://github.com/jruby/jruby/issues/5935
-          warn Rainbow(<<~MESSAGE).yellow.to_s
+          warn Rainbow(<<~MESSAGE).yellow
             Warning: #{name} does not support #{param} parameter.
 
             Supported parameters are:
@@ -178,71 +160,47 @@ module RuboCop
         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 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
 
-    def ruby_version_file
-      @ruby_version_file ||=
-        find_file_upwards(RUBY_VERSION_FILENAME, base_dir_for_path_parameters)
+      msg = 'Cops cannot be both enabled by default and disabled by default'
+      raise ValidationError, msg
     end
 
-    def target_ruby_version_from_version_file
-      file = ruby_version_file
-      return unless file && File.file?(file)
+    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
 
-      @target_ruby_version_from_version_file ||=
-        File.read(file).match(/\A(ruby-)?(?<version>\d+\.\d+)/) do |md|
-          md[:version].to_f
-        end
+        msg = 'Unsafe cops cannot have a safe auto-correction ' \
+              "(section #{name} in #{smart_loaded_path})"
+        raise ValidationError, msg
+      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 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' && value == 'pending'
 
-    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
+        raise ValidationError, msg_not_boolean(parent, key, value)
       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
+    # 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

@@ -24,15 +24,18 @@ module RuboCop
         @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
 
         return false if cop_config['AutoCorrect'] == false
 
-        if @options.fetch(:safe_auto_correct, false)
-          return cop_config.fetch('SafeAutoCorrect', true)
-        end
+        return safe_autocorrect? if @options.fetch(:safe_auto_correct, false)
 
         true
       end
@@ -76,7 +79,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)

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/cop.rb

@@ -172,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)
@@ -217,6 +219,25 @@ 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)

data/lib/rubocop/cop/correctors/space_corrector.rb

@@ -12,12 +12,11 @@ module RuboCop
         def empty_corrections(processed_source, corrector, empty_config,
                               left_token, right_token)
           @processed_source = processed_source
+          range = range_between(left_token.end_pos, right_token.begin_pos)
           if offending_empty_space?(empty_config, left_token, right_token)
-            range = side_space_range(range: left_token.pos, side: :right)
             corrector.remove(range)
             corrector.insert_after(left_token.pos, ' ')
           elsif offending_empty_no_space?(empty_config, left_token, right_token)
-            range = side_space_range(range: left_token.pos, side: :right)
             corrector.remove(range)
           end
         end

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -98,7 +98,7 @@ module RuboCop
         end
 
         def_node_search :dependency_declarations, <<~PATTERN
-          (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} ...)
+          (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} (str _) ...)
         PATTERN
       end
     end

data/lib/rubocop/cop/generator.rb

@@ -104,10 +104,9 @@ module RuboCop
         end
       SPEC
 
-      CONFIGURATION_ADDED_MESSAGE = <<~MESSAGE
-        [modify] A configuration for the cop is added into %<configuration_file_path>s.
-                 If you want to disable the cop by default, set `Enabled` option to false.
-      MESSAGE
+      CONFIGURATION_ADDED_MESSAGE =
+        '[modify] A configuration for the cop is added into ' \
+          '%<configuration_file_path>s.'
 
       def initialize(name, github_user, output: $stdout)
         @badge = Badge.parse(name)

data/lib/rubocop/cop/generator/configuration_injector.rb

@@ -10,7 +10,7 @@ module RuboCop
         TEMPLATE = <<~YAML
           %<badge>s:
             Description: 'TODO: Write a description of the cop.'
-            Enabled: true
+            Enabled: pending
             VersionAdded: '%<version_added>s'
         YAML
 

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'internal_affairs/method_name_equal'
 require_relative 'internal_affairs/node_destructuring'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/offense_location_keyword'

data/lib/rubocop/cop/internal_affairs/method_name_equal.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that method names are checked using `method?` method.
+      #
+      # @example
+      #   # bad
+      #   node.method_name == :do_something
+      #
+      #   # good
+      #   node.method?(:do_something)
+      #
+      class MethodNameEqual < Cop
+        include RangeHelp
+
+        MSG = 'Use `method?(%<method_name>s)` instead of ' \
+              '`method_name == %<method_name>s`.'
+
+        def_node_matcher :method_name?, <<~PATTERN
+          (send
+            $(send
+              (...) :method_name) :==
+            $...)
+        PATTERN
+
+        def on_send(node)
+          method_name?(node) do |method_name_node, method_name_arg|
+            message = format(MSG, method_name: method_name_arg.first.source)
+
+            range = range(method_name_node, node)
+
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_name?(node) do |method_name_node, method_name_arg|
+              corrector.replace(
+                range(method_name_node, node),
+                "method?(#{method_name_arg.first.source})"
+              )
+            end
+          end
+        end
+
+        private
+
+        def range(method_name_node, node)
+          range_between(
+            method_name_node.loc.selector.begin_pos, node.source_range.end_pos
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/{align_arguments.rb → argument_alignment.rb}

@@ -37,7 +37,7 @@ module RuboCop
       #
       #   foo :bar,
       #       :baz
-      class AlignArguments < Cop
+      class ArgumentAlignment < Cop
         include Alignment
 
         ALIGN_PARAMS_MSG = 'Align the arguments of a method call if ' \