rubocop 0.81.0 → 0.85.1

data/lib/rubocop/cop/mixin/regexp_literal_help.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling Regexp literals.
+    module RegexpLiteralHelp
+      private
+
+      def freespace_mode_regexp?(node)
+        regopt = node.children.find(&:regopt_type?)
+
+        regopt.children.include?(:x)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for modifier cops.
     module StatementModifier
+      include LineLengthHelp
+
       private
 
       def single_line_as_modifier?(node)
@@ -34,21 +36,14 @@ module RuboCop
       def modifier_fits_on_single_line?(node)
         return true unless max_line_length
 
-        modifier_length = length_in_modifier_form(node, node.condition,
-                                                  node.body.source_length)
-
-        modifier_length <= max_line_length
+        length_in_modifier_form(node, node.condition) <= max_line_length
       end
 
-      def length_in_modifier_form(node, cond, body_length)
+      def length_in_modifier_form(node, cond)
         keyword = node.loc.keyword
-
-        indentation = keyword.column * indentation_multiplier
-        kw_length = keyword.size
-        cond_length = cond.source_range.size
-        space = 1
-
-        indentation + body_length + space + kw_length + space + cond_length
+        indentation = keyword.source_line[/^\s*/]
+        line_length("#{indentation}#{node.body.source} #{keyword.source} " \
+                    "#{cond.source}")
       end
 
       def max_line_length
@@ -56,16 +51,6 @@ module RuboCop
 
         config.for_cop('Layout/LineLength')['Max']
       end
-
-      def indentation_multiplier
-        return 1 if config.for_cop('Layout/Tab')['Enabled']
-
-        default_configuration = RuboCop::ConfigLoader.default_configuration
-        config.for_cop('Layout/Tab')['IndentationWidth'] ||
-          config.for_cop('Layout/IndentationWidth')['Width'] ||
-          default_configuration.for_cop('Layout/Tab')['IndentationWidth'] ||
-          default_configuration.for_cop('Layout/IndentationWidth')['Width']
-      end
     end
   end
 end

data/lib/rubocop/cop/mixin/target_ruby_version.rb

@@ -4,12 +4,16 @@ module RuboCop
   module Cop
     # Common functionality for checking target ruby version.
     module TargetRubyVersion
+      def required_minimum_ruby_version
+        @minimum_target_ruby_version
+      end
+
       def minimum_target_ruby_version(version)
         @minimum_target_ruby_version = version
       end
 
       def support_target_ruby_version?(version)
-        @minimum_target_ruby_version <= version
+        required_minimum_ruby_version <= version
       end
     end
   end

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -135,7 +135,7 @@ module RuboCop
 
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
-        article = kind =~ /array/ ? 'an' : 'a'
+        article = /array/.match?(kind) ? 'an' : 'a'
         msg = format(
           MSG,
           command: 'Avoid',
@@ -184,9 +184,7 @@ module RuboCop
         #       ...
         #     SOURCE
         #   })
-        if node.pair_type? || node.hash_type?
-          return heredoc?(node.children.last)
-        end
+        return heredoc?(node.children.last) if node.pair_type? || node.hash_type?
 
         false
       end

data/lib/rubocop/cop/mixin/uncommunicative_name.rb

@@ -18,7 +18,7 @@ module RuboCop
           full_name = arg.children.first.to_s
           next if full_name == '_'
 
-          name = full_name.gsub(/\A([_]+)/, '')
+          name = full_name.gsub(/\A(_+)/, '')
           next if (arg.restarg_type? || arg.kwrestarg_type?) && name.empty?
           next if allowed_names.include?(name)
 

data/lib/rubocop/cop/naming/class_and_module_camel_case.rb

@@ -6,6 +6,12 @@ module RuboCop
       # This cop checks for class and module names with
       # an underscore in them.
       #
+      # `AllowedNames` config takes an array of permitted names.
+      # Its default value is `['module_parent']`.
+      # These names can be full class/module names or part of the name.
+      # eg. Adding `my_class` to the `AllowedNames` config will allow names like
+      # `my_class`, `my_class::User`, `App::my_class`, `App::my_class::User`, etc.
+      #
       # @example
       #   # bad
       #   class My_Class
@@ -18,11 +24,15 @@ module RuboCop
       #   end
       #   module MyModule
       #   end
+      #   class module_parent::MyModule
+      #   end
       class ClassAndModuleCamelCase < Cop
         MSG = 'Use CamelCase for classes and modules.'
 
         def on_class(node)
-          return unless node.loc.name.source =~ /_/
+          allowed = /#{cop_config['AllowedNames'].join('|')}/
+          name = node.loc.name.source.gsub(allowed, '')
+          return unless /_/.match?(name)
 
           add_offense(node, location: :name)
         end

data/lib/rubocop/cop/naming/constant_name.rb

@@ -45,8 +45,9 @@ module RuboCop
           # SomeClass = Class.new(...)
           # SomeClass = Struct.new(...)
           return if allowed_assignment?(value)
+          return if SNAKE_CASE.match?(const_name)
 
-          add_offense(node, location: :name) if const_name !~ SNAKE_CASE
+          add_offense(node, location: :name)
         end
 
         private

data/lib/rubocop/cop/naming/file_name.rb

@@ -49,25 +49,36 @@ module RuboCop
 
         def for_bad_filename(file_path)
           basename = File.basename(file_path)
-          msg = if filename_good?(basename)
-                  return if matching_definition?(file_path)
 
-                  no_definition_message(basename, file_path)
-                else
-                  return if bad_filename_allowed?
+          if filename_good?(basename)
+            msg = perform_class_and_module_naming_checks(file_path, basename)
+          else
+            msg = other_message(basename) unless bad_filename_allowed?
+          end
 
-                  other_message(basename)
-                end
+          yield source_range(processed_source.buffer, 1, 0), msg if msg
+        end
 
-          yield source_range(processed_source.buffer, 1, 0), msg
+        def perform_class_and_module_naming_checks(file_path, basename)
+          return unless expect_matching_definition?
+
+          if check_definition_path_hierarchy? &&
+             !matching_definition?(file_path)
+            msg = no_definition_message(basename, file_path)
+          elsif !matching_class?(basename)
+            msg = no_definition_message(basename, basename)
+          end
+          msg
         end
 
         def matching_definition?(file_path)
-          return true unless expect_matching_definition?
-
           find_class_or_module(processed_source.ast, to_namespace(file_path))
         end
 
+        def matching_class?(file_name)
+          find_class_or_module(processed_source.ast, to_namespace(file_name))
+        end
+
         def bad_filename_allowed?
           ignore_executable_scripts? && processed_source.start_with?('#!')
         end
@@ -94,6 +105,10 @@ module RuboCop
           cop_config['ExpectMatchingDefinition']
         end
 
+        def check_definition_path_hierarchy?
+          cop_config['CheckDefinitionPathHierarchy']
+        end
+
         def regex
           cop_config['Regex']
         end
@@ -104,7 +119,7 @@ module RuboCop
 
         def filename_good?(basename)
           basename = basename.sub(/^\./, '')
-          basename = basename.sub(/\.[^\.]+$/, '')
+          basename = basename.sub(/\.[^.]+$/, '')
           # special handling for Action Pack Variants file names like
           # some_file.xlsx+mobile.axlsx
           basename = basename.sub('+', '_')
@@ -153,9 +168,7 @@ module RuboCop
 
               namespace, name = *namespace
 
-              if name == expected.last || match_acronym?(expected.last, name)
-                expected.pop
-              end
+              expected.pop if name == expected.last || match_acronym?(expected.last, name)
             end
 
             false

data/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb

@@ -39,7 +39,7 @@ module RuboCop
         def meaningful_delimiters?(node)
           delimiters = delimiter_string(node)
 
-          return false unless delimiters =~ /\w/
+          return false unless /\w/.match?(delimiters)
 
           forbidden_delimiters.none? do |forbidden_delimiter|
             delimiters =~ Regexp.new(forbidden_delimiter)

data/lib/rubocop/cop/naming/method_name.rb

@@ -35,15 +35,11 @@ module RuboCop
 
         MSG = 'Use %<style>s for method names.'
 
-        def_node_matcher :attr?, <<~PATTERN
-          (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
-        PATTERN
-
         def_node_matcher :sym_name, '(sym $_name)'
         def_node_matcher :str_name, '(str $_name)'
 
         def on_send(node)
-          return unless (attrs = attr?(node))
+          return unless (attrs = node.attribute_accessor?)
 
           attrs.last.each do |name_item|
             name = attr_name(name_item)

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -67,7 +67,7 @@ module RuboCop
         private
 
         def allowed_method_name?(method_name, prefix)
-          !method_name.match(/^#{prefix}[^0-9]/) ||
+          !method_name.match?(/^#{prefix}[^0-9]/) ||
             method_name == expected_name(method_name, prefix) ||
             method_name.end_with?('=') ||
             allowed_methods.include?(method_name)

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -73,7 +73,7 @@ module RuboCop
             node.body&.each_descendant(:lvar) do |var|
               next unless var.children.first == offending_name
 
-              corrector.replace(var.loc.expression, preferred_name)
+              corrector.replace(var, preferred_name)
             end
           end
         end

data/lib/rubocop/cop/registry.rb

@@ -22,33 +22,42 @@ module RuboCop
 
     # Registry that tracks all cops by their badge and department.
     class Registry
-      def initialize(cops = [])
+      include Enumerable
+
+      attr_reader :options
+
+      def initialize(cops = [], options = {})
         @registry = {}
         @departments = {}
         @cops_by_cop_name = Hash.new { |hash, key| hash[key] = [] }
 
-        cops.each { |cop| enlist(cop) }
+        @enrollment_queue = cops
+        @options = options
       end
 
       def enlist(cop)
-        @registry[cop.badge] = cop
-        @departments[cop.department] ||= []
-        @departments[cop.department] << cop
-        @cops_by_cop_name[cop.cop_name] << cop
+        @enrollment_queue << cop
+      end
+
+      def dismiss(cop)
+        raise "Cop #{cop} could not be dismissed" unless @enrollment_queue.delete(cop)
       end
 
       # @return [Array<Symbol>] list of departments for current cops.
       def departments
+        clear_enrollment_queue
         @departments.keys
       end
 
       # @return [Registry] Cops for that specific department.
       def with_department(department)
+        clear_enrollment_queue
         with(@departments.fetch(department, []))
       end
 
       # @return [Registry] Cops not for a specific department.
       def without_department(department)
+        clear_enrollment_queue
         without_department = @departments.dup
         without_department.delete(department)
 
@@ -93,9 +102,7 @@ module RuboCop
       # @return [String] Qualified cop name
       def qualified_cop_name(name, path, shall_warn = true)
         badge = Badge.parse(name)
-        if shall_warn && department_missing?(badge, name)
-          print_warning(name, path)
-        end
+        print_warning(name, path) if shall_warn && department_missing?(badge, name)
         return name if registered?(badge)
 
         potential_badges = qualify_badge(badge)
@@ -120,6 +127,7 @@ module RuboCop
       end
 
       def unqualified_cop_names
+        clear_enrollment_queue
         @unqualified_cop_names ||=
           Set.new(@cops_by_cop_name.keys.map { |qn| File.basename(qn) }) <<
           'RedundantCopDisableDirective'
@@ -127,18 +135,21 @@ module RuboCop
 
       # @return [Hash{String => Array<Class>}]
       def to_h
+        clear_enrollment_queue
         @cops_by_cop_name
       end
 
       def cops
+        clear_enrollment_queue
         @registry.values
       end
 
       def length
+        clear_enrollment_queue
         @registry.size
       end
 
-      def enabled(config, only, only_safe = false)
+      def enabled(config, only = [], only_safe = false)
         select do |cop|
           only.include?(cop.cop_name) || enabled?(cop, config, only_safe)
         end
@@ -147,9 +158,8 @@ module RuboCop
       def enabled?(cop, config, only_safe)
         cfg = config.for_cop(cop)
 
-        # cfg['Enabled'] might be a string `pending`, which is considered
-        # disabled
-        cop_enabled = cfg.fetch('Enabled') == true
+        cop_enabled = cfg.fetch('Enabled') == true ||
+                      enabled_pending_cop?(cfg, config)
 
         if only_safe
           cop_enabled && cfg.fetch('Safe', true)
@@ -158,6 +168,13 @@ module RuboCop
         end
       end
 
+      def enabled_pending_cop?(cop_cfg, config)
+        return false if @options[:disable_pending_cops]
+
+        cop_cfg.fetch('Enabled') == 'pending' &&
+          (@options[:enable_pending_cops] || config.enabled_new_cops?)
+      end
+
       def names
         cops.map(&:cop_name)
       end
@@ -167,6 +184,7 @@ module RuboCop
       end
 
       def sort!
+        clear_enrollment_queue
         @registry = Hash[@registry.sort_by { |badge, _| badge.cop_name }]
 
         self
@@ -183,16 +201,57 @@ module RuboCop
       # @param [String] cop_name
       # @return [Class, nil]
       def find_by_cop_name(cop_name)
-        @cops_by_cop_name[cop_name].first
+        to_h[cop_name].first
+      end
+
+      @global = new
+
+      class << self
+        attr_reader :global
+      end
+
+      def self.all
+        global.without_department(:Test).cops
+      end
+
+      def self.qualified_cop_name(name, origin)
+        global.qualified_cop_name(name, origin)
+      end
+
+      # Changes momentarily the global registry
+      # Intended for testing purposes
+      def self.with_temporary_global(temp_global = global.dup)
+        previous = @global
+        @global = temp_global
+        yield
+      ensure
+        @global = previous
       end
 
       private
 
+      def initialize_copy(reg)
+        initialize(reg.cops, reg.options)
+      end
+
+      def clear_enrollment_queue
+        return if @enrollment_queue.empty?
+
+        @enrollment_queue.each do |cop|
+          @registry[cop.badge] = cop
+          @departments[cop.department] ||= []
+          @departments[cop.department] << cop
+          @cops_by_cop_name[cop.cop_name] << cop
+        end
+        @enrollment_queue = []
+      end
+
       def with(cops)
         self.class.new(cops)
       end
 
       def qualify_badge(badge)
+        clear_enrollment_queue
         @departments
           .map { |department, _| badge.with_department(department) }
           .select { |potential_badge| registered?(potential_badge) }
@@ -209,6 +268,7 @@ module RuboCop
       end
 
       def registered?(badge)
+        clear_enrollment_queue
         @registry.key?(badge)
       end
     end