rubocop 1.7.0 → 1.10.0

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

data/lib/rubocop/config_loader.rb

@@ -25,17 +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 = []
+        @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)
@@ -52,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)
@@ -99,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
@@ -174,19 +175,11 @@ module RuboCop
         resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
       end
 
-      def loaded_features
-        @loaded_features.flatten.compact
-      end
-
       # @api private
       # Used to add features that were required inside a config or from
       # the CLI using `--require`.
       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
+        @loaded_features.merge(Array(loaded_features))
       end
 
       private

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # This cop checks that `date =` is not used in gemspec file.
+      # It is set automatically when the gem is packaged.
+      #
+      # @example
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     s.name = 'your_cool_gem_name'
+      #     spec.date = Time.now.strftime('%Y-%m-%d')
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     s.name = 'your_cool_gem_name'
+      #   end
+      #
+      class DateAssignment < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Do not use `date =` in gemspec, it is set automatically when the gem is packaged.'
+
+        def_node_matcher :gem_specification, <<~PATTERN
+          (block
+            (send
+              (const
+                (const {cbase nil?} :Gem) :Specification) :new)
+            ...)
+        PATTERN
+
+        def on_block(block_node)
+          return unless gem_specification(block_node)
+
+          block_parameter = block_node.arguments.first.source
+
+          date_assignment = block_node.descendants.detect do |node|
+            node.send_type? && node.receiver&.source == block_parameter && node.method?(:date=)
+          end
+
+          return unless date_assignment
+
+          add_offense(date_assignment) do |corrector|
+            range = range_by_whole_lines(date_assignment.source_range, include_final_newline: true)
+
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+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,10 +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