rubocop 0.75.1 → 0.80.0

data/lib/rubocop/config_validator.rb

@@ -10,32 +10,24 @@ 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
-    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.
-      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)
+      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)
@@ -43,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)
@@ -52,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)
@@ -80,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?
+
+      source = target_ruby.source
+      last_version = target_ruby.rubocop_version_with_support
 
-      msg = if OBSOLETE_RUBIES.include?(target_ruby_version)
+      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])
@@ -108,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
@@ -128,21 +110,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') }
@@ -169,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)
 
-    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
+        next unless %w[Enabled
+                       Safe
+                       SafeAutoCorrect
+                       AutoCorrect].include?(key) && value.is_a?(String)
+
+        next if key == 'Enabled' && value == 'pending'
+
+        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/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`
@@ -176,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)
@@ -221,8 +219,31 @@ 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_name, cop_config, @options
@@ -250,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

data/lib/rubocop/cop/corrector.rb

@@ -154,16 +154,17 @@ module RuboCop
 
       # :nodoc:
       def validate_range(range)
-        return if range.source_buffer == @source_buffer
+        buffer = range.source_buffer
+        return if buffer == @source_buffer
 
-        unless range.source_buffer.is_a?(Parser::Source::Buffer)
+        unless buffer.is_a?(Parser::Source::Buffer)
           # actually this should be enforced by parser gem
-          raise 'Corrector expected range source buffer to be a '\
-                "Parser::Source::Buffer, but got #{range.source_buffer.class}"
+          raise 'Corrector expected range source buffer to be a ' \
+                "Parser::Source::Buffer, but got #{buffer.class}"
         end
-        raise "Correction target buffer #{range.source_buffer.object_id} "\
-              "name:#{range.source_buffer.name.inspect}"\
-              " is not current #{@source_buffer.object_id} "\
+        raise "Correction target buffer #{buffer.object_id} " \
+              "name:#{buffer.name.inspect}" \
+              " is not current #{@source_buffer.object_id} " \
               "name:#{@source_buffer.name.inspect} under investigation"
       end
     end