rubocop 1.6.1 → 1.9.1

data/lib/rubocop/cli/command/auto_genenerate_config.rb

@@ -9,6 +9,7 @@ module RuboCop
         self.command_name = :auto_gen_config
 
         AUTO_GENERATED_FILE = '.rubocop_todo.yml'
+        YAML_OPTIONAL_DOC_START = /\A---(\s+#|\s*\z)/.freeze
 
         PHASE_1 = 'Phase 1 of 2: run Layout/LineLength cop'
         PHASE_2 = 'Phase 2 of 2: run all cops'
@@ -130,10 +131,10 @@ module RuboCop
         end
 
         def write_config_file(file_name, file_string, rubocop_yml_contents)
-          File.open(file_name, 'w') do |f|
-            f.write "inherit_from:#{file_string}\n"
-            f.write "\n#{rubocop_yml_contents}" if /\S/.match?(rubocop_yml_contents)
-          end
+          lines = /\S/.match?(rubocop_yml_contents) ? rubocop_yml_contents.split("\n", -1) : []
+          doc_start_index = lines.index { |line| YAML_OPTIONAL_DOC_START.match?(line) } || -1
+          lines.insert(doc_start_index + 1, "inherit_from:#{file_string}\n")
+          File.open(file_name, 'w') { |f| f.write lines.join("\n") }
         end
       end
     end

data/lib/rubocop/comment_config.rb

@@ -47,6 +47,12 @@ module RuboCop
       )
     end
 
+    def comment_only_line?(line_number)
+      non_comment_token_line_numbers.none? do |non_comment_line_number|
+        non_comment_line_number == line_number
+      end
+    end
+
     private
 
     def extra_enabled_comments_with_names(extras:, names:)
@@ -166,12 +172,6 @@ module RuboCop
       @all_cop_names ||= Cop::Registry.global.names - [REDUNDANT_DISABLE]
     end
 
-    def comment_only_line?(line_number)
-      non_comment_token_line_numbers.none? do |non_comment_line_number|
-        non_comment_line_number == line_number
-      end
-    end
-
     def non_comment_token_line_numbers
       @non_comment_token_line_numbers ||= begin
         non_comment_tokens = processed_source.tokens.reject(&:comment?)

data/lib/rubocop/config.rb

@@ -33,8 +33,11 @@ module RuboCop
       @validator = ConfigValidator.new(self)
     end
 
-    def self.create(hash, path)
-      new(hash, path).check
+    def self.create(hash, path, check: true)
+      config = new(hash, path)
+      config.check if check
+
+      config
     end
 
     def loaded_features
@@ -50,8 +53,8 @@ module RuboCop
       self
     end
 
-    def_delegators :@hash, :[], :[]=, :delete, :each, :key?, :keys, :each_key,
-                   :fetch, :map, :merge, :to_h, :to_hash, :transform_values
+    def_delegators :@hash, :[], :[]=, :delete, :dig, :each, :key?, :keys, :each_key,
+                   :fetch, :map, :merge, :replace, :to_h, :to_hash, :transform_values
     def_delegators :@validator, :validate, :target_ruby_version
 
     def to_s
@@ -281,6 +284,9 @@ module RuboCop
     end
 
     def enable_cop?(qualified_cop_name, cop_options)
+      # If the cop is explicitly enabled, the other checks can be skipped.
+      return true if cop_options['Enabled'] == true
+
       department = department_of(qualified_cop_name)
       cop_enabled = cop_options.fetch('Enabled') do
         !for_all_cops['DisabledByDefault']
@@ -292,10 +298,10 @@ module RuboCop
     end
 
     def department_of(qualified_cop_name)
-      cop_department, cop_name = qualified_cop_name.split('/')
-      return nil if cop_name.nil?
+      *cop_department, _ = qualified_cop_name.split('/')
+      return nil if cop_department.empty?
 
-      self[cop_department]
+      self[cop_department.join('/')]
     end
   end
 end

data/lib/rubocop/config_loader.rb

@@ -25,16 +25,18 @@ module RuboCop
       attr_accessor :debug, :ignore_parent_exclusion,
                     :disable_pending_cops, :enable_pending_cops
       attr_writer :default_configuration, :project_root
+      attr_reader :loaded_features
 
       alias debug? debug
       alias ignore_parent_exclusion? ignore_parent_exclusion
 
       def clear_options
         @debug = nil
+        @loaded_features = Set.new
         FileFinder.root_level = nil
       end
 
-      def load_file(file)
+      def load_file(file, check: true)
         path = file_path(file)
 
         hash = load_yaml_configuration(path)
@@ -51,7 +53,7 @@ module RuboCop
 
         hash.delete('inherit_from')
 
-        Config.create(hash, path)
+        Config.create(hash, path, check: check)
       end
 
       def load_yaml_configuration(absolute_path)
@@ -98,10 +100,10 @@ module RuboCop
           find_user_xdg_config || DEFAULT_FILE
       end
 
-      def configuration_from_file(config_file)
+      def configuration_from_file(config_file, check: true)
         return default_configuration if config_file == DEFAULT_FILE
 
-        config = load_file(config_file)
+        config = load_file(config_file, check: check)
         if ignore_parent_exclusion?
           print 'Ignoring AllCops/Exclude from parent folders' if debug?
         else
@@ -173,8 +175,11 @@ module RuboCop
         resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
       end
 
-      def loaded_features
-        @loaded_features.flatten.compact
+      # @api private
+      # Used to add features that were required inside a config or from
+      # the CLI using `--require`.
+      def add_loaded_features(loaded_features)
+        @loaded_features.merge(Array(loaded_features))
       end
 
       private
@@ -183,14 +188,6 @@ module RuboCop
         File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
       end
 
-      def add_loaded_features(loaded_features)
-        if instance_variable_defined?(:@loaded_features)
-          instance_variable_get(:@loaded_features) << loaded_features
-        else
-          instance_variable_set(:@loaded_features, [loaded_features])
-        end
-      end
-
       def find_project_dotfile(target_dir)
         find_file_upwards(DOTFILE, target_dir, project_root)
       end

data/lib/rubocop/config_loader_resolver.rb

@@ -20,12 +20,13 @@ module RuboCop
       end
     end
 
-    # rubocop:disable Metrics/MethodLength
-    def resolve_inheritance(path, hash, file, debug)
+    def resolve_inheritance(path, hash, file, debug) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       inherited_files = Array(hash['inherit_from'])
       base_configs(path, inherited_files, file)
         .reverse.each_with_index do |base_config, index|
         override_department_setting_for_cops(base_config, hash)
+        override_enabled_for_disabled_departments(base_config, hash)
+
         base_config.each do |k, v|
           next unless v.is_a?(Hash)
 
@@ -39,7 +40,6 @@ module RuboCop
         end
       end
     end
-    # rubocop:enable Metrics/MethodLength
 
     def resolve_inheritance_from_gems(hash)
       gems = hash.delete('inherit_gem')
@@ -75,6 +75,7 @@ module RuboCop
       end
 
       config = handle_disabled_by_default(config, default_configuration) if disabled_by_default
+      override_enabled_for_disabled_departments(default_configuration, config)
 
       opts = { inherit_mode: config['inherit_mode'] || {},
                unset_nil: unset_nil }
@@ -122,10 +123,26 @@ module RuboCop
       end
     end
 
+    # If a cop was previously explicitly enabled, but then superseded by the
+    # department being disabled, disable it.
+    def override_enabled_for_disabled_departments(base_hash, derived_hash)
+      cops_to_disable = derived_hash.each_key.with_object([]) do |key, cops|
+        next unless disabled?(derived_hash, key)
+
+        cops.concat(base_hash.keys.grep(Regexp.new("^#{key}/")))
+      end
+
+      cops_to_disable.each do |cop_name|
+        next unless base_hash.dig(cop_name, 'Enabled') == true
+
+        derived_hash.replace(merge({ cop_name => { 'Enabled' => false } }, derived_hash))
+      end
+    end
+
     private
 
     def disabled?(hash, department)
-      hash[department] && hash[department]['Enabled'] == false
+      hash[department].is_a?(Hash) && hash[department]['Enabled'] == false
     end
 
     def duplicate_setting?(base_hash, derived_hash, key, inherited_file)

data/lib/rubocop/config_obsoletion.rb

@@ -63,9 +63,11 @@ module RuboCop
     # 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 |configuration|
-          COP_RULE_CLASSES[rule_type].new(@config, *configuration)
-        end
+        data.map do |cop_name, configuration|
+          next unless configuration # allow configurations to be disabled with `CopName: ~`
+
+          COP_RULE_CLASSES[rule_type].new(@config, cop_name, configuration)
+        end.compact
       end
     end
 

data/lib/rubocop/config_store.rb

@@ -4,6 +4,9 @@ module RuboCop
   # Handles caching of configurations and association of inspected
   # ruby files to configurations.
   class ConfigStore
+    attr_reader :validated
+    alias validated? validated
+
     def initialize
       # @options_config stores a config that is specified in the command line.
       # This takes precedence over configs located in any directories
@@ -17,6 +20,9 @@ module RuboCop
       # @object_cache maps configuration file paths to
       # configuration objects so we only need to load them once.
       @object_cache = {}
+
+      # By default the config is validated before it can be used.
+      @validated = true
     end
 
     def options_config=(options_config)
@@ -29,6 +35,11 @@ module RuboCop
       @options_config = ConfigLoader.default_configuration
     end
 
+    def unvalidated
+      @validated = false
+      self
+    end
+
     def for_file(file)
       for_dir(File.dirname(file))
     end
@@ -55,7 +66,7 @@ module RuboCop
       path = @path_cache[dir]
       @object_cache[path] ||= begin
         print "For #{dir}: " if ConfigLoader.debug?
-        ConfigLoader.configuration_from_file(path)
+        ConfigLoader.configuration_from_file(path, check: validated?)
       end
     end
   end

data/lib/rubocop/cop/base.rb

@@ -34,6 +34,7 @@ module RuboCop
     class Base # rubocop:disable Metrics/ClassLength
       extend RuboCop::AST::Sexp
       extend NodePattern::Macros
+      extend ExcludeLimit
       include RuboCop::AST::Sexp
       include Util
       include IgnoredNode
@@ -351,7 +352,7 @@ module RuboCop
       def use_corrector(range, corrector)
         if autocorrect?
           attempt_correction(range, corrector)
-        elsif corrector
+        elsif corrector && cop_config.fetch('AutoCorrect', true)
           :uncorrected
         else
           :unsupported

data/lib/rubocop/cop/exclude_limit.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Allows specified configuration options to have an exclude limit
+  # ie. a maximum value tracked that it can be used by `--auto-gen-config`.
+  module ExcludeLimit
+    # Sets up a configuration option to have an exclude limit tracked.
+    # The parameter name given is transformed into a method name (eg. `Max`
+    # becomes `self.max=` and `MinDigits` becomes `self.min_digits=`).
+    def exclude_limit(parameter_name, method_name: transform(parameter_name))
+      define_method("#{method_name}=") do |value|
+        cfg = config_to_allow_offenses
+        cfg[:exclude_limit] ||= {}
+        current_max = cfg[:exclude_limit][parameter_name]
+        value = [current_max, value].max if current_max
+        cfg[:exclude_limit][parameter_name] = value
+      end
+    end
+
+    private
+
+    def transform(parameter_name)
+      parameter_name.gsub(/(?<!\A)(?=[A-Z])/, '_').downcase
+    end
+  end
+end

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

@@ -36,12 +36,13 @@ module RuboCop
       #     spec.required_ruby_version = '>= 2.5'
       #   end
       #
-      #   # good
+      #   # accepted but not recommended
       #   Gem::Specification.new do |spec|
       #     spec.required_ruby_version = ['>= 2.5.0', '< 2.7.0']
       #   end
       #
-      #   # good
+      #   # accepted but not recommended, since
+      #   # Ruby does not really follow semantic versionning
       #   Gem::Specification.new do |spec|
       #     spec.required_ruby_version = '~> 2.5'
       #   end

data/lib/rubocop/cop/generator.rb

@@ -81,9 +81,7 @@ module RuboCop
       SPEC_TEMPLATE = <<~SPEC
         # frozen_string_literal: true
 
-        RSpec.describe RuboCop::Cop::%<department>s::%<cop_name>s do
-          subject(:cop) { described_class.new(config) }
-
+        RSpec.describe RuboCop::Cop::%<department>s::%<cop_name>s, :config do
           let(:config) { RuboCop::Config.new }
 
           # TODO: Write test code

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
+require_relative 'internal_affairs/empty_line_between_expect_offense_and_correction'
+require_relative 'internal_affairs/example_description'
 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'
-require_relative 'internal_affairs/redundant_message_argument'
+require_relative 'internal_affairs/redundant_described_class_as_subject'
+require_relative 'internal_affairs/redundant_let_rubocop_config_new'
 require_relative 'internal_affairs/redundant_location_argument'
+require_relative 'internal_affairs/redundant_message_argument'
+require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/useless_message_assertion'

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # This cop checks whether `expect_offense` and correction expectation methods
+      # (i.e. `expect_correction` and `expect_no_corrections`) are separated by empty line.
+      #
+      # @example
+      #   # bad
+      #   it 'registers and corrects an offense' do
+      #     expect_offense(<<~RUBY)
+      #       bad_method
+      #       ^^^^^^^^^^ Use `good_method`.
+      #     RUBY
+      #     expect_correction(<<~RUBY)
+      #       good_method
+      #     RUBY
+      #   end
+      #
+      #   # good
+      #   it 'registers and corrects an offense' do
+      #     expect_offense(<<~RUBY)
+      #       bad_method
+      #       ^^^^^^^^^^ Use `good_method`.
+      #     RUBY
+      #
+      #     expect_correction(<<~RUBY)
+      #       good_method
+      #     RUBY
+      #   end
+      #
+      class EmptyLineBetweenExpectOffenseAndCorrection < Base
+        extend AutoCorrector
+
+        MSG = 'Add empty line between `expect_offense` and `%<expect_correction>s`.'
+        RESTRICT_ON_SEND = %i[expect_offense].freeze
+        CORRECTION_EXPECTATION_METHODS = %i[expect_correction expect_no_corrections].freeze
+
+        def on_send(node)
+          return unless (next_sibling = node.right_sibling) && next_sibling.send_type?
+
+          method_name = next_sibling.method_name
+          return unless CORRECTION_EXPECTATION_METHODS.include?(method_name)
+
+          range = offense_range(node)
+          return unless range.last_line + 1 == next_sibling.loc.line
+
+          add_offense(range, message: format(MSG, expect_correction: method_name)) do |corrector|
+            corrector.insert_after(range, "\n")
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          first_argument = node.first_argument
+
+          if first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
+            first_argument.loc.heredoc_end
+          else
+            node
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that RSpec examples that use `expects_offense`
+      # or `expects_no_offenses` do not have conflicting
+      # descriptions.
+      #
+      # @example
+      #   # bad
+      #   it 'does not register an offense' do
+      #     expect_offense('...')
+      #   end
+      #
+      #   it 'registers an offense' do
+      #     expect_no_offenses('...')
+      #   end
+      #
+      #   # good
+      #   it 'registers an offense' do
+      #     expect_offense('...')
+      #   end
+      #
+      #   it 'does not register an offense' do
+      #     expect_no_offenses('...')
+      #   end
+      class ExampleDescription < Base
+        class << self
+          attr_accessor :descriptions
+        end
+
+        MSG = 'Description does not match use of `%<method_name>s`.'
+
+        RESTRICT_ON_SEND = %i[
+          expect_offense
+          expect_no_offenses
+          expect_correction
+          expect_no_corrections
+        ].to_set.freeze
+
+        EXPECT_NO_OFFENSES_INCORRECT_DESCRIPTIONS = [
+          /^(adds|registers|reports|finds) (an? )?offense/,
+          /^flags\b/
+        ].freeze
+
+        EXPECT_OFFENSE_INCORRECT_DESCRIPTIONS = [
+          /^(does not|doesn't) (register|find|flag|report)/,
+          /^(does not|doesn't) add (a|an|any )?offense/
+        ].freeze
+
+        EXPECT_NO_CORRECTIONS_INCORRECT_DESCRIPTIONS = [
+          /^(auto[- ]?)?correct/
+        ].freeze
+
+        EXPECT_CORRECTION_INCORRECT_DESCRIPTIONS = [
+          /\b(does not|doesn't) (auto[- ]?)?correct/
+        ].freeze
+
+        def_node_matcher :offense_example?, <<~PATTERN
+          (block
+            (send _ {:it :specify} $_description)
+            _args
+            `(send nil? %RESTRICT_ON_SEND ...)
+          )
+        PATTERN
+
+        def on_send(node)
+          parent = node.each_ancestor(:block).first
+          return unless parent && (description = offense_example?(parent))
+
+          method_name = node.method_name
+          message = format(MSG, method_name: method_name)
+
+          regexp_group = self.class.const_get("#{method_name}_incorrect_descriptions".upcase)
+          check_description(description, regexp_group, message)
+        end
+
+        private
+
+        def check_description(description, regexps, message)
+          return unless regexps.any? { |regexp| regexp.match?(description.value) }
+
+          add_offense(description, message: message)
+        end
+      end
+    end
+  end
+end