rubocop 1.39.0 → 1.44.1

data/lib/rubocop/cop/util.rb

@@ -52,6 +52,21 @@ module RuboCop
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
+      def any_descendant?(node, *types)
+        if block_given?
+          node.each_descendant(*types) do |descendant|
+            return true if yield(descendant)
+          end
+        else
+          # Use a block version to avoid allocating enumerators.
+          node.each_descendant do # rubocop:disable Lint/UnreachableLoop
+            return true
+          end
+        end
+
+        false
+      end
+
       def args_begin(node)
         loc = node.loc
         selector = if node.super_type? || node.yield_type?
@@ -71,14 +86,19 @@ module RuboCop
       def on_node(syms, sexp, excludes = [], &block)
         return to_enum(:on_node, syms, sexp, excludes) unless block
 
-        yield sexp if Array(syms).include?(sexp.type)
-        return if Array(excludes).include?(sexp.type)
+        yield sexp if include_or_equal?(syms, sexp.type)
+        return if include_or_equal?(excludes, sexp.type)
 
         sexp.each_child_node { |elem| on_node(syms, elem, excludes, &block) }
       end
 
+      LINE_BEGINS_REGEX_CACHE = Hash.new do |hash, index|
+        hash[index] = /^\s{#{index}}\S/
+      end
+      private_constant :LINE_BEGINS_REGEX_CACHE
+
       def begins_its_line?(range)
-        range.source_line.index(/\S/) == range.column
+        range.source_line.match?(LINE_BEGINS_REGEX_CACHE[range.column])
       end
 
       # Returns, for example, a bare `if` node if the given node is an `if`
@@ -152,16 +172,23 @@ module RuboCop
         ' ' * (node.loc.column + offset)
       end
 
+      @to_supported_styles_cache = {}
+
       def to_supported_styles(enforced_style)
-        enforced_style.sub(/^Enforced/, 'Supported').sub('Style', 'Styles')
+        @to_supported_styles_cache[enforced_style] ||=
+          enforced_style.sub(/^Enforced/, 'Supported').sub('Style', 'Styles')
       end
 
       private
 
       def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_VERSION < '2.3' || RUBY_ENGINE == 'jruby'
+        src = src.dup if RUBY_ENGINE == 'jruby'
         src.force_encoding(Encoding.default_external).valid_encoding?
       end
+
+      def include_or_equal?(source, target)
+        source == target || (source.is_a?(Array) && source.include?(target))
+      end
     end
   end
 end

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -83,7 +83,7 @@ module RuboCop
         end
 
         def multiple_assignment_node
-          grandparent_node = node.parent ? node.parent.parent : nil
+          grandparent_node = node.parent&.parent
           return nil unless grandparent_node
           return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
           return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE

data/lib/rubocop/cop/variable_force/variable_table.rb

@@ -97,8 +97,10 @@ module RuboCop
           scope_stack.reverse_each do |scope|
             variable = scope.variables[name]
             return variable if variable
+
             # Only block scope allows referencing outer scope variables.
-            return nil unless scope.node.block_type?
+            node = scope.node
+            return nil unless node.block_type? || node.numblock_type?
           end
 
           nil

data/lib/rubocop/cop/variable_force.rb

@@ -50,7 +50,7 @@ module RuboCop
 
       ZERO_ARITY_SUPER_TYPE = :zsuper
 
-      TWISTED_SCOPE_TYPES = %i[block class sclass defs module].freeze
+      TWISTED_SCOPE_TYPES = %i[block numblock class sclass defs module].freeze
       SCOPE_TYPES = (TWISTED_SCOPE_TYPES + [:def]).freeze
 
       SEND_TYPE = :send
@@ -108,34 +108,23 @@ module RuboCop
         :skip_children
       end
 
-      # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      NODE_HANDLER_METHOD_NAMES = [
+        [VARIABLE_ASSIGNMENT_TYPE, :process_variable_assignment],
+        [REGEXP_NAMED_CAPTURE_TYPE, :process_regexp_named_captures],
+        [MULTIPLE_ASSIGNMENT_TYPE, :process_variable_multiple_assignment],
+        [VARIABLE_REFERENCE_TYPE, :process_variable_referencing],
+        [RESCUE_TYPE, :process_rescue],
+        [ZERO_ARITY_SUPER_TYPE, :process_zero_arity_super],
+        [SEND_TYPE, :process_send],
+        *ARGUMENT_DECLARATION_TYPES.product([:process_variable_declaration]),
+        *OPERATOR_ASSIGNMENT_TYPES.product([:process_variable_operator_assignment]),
+        *LOOP_TYPES.product([:process_loop]),
+        *SCOPE_TYPES.product([:process_scope])
+      ].to_h.freeze
+      private_constant :NODE_HANDLER_METHOD_NAMES
       def node_handler_method_name(node)
-        case node.type
-        when VARIABLE_ASSIGNMENT_TYPE
-          :process_variable_assignment
-        when REGEXP_NAMED_CAPTURE_TYPE
-          :process_regexp_named_captures
-        when MULTIPLE_ASSIGNMENT_TYPE
-          :process_variable_multiple_assignment
-        when VARIABLE_REFERENCE_TYPE
-          :process_variable_referencing
-        when RESCUE_TYPE
-          :process_rescue
-        when ZERO_ARITY_SUPER_TYPE
-          :process_zero_arity_super
-        when SEND_TYPE
-          :process_send
-        when *ARGUMENT_DECLARATION_TYPES
-          :process_variable_declaration
-        when *OPERATOR_ASSIGNMENT_TYPES
-          :process_variable_operator_assignment
-        when *LOOP_TYPES
-          :process_loop
-        when *SCOPE_TYPES
-          :process_scope
-        end
+        NODE_HANDLER_METHOD_NAMES[node.type]
       end
-      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
       def process_variable_declaration(node)
         variable_name = node.children.first
@@ -358,13 +347,12 @@ module RuboCop
         end
       end
 
-      # Use Node#equal? for accurate check.
       def scanned_node?(node)
-        scanned_nodes.any? { |scanned_node| scanned_node.equal?(node) }
+        scanned_nodes.include?(node)
       end
 
       def scanned_nodes
-        @scanned_nodes ||= []
+        @scanned_nodes ||= Set.new.compare_by_identity
       end
 
       # Hooks invoked by VariableTable.

data/lib/rubocop/cops_documentation_generator.rb

@@ -33,7 +33,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     cops.with_department(department).sort!
   end
 
-  def cops_body(cop, description, examples_objects, safety_objects, pars) # rubocop:disable Metrics/AbcSize
+  def cops_body(cop, description, examples_objects, safety_objects, see_objects, pars) # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
     check_examples_to_have_the_default_enforced_style!(examples_objects, cop)
 
     content = h2(cop.cop_name)
@@ -42,8 +42,8 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     content << "#{description}\n"
     content << safety_object(safety_objects) if safety_objects.any? { |s| !s.text.blank? }
     content << examples(examples_objects) if examples_objects.any?
-    content << configurations(pars)
-    content << references(cop)
+    content << configurations(cop.department, pars)
+    content << references(cop, see_objects)
     content
   end
 
@@ -136,7 +136,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     content
   end
 
-  def configurations(pars)
+  def configurations(department, pars)
     return '' if pars.empty?
 
     header = ['Name', 'Default value', 'Configurable values']
@@ -147,12 +147,20 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     content = configs.map do |name|
       configurable = configurable_values(pars, name)
       default = format_table_value(pars[name])
-      [name, default, configurable]
+
+      [configuration_name(department, name), default, configurable]
     end
 
     h3('Configurable attributes') + to_table(header, content)
   end
 
+  def configuration_name(department, name)
+    return name unless name == 'AllowMultilineFinalElement'
+
+    filename = "#{department_to_basename(department)}.adoc"
+    "xref:#{filename}#allowmultilinefinalelement[AllowMultilineFinalElement]"
+  end
+
   # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
   def configurable_values(pars, name)
     case name
@@ -216,21 +224,34 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     end
   end
 
-  def references(cop)
+  def references(cop, see_objects) # rubocop:disable Metrics/AbcSize
     cop_config = config.for_cop(cop)
     urls = RuboCop::Cop::MessageAnnotator.new(config, cop.name, cop_config, {}).urls
-    return '' if urls.empty?
+    return '' if urls.empty? && see_objects.empty?
 
     content = h3('References')
     content << urls.map { |url| "* #{url}" }.join("\n")
-    content << "\n"
+    content << "\n" unless urls.empty?
+    content << see_objects.map { |see| "* #{see.name}" }.join("\n")
+    content << "\n" unless see_objects.empty?
     content
   end
 
+  def footer_for_department(department)
+    return '' unless department == :Layout
+
+    filename = "#{department_to_basename(department)}_footer.adoc"
+    file = "#{Dir.pwd}/docs/modules/ROOT/partials/#{filename}"
+    return '' unless File.exist?(file)
+
+    "\ninclude::../partials/#{filename}[]\n"
+  end
+
   def print_cops_of_department(department)
     selected_cops = cops_of_department(department)
     content = +"= #{department}\n"
     selected_cops.each { |cop| content << print_cop_with_doc(cop) }
+    content << footer_for_department(department)
     file_name = "#{Dir.pwd}/docs/modules/ROOT/pages/#{department_to_basename(department)}.adoc"
     File.open(file_name, 'w') do |file|
       puts "* generated #{file_name}"
@@ -238,7 +259,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     end
   end
 
-  def print_cop_with_doc(cop)
+  def print_cop_with_doc(cop) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
     cop_config = config.for_cop(cop)
     non_display_keys = %w[
       Description Enabled StyleGuide Reference Safe SafeAutoCorrect VersionAdded
@@ -246,13 +267,14 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     ]
     pars = cop_config.reject { |k| non_display_keys.include? k }
     description = 'No documentation'
-    examples_object = safety_object = []
+    examples_object = safety_object = see_object = []
     cop_code(cop) do |code_object|
       description = code_object.docstring unless code_object.docstring.blank?
       examples_object = code_object.tags('example')
       safety_object = code_object.tags('safety')
+      see_object = code_object.tags('see')
     end
-    cops_body(cop, description, examples_object, safety_object, pars)
+    cops_body(cop, description, examples_object, safety_object, see_object, pars)
   end
 
   def cop_code(cop)

data/lib/rubocop/directive_comment.rb

@@ -35,7 +35,7 @@ module RuboCop
 
     # Checks if this directive relates to single line
     def single_line?
-      !self.class.before_comment(comment.text).empty?
+      !comment.text.start_with?(DIRECTIVE_COMMENT_REGEXP)
     end
 
     # Checks if this directive contains all the given cop names

data/lib/rubocop/file_patterns.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # A wrapper around patterns array to perform optimized search.
+  #
+  # For projects with a large set of rubocop todo files, most items in `Exclude`/`Include`
+  # are exact file names. It is wasteful to linearly check the list of patterns over and over
+  # to check if the file is relevant to the cop.
+  #
+  # This class partitions an array of patterns into a set of exact match strings and the rest
+  # of the patterns. This way we can firstly do a cheap check in the set and then proceed via
+  # the costly patterns check, if needed.
+  # @api private
+  class FilePatterns
+    @cache = {}.compare_by_identity
+
+    def self.from(patterns)
+      @cache[patterns] ||= new(patterns)
+    end
+
+    def initialize(patterns)
+      @strings = Set.new
+      @patterns = []
+      partition_patterns(patterns)
+    end
+
+    def match?(path)
+      @strings.include?(path) || @patterns.any? { |pattern| PathUtil.match_path?(pattern, path) }
+    end
+
+    private
+
+    def partition_patterns(patterns)
+      patterns.each do |pattern|
+        if pattern.is_a?(String) && !pattern.match?(/[*{\[?]/)
+          @strings << pattern
+        else
+          @patterns << pattern
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -65,6 +65,10 @@ module RuboCop
         @options.fetch(:offense_counts, true)
       end
 
+      def auto_gen_enforced_style?
+        @options.fetch(:auto_gen_enforced_style, true)
+      end
+
       def command
         command = 'rubocop --auto-gen-config'
 
@@ -79,6 +83,8 @@ module RuboCop
 
         command += ' --no-auto-gen-timestamp' unless show_timestamp?
 
+        command += ' --no-auto-gen-enforced-style' unless auto_gen_enforced_style?
+
         command
       end
 
@@ -172,17 +178,22 @@ module RuboCop
       end
 
       def output_cop_config(output_buffer, cfg, cop_name)
-        # 'Enabled' option will be put into file only if exclude
-        # limit is exceeded.
-        cfg_without_enabled = cfg.reject { |key| key == 'Enabled' }
-
+        filtered_cfg = filtered_config(cfg)
         output_buffer.puts "#{cop_name}:"
-        cfg_without_enabled.each do |key, value|
+        filtered_cfg.each do |key, value|
           value = value[0] if value.is_a?(Array)
           output_buffer.puts "  #{key}: #{value}"
         end
 
-        output_offending_files(output_buffer, cfg_without_enabled, cop_name)
+        output_offending_files(output_buffer, filtered_cfg, cop_name)
+      end
+
+      def filtered_config(cfg)
+        # 'Enabled' option will be put into file only if exclude
+        # limit is exceeded.
+        rejected_keys = ['Enabled']
+        rejected_keys << 'EnforcedStyle' unless auto_gen_enforced_style?
+        cfg.reject { |key| rejected_keys.include?(key) }
       end
 
       def output_offending_files(output_buffer, cfg, cop_name)

data/lib/rubocop/formatter/html_formatter.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
+require 'base64'
 require 'cgi'
 require 'erb'
 require 'ostruct'
-require 'base64'
 
 module RuboCop
   module Formatter

data/lib/rubocop/formatter.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 module RuboCop
+  # The bootstrap module for formatter.
   module Formatter
     require_relative 'formatter/text_util'
 
     require_relative 'formatter/base_formatter'
     require_relative 'formatter/simple_text_formatter'
+
     # relies on simple text
     require_relative 'formatter/clang_style_formatter'
     require_relative 'formatter/disabled_config_formatter'
@@ -18,11 +20,12 @@ module RuboCop
     require_relative 'formatter/junit_formatter'
     require_relative 'formatter/markdown_formatter'
     require_relative 'formatter/offense_count_formatter'
+    require_relative 'formatter/pacman_formatter'
     require_relative 'formatter/progress_formatter'
     require_relative 'formatter/quiet_formatter'
     require_relative 'formatter/tap_formatter'
     require_relative 'formatter/worst_offenders_formatter'
-    require_relative 'formatter/pacman_formatter'
+
     # relies on progress formatter
     require_relative 'formatter/auto_gen_config_formatter'
 

data/lib/rubocop/options.rb

@@ -167,6 +167,7 @@ module RuboCop
         option(opts, '--[no-]offense-counts')
         option(opts, '--[no-]auto-gen-only-exclude')
         option(opts, '--[no-]auto-gen-timestamp')
+        option(opts, '--[no-]auto-gen-enforced-style')
       end
     end
 
@@ -486,6 +487,13 @@ module RuboCop
       auto_gen_timestamp:
                                         ['Include the date and time when the --auto-gen-config',
                                          'was run in the file it generates. Default is true.'],
+      auto_gen_enforced_style:
+                                        ['Add a setting to the TODO configuration file to enforce',
+                                         'the style used, rather than a per-file exclusion',
+                                         'if one style is used in all files for cop with',
+                                         'EnforcedStyle as a configurable option',
+                                         'when the --auto-gen-config was run',
+                                         'in the file it generates. Default is true.'],
       auto_gen_only_exclude:
                                         ['Generate only Exclude parameters and not Max',
                                          'when running --auto-gen-config, except if the',

data/lib/rubocop/path_util.rb

@@ -3,41 +3,59 @@
 module RuboCop
   # Common methods and behaviors for dealing with paths.
   module PathUtil
+    class << self
+      attr_accessor :relative_paths_cache
+    end
+    self.relative_paths_cache = Hash.new { |hash, key| hash[key] = {} }
+
     module_function
 
     def relative_path(path, base_dir = Dir.pwd)
-      # Optimization for the common case where path begins with the base
-      # dir. Just cut off the first part.
-      if path.start_with?(base_dir)
-        base_dir_length = base_dir.length
-        result_length = path.length - base_dir_length - 1
-        return path[base_dir_length + 1, result_length]
-      end
-
-      path_name = Pathname.new(File.expand_path(path))
-      begin
-        path_name.relative_path_from(Pathname.new(base_dir)).to_s
-      rescue ArgumentError
-        path
-      end
+      PathUtil.relative_paths_cache[base_dir][path] ||=
+        # Optimization for the common case where path begins with the base
+        # dir. Just cut off the first part.
+        if path.start_with?(base_dir)
+          base_dir_length = base_dir.length
+          result_length = path.length - base_dir_length - 1
+          path[base_dir_length + 1, result_length]
+        else
+          path_name = Pathname.new(File.expand_path(path))
+          begin
+            path_name.relative_path_from(Pathname.new(base_dir)).to_s
+          rescue ArgumentError
+            path
+          end
+        end
     end
 
+    SMART_PATH_CACHE = {} # rubocop:disable Style/MutableConstant
+    private_constant :SMART_PATH_CACHE
+
     def smart_path(path)
-      # Ideally, we calculate this relative to the project root.
-      base_dir = Dir.pwd
+      SMART_PATH_CACHE[path] ||= begin
+        # Ideally, we calculate this relative to the project root.
+        base_dir = Dir.pwd
 
-      if path.start_with? base_dir
-        relative_path(path, base_dir)
-      else
-        path
+        if path.start_with? base_dir
+          relative_path(path, base_dir)
+        else
+          path
+        end
       end
     end
 
+    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
     def match_path?(pattern, path)
       case pattern
       when String
-        File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) ||
-          hidden_file_in_not_hidden_dir?(pattern, path)
+        matches =
+          if pattern == path
+            true
+          elsif glob?(pattern)
+            File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+          end
+
+        matches || hidden_file_in_not_hidden_dir?(pattern, path)
       when Regexp
         begin
           pattern.match?(path)
@@ -48,12 +66,18 @@ module RuboCop
         end
       end
     end
+    # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
     # Returns true for an absolute Unix or Windows path.
     def absolute?(path)
       %r{\A([A-Z]:)?/}i.match?(path)
     end
 
+    # Returns true for a glob
+    def glob?(path)
+      path.match?(/[*{\[?]/)
+    end
+
     def hidden_file_in_not_hidden_dir?(pattern, path)
       hidden_file?(path) &&
         File.fnmatch?(
@@ -67,8 +91,12 @@ module RuboCop
       maybe_hidden_file?(path) && File.basename(path).start_with?('.')
     end
 
+    HIDDEN_FILE_PATTERN = "#{File::SEPARATOR}."
+
     # Loose check to reduce memory allocations
     def maybe_hidden_file?(path)
+      return false unless path.include?(HIDDEN_FILE_PATTERN)
+
       separator_index = path.rindex(File::SEPARATOR)
       return false unless separator_index
 

data/lib/rubocop/result_cache.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require 'digest/sha1'
-require 'find'
 require 'etc'
+require 'find'
 require 'zlib'
 require_relative 'cache_config'
 
@@ -53,7 +53,7 @@ module RuboCop
       def remove_oldest_files(files, dirs, cache_root, verbose)
         # Add 1 to half the number of files, so that we remove the file if
         # there's only 1 left.
-        remove_count = 1 + (files.length / 2)
+        remove_count = (files.length / 2) + 1
         puts "Removing the #{remove_count} oldest files from #{cache_root}" if verbose
         sorted = files.sort_by { |path| File.mtime(path) }
         remove_files(sorted, dirs, remove_count)

data/lib/rubocop/rspec/cop_helper.rb

@@ -44,7 +44,10 @@ module CopHelper
 
   def registry
     @registry ||= begin
-      cops = configuration.keys.map { |cop| RuboCop::Cop::Registry.global.find_by_cop_name(cop) }
+      keys = configuration.keys
+      cops =
+        keys.map { |directive| RuboCop::Cop::Registry.global.find_cops_by_directive(directive) }
+            .flatten
       cops << cop_class if defined?(cop_class) && !cops.include?(cop_class)
       cops.compact!
       RuboCop::Cop::Registry.new(cops)

data/lib/rubocop/rspec/expect_offense.rb

@@ -6,7 +6,7 @@ module RuboCop
     #
     # This mixin makes it easier to specify strict offense expectations
     # in a declarative and visual fashion. Just type out the code that
-    # should generate a offense, annotate code by writing '^'s
+    # should generate an offense, annotate code by writing '^'s
     # underneath each character that should be highlighted, and follow
     # the carets with a string (separated by a space) that is the
     # message of the offense. You can include multiple offenses in
@@ -126,7 +126,7 @@ module RuboCop
         @offenses
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def expect_correction(correction, loop: true, source: nil)
         if source
           expected_annotations = parse_annotations(source, raise_error: false)
@@ -138,6 +138,8 @@ module RuboCop
 
         source = @processed_source.raw_source
 
+        raise 'Use `expect_no_corrections` if the code will not change' if correction == source
+
         iteration = 0
         new_source = loop do
           iteration += 1
@@ -157,11 +159,11 @@ module RuboCop
           _investigate(cop, @processed_source)
         end
 
-        raise 'Use `expect_no_corrections` if the code will not change' if new_source == source
+        raise 'Expected correction but no corrections were made' if new_source == source
 
         expect(new_source).to eq(correction)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def expect_no_corrections
         raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source

data/lib/rubocop/rspec/support.rb

@@ -3,10 +3,10 @@
 # Require this file to load code that supports testing using RSpec.
 
 require_relative 'cop_helper'
-require_relative 'host_environment_simulation_helper'
-require_relative 'shared_contexts'
 require_relative 'expect_offense'
+require_relative 'host_environment_simulation_helper'
 require_relative 'parallel_formatter'
+require_relative 'shared_contexts'
 
 RSpec.configure do |config|
   config.include CopHelper