rubocop 1.85.1 → 1.86.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0878d77ab8d3571eaa4e50ac6d4c89bac50ba7b36a740b944293dff7e60e3c5
-  data.tar.gz: 21f33042b5a670b5da1b58cbdee49a6250f537326881e34b2766c40a4d9a9f3b
+  metadata.gz: a8991e66e8594a8ba30b4122a2990df1d7f610e3e51515b016e68432bcd94855
+  data.tar.gz: dadc1936594395ec71c4b628867d1ed2e2f585fcafedb886e5493d0b81c4cb2f
 SHA512:
-  metadata.gz: 87cec420dd37c3c60d6112b9e6ced643ee22fb5b4c95148d714876fb0bfc8171634dd9b39ac6a0f7be7373e59c960a6bdbc74c01489daad3e9fcc7dbddb78e0d
-  data.tar.gz: 3f7c8637950adec215950b600ef61565b8847f1ba90f82f0ec9720ea6e7d4215f9d0312247324ea0976e4829b1bd3de3b11a4662d0a2a865433825d42779e7be
+  metadata.gz: f95a7d048724e297f77b42444bd2eae15889bfa1b9b815fabbde131af75e99e114ab6ba2b4c0d078c937be9abd899ec7d9fb0650354b4bfd3cfb5a554f4bcfc3
+  data.tar.gz: ed088266152e384f4c2c82dead8363ced3c990b6492a4b4652f98a548ec16b0c57da73e1295dbbc302b00c5affd3fe2e540d9c012221068449d733d1c812139c

data/config/default.yml

@@ -3,20 +3,16 @@
 AllCops:
   RubyInterpreters:
     - ruby
-    - macruby
     - rake
     - jruby
-    - rbx
   # Include common Ruby source files.
   Include:
     - '**/*.rb'
     - '**/*.arb'
     - '**/*.axlsx'
     - '**/*.builder'
-    - '**/*.fcgi'
     - '**/*.gemfile'
     - '**/*.gemspec'
-    - '**/*.god'
     - '**/*.jb'
     - '**/*.jbuilder'
     - '**/*.mspec'
@@ -25,15 +21,12 @@ AllCops:
     - '**/*.podspec'
     - '**/*.rabl'
     - '**/*.rake'
-    - '**/*.rbuild'
     - '**/*.rbw'
-    - '**/*.rbx'
     - '**/*.ru'
     - '**/*.ruby'
     - '**/*.schema'
     - '**/*.spec'
     - '**/*.thor'
-    - '**/*.watchr'
     - '**/.irbrc'
     - '**/.pryrc'
     - '**/.simplecov'
@@ -43,7 +36,6 @@ AllCops:
     - '**/Brewfile'
     - '**/Buildfile'
     - '**/Capfile'
-    - '**/Cheffile'
     - '**/Dangerfile'
     - '**/Deliverfile'
     - '**/Fastfile'
@@ -60,7 +52,6 @@ AllCops:
     - '**/Snapfile'
     - '**/Steepfile'
     - '**/Thorfile'
-    - '**/Vagabondfile'
     - '**/Vagrantfile'
   Exclude:
     - 'node_modules/**/*'
@@ -117,7 +108,7 @@ AllCops:
   # line option.
   UseCache: true
   # Threshold for how many files can be stored in the result cache before some
-  # of the files are automatically removed.
+  # of the files are automatically removed. Set to false to disable cache pruning.
   MaxFilesInCache: 20000
   # The cache will be stored in "rubocop_cache" under this directory. If
   # CacheRootDirectory is ~ (nil), which it is by default, the root will be
@@ -3993,11 +3984,13 @@ Style/EmptyClassDefinition:
   Description: 'Enforces consistent style for empty class definitions.'
   Enabled: pending
   VersionAdded: '1.84'
+  VersionChanged: '1.86'
   EnforcedStyle: class_keyword
   SupportedStyles:
     - class_keyword
     - class_new
     - class_definition # Deprecated.
+  AllowedParentClasses: []
 
 Style/EmptyElse:
   Description: 'Avoid empty else-clauses.'

data/lib/rubocop/cache_config.rb

@@ -35,7 +35,7 @@ module RuboCop
       root_dir do
         next cache_root_override if cache_root_override
 
-        config_path = ConfigFinder.find_config_path(Dir.pwd)
+        config_path = ConfigFinder.find_config_path(PathUtil.pwd)
         file_contents = File.read(config_path)
 
         # Returns early if `CacheRootDirectory` is not used before requiring `erb` or `yaml`.

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

@@ -153,7 +153,7 @@ module RuboCop
         def relative_path_to_todo_from_options_config
           return AUTO_GENERATED_FILE unless @options[:config]
 
-          base = Pathname.new(Dir.pwd)
+          base = Pathname.new(PathUtil.pwd)
           config_dir = Pathname.new(@options[:config]).realpath.dirname
 
           # Don't have the path start with `/`

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

@@ -25,7 +25,7 @@ module RuboCop
           super
 
           # Load the configs so the require()s are done for custom cops
-          @config = @config_store.for(Dir.pwd)
+          @config = @config_store.for(PathUtil.pwd)
 
           @cop_matchers = @options[:show_cops].map do |pattern|
             if pattern.include?('*')
@@ -46,7 +46,7 @@ module RuboCop
           registry = Cop::Registry.global
           show_all = @cop_matchers.empty?
 
-          puts "# Available cops (#{registry.length}) + config for #{Dir.pwd}: " if show_all
+          puts "# Available cops (#{registry.length}) + config for #{PathUtil.pwd}: " if show_all
 
           registry.departments.sort!.each do |department|
             print_cops_of_department(registry, department, show_all)

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

@@ -12,7 +12,7 @@ module RuboCop
         def initialize(env)
           super
 
-          @config = @config_store.for(Dir.pwd)
+          @config = @config_store.for(PathUtil.pwd)
         end
 
         def run

data/lib/rubocop/config.rb

@@ -286,7 +286,7 @@ module RuboCop
            loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
           File.expand_path(File.dirname(loaded_path))
         else
-          Dir.pwd
+          PathUtil.pwd
         end
     end
 

data/lib/rubocop/config_finder.rb

@@ -30,7 +30,7 @@ module RuboCop
       private
 
       def find_project_root
-        pwd = Dir.pwd
+        pwd = PathUtil.pwd
         gems_file = find_last_file_upwards('Gemfile', pwd) || find_last_file_upwards('gems.rb', pwd)
         return unless gems_file
 

data/lib/rubocop/config_store.rb

@@ -49,7 +49,7 @@ module RuboCop
     end
 
     def for_pwd
-      for_dir(Dir.pwd)
+      for_dir(PathUtil.pwd)
     end
 
     # If type (file/dir) is known beforehand,

data/lib/rubocop/config_validator.rb

@@ -9,7 +9,7 @@ module RuboCop
 
     # @api private
     COMMON_PARAMS = %w[Exclude Include Severity inherit_mode AutoCorrect StyleGuide Details
-                       Enabled Reference References].freeze
+                       Enabled Reference References Safe SafeAutoCorrect].freeze
     # @api private
     INTERNAL_PARAMS = %w[Description StyleGuide
                          VersionAdded VersionChanged VersionRemoved

data/lib/rubocop/cop/layout/argument_alignment.rb

@@ -52,7 +52,7 @@ module RuboCop
                            'following the first line of a multi-line method call.'
 
         def on_send(node)
-          return if !multiple_arguments?(node) || (node.send_type? && node.method?(:[]=)) ||
+          return if !multiple_arguments?(node) || (node.call_type? && node.method?(:[]=)) ||
                     autocorrect_incompatible_with_other_cops?
 
           items = flattened_arguments(node)

data/lib/rubocop/cop/layout/dot_position.rb

@@ -112,7 +112,7 @@ module RuboCop
         end
 
         def last_heredoc_line(node)
-          if node.send_type?
+          if node.call_type?
             node.arguments.select { |arg| heredoc?(arg) }.map { |arg| arg.loc.heredoc_end.line }.max
           elsif heredoc?(node)
             node.loc.heredoc_end.line

data/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb

@@ -60,6 +60,11 @@ module RuboCop
         END_OF_HEREDOC_LINE = 1
         SIMPLE_DIRECTIVE_COMMENT_PATTERN = /\A# *:nocov:\z/.freeze
 
+        # @!method guard_clause_branch?(node)
+        def_node_matcher :guard_clause_branch?, <<~PATTERN
+          {(send nil? {:raise :fail} ...) return break next}
+        PATTERN
+
         def on_if(node)
           return if correct_style?(node)
           return if multiple_statements_on_line?(node)
@@ -97,14 +102,16 @@ module RuboCop
         end
 
         def correct_style?(node)
-          !contains_guard_clause?(node) ||
+          !node.if_branch&.guard_clause? ||
             next_line_rescue_or_ensure?(node) ||
             next_sibling_parent_empty_or_else?(node) ||
             next_sibling_empty_or_guard_clause?(node)
         end
 
         def contains_guard_clause?(node)
-          node.if_branch&.guard_clause?
+          return false unless (branch = node.if_branch)
+
+          guard_clause_branch?(branch)
         end
 
         def next_line_empty_or_allowed_directive_comment?(line)

data/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -185,7 +185,7 @@ module RuboCop
         end
 
         def empty_line_between_macros
-          cop_config.fetch('DefLikeMacros', []).map(&:to_sym)
+          @empty_line_between_macros ||= cop_config.fetch('DefLikeMacros', []).map(&:to_sym).freeze
         end
 
         def macro_candidate?(node)

data/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb

@@ -66,6 +66,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Add an empty line after attribute accessor.'
+        RESTRICT_ON_SEND = %i[attr_reader attr_writer attr_accessor attr].freeze
 
         def on_send(node)
           return unless node.attribute_accessor?

data/lib/rubocop/cop/layout/end_alignment.rb

@@ -129,8 +129,9 @@ module RuboCop
           # we check if it's an if/unless/while/until.
           return unless (rhs = first_part_of_call_chain(rhs))
 
-          # If `rhs` is a `begin` node, find the first non-`begin` child.
-          rhs = rhs.child_nodes.first while rhs.begin_type?
+          # If `rhs` is a `begin` node or a logical operator,
+          # unwrap to find the leading conditional.
+          rhs = rhs.child_nodes.first while rhs.type?(:begin, :or, :and)
 
           return unless rhs.conditional?
           return if rhs.if_type? && rhs.ternary?

data/lib/rubocop/cop/layout/multiline_method_call_indentation.rb

@@ -128,12 +128,15 @@ module RuboCop
           if hash_pair_indented?(node, pair_ancestor, given_style)
             return check_hash_pair_indented_style(rhs, pair_ancestor)
           end
-
-          return false if !pair_ancestor && not_for_this_cop?(node)
+          return false if skip_for_context?(node, pair_ancestor)
 
           check_regular_indentation(node, lhs, rhs, given_style)
         end
 
+        def skip_for_context?(node, pair_ancestor)
+          pair_ancestor ? inside_multiline_chain_arg?(node) : not_for_this_cop?(node)
+        end
+
         def hash_pair_aligned?(pair_ancestor, given_style)
           pair_ancestor && given_style == :aligned
         end
@@ -152,7 +155,10 @@ module RuboCop
         end
 
         def check_hash_pair_indentation(node, lhs, rhs)
-          @base = find_hash_pair_alignment_base(node) || lhs.source_range
+          @base = find_hash_pair_alignment_base(node)
+          return false if !@base && inside_multiline_chain_arg?(node)
+
+          @base ||= lhs.source_range
           return if aligned_with_first_line_dot?(node, rhs)
 
           calculate_column_delta_offense(rhs, @base.column)
@@ -166,6 +172,25 @@ module RuboCop
           first_call.loc.dot.join(first_call.loc.selector)
         end
 
+        def inside_multiline_chain_arg?(node)
+          enclosing_call = find_enclosing_chain_call(node)
+          return false unless enclosing_call
+
+          !same_line?(enclosing_call.loc.selector, enclosing_call.receiver.source_range)
+        end
+
+        def find_enclosing_chain_call(node)
+          hash_ancestor = find_pair_ancestor(node).parent
+          enclosing_call = hash_ancestor.parent
+          return unless hash_arg_in_chain?(enclosing_call, hash_ancestor)
+
+          enclosing_call
+        end
+
+        def hash_arg_in_chain?(call, hash_node)
+          call&.call_type? && call.receiver != hash_node && call.loc?(:dot)
+        end
+
         def aligned_with_first_line_dot?(node, rhs)
           return false unless rhs.source.start_with?('.', '&.')
 

data/lib/rubocop/cop/layout/space_around_keyword.rb

@@ -47,9 +47,11 @@ module RuboCop
           check(node, [:operator].freeze) if node.keyword?
         end
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node)
           check(node, %i[begin end].freeze)
         end
+        alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_break(node)
           check(node, [:keyword].freeze)

data/lib/rubocop/cop/layout/space_in_lambda_literal.rb

@@ -26,6 +26,7 @@ module RuboCop
 
         MSG_REQUIRE_SPACE = 'Use a space between `->` and `(` in lambda literals.'
         MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and `(` in lambda literals.'
+        RESTRICT_ON_SEND = %i[lambda].freeze
 
         def on_send(node)
           return unless arrow_lambda_with_args?(node)

data/lib/rubocop/cop/lint/constant_reassignment.rb

@@ -6,8 +6,11 @@ module RuboCop
       # Checks for constant reassignments.
       #
       # Emulates Ruby's runtime warning "already initialized constant X"
-      # when a constant is reassigned in the same file and namespace using the
-      # `NAME = value` syntax.
+      # when a constant is reassigned in the same file and namespace.
+      #
+      # The cop tracks constants defined via `NAME = value` syntax as well as
+      # class/module keyword definitions. It detects reassignment when a constant
+      # is first defined one way and then redefined using the `NAME = value` syntax.
       #
       # The cop cannot catch all offenses, like, for example, when a constant
       # is reassigned in another file, or when using metaprogramming (`Module#const_set`).
@@ -36,6 +39,14 @@ module RuboCop
       #     X = :bar
       #   end
       #
+      #   # bad
+      #   class FooError < StandardError; end
+      #   FooError = Class.new(RuntimeError)
+      #
+      #   # bad
+      #   module M; end
+      #   M = 1
+      #
       #   # good - keep only one assignment
       #   X = :bar
       #
@@ -69,16 +80,30 @@ module RuboCop
 
         # @!method remove_constant(node)
         def_node_matcher :remove_constant, <<~PATTERN
-          (send _ :remove_const
+          (send {nil? self} :remove_const
             ({sym str} $_))
         PATTERN
 
+        def on_class(node)
+          return unless unconditional_definition?(node)
+
+          constant_definitions[definition_name(node)] ||= :class
+        end
+
+        def on_module(node)
+          return unless unconditional_definition?(node)
+
+          constant_definitions[definition_name(node)] ||= :module
+        end
+
         def on_casgn(node)
           return unless fixed_constant_path?(node)
           return unless simple_assignment?(node)
-          return if constant_names.add?(fully_qualified_constant_name(node))
 
-          add_offense(node, message: format(MSG, constant: node.name))
+          name = fully_qualified_constant_name(node)
+          return constant_definitions[name] = :casgn unless constant_definitions.key?(name)
+
+          add_offense(node, message: format(MSG, constant: constant_display_name(node)))
         end
 
         def on_send(node)
@@ -90,7 +115,7 @@ module RuboCop
 
           return if namespaces.none?
 
-          constant_names.delete(fully_qualified_name_for(namespaces, constant))
+          constant_definitions.delete(fully_qualified_name_for(namespaces, constant))
         end
 
         private
@@ -104,7 +129,7 @@ module RuboCop
             return true if ancestor.type?(:module, :class)
 
             ancestor.begin_type? || ancestor.literal? || ancestor.casgn_type? ||
-              freeze_method?(ancestor)
+              ancestor.type?(:masgn, :mlhs) || freeze_method?(ancestor)
           end
         end
 
@@ -128,6 +153,10 @@ module RuboCop
           ['', *namespaces, constant].join('::')
         end
 
+        def constant_display_name(node)
+          [*constant_namespaces(node), node.name].join('::')
+        end
+
         def constant_namespaces(node)
           node.each_path.select(&:const_type?).map(&:short_name)
         end
@@ -139,8 +168,29 @@ module RuboCop
             .reverse
         end
 
-        def constant_names
-          @constant_names ||= Set.new
+        def unconditional_definition?(node)
+          node.each_ancestor.all? do |ancestor|
+            ancestor.type?(:begin, :module, :class)
+          end
+        end
+
+        def definition_name(node)
+          identifier = node.identifier
+
+          if identifier.namespace&.cbase_type?
+            fully_qualified_name_for([], identifier.short_name)
+          else
+            namespaces = ancestor_namespaces(node) + identifier_namespaces(identifier)
+            fully_qualified_name_for(namespaces, identifier.short_name)
+          end
+        end
+
+        def identifier_namespaces(identifier)
+          identifier.each_path.select(&:const_type?).map(&:short_name)
+        end
+
+        def constant_definitions
+          @constant_definitions ||= {}
         end
       end
     end

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -197,6 +197,13 @@ module RuboCop
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
 
+        # @!method class_or_module_new_block?(node)
+        def_node_matcher :class_or_module_new_block?, <<~PATTERN
+          (block
+            (send (const _ {:Class :Module}) :new ...)
+            ...)
+        PATTERN
+
         def on_send(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
           name, original_name = alias_method?(node)
 
@@ -233,9 +240,12 @@ module RuboCop
 
         def check_self_receiver(node, name)
           enclosing = node.parent_module_name
-          return unless enclosing
-
-          found_method(node, "#{enclosing}.#{name}")
+          if enclosing
+            found_method(node, "#{enclosing}.#{name}")
+          elsif (anon_block = anonymous_class_block(node))
+            scope = qualified_name(anon_block.parent_module_name, nil, 'Object')
+            found_method(node, "#{scope}.#{name}", scope_id: anon_block_scope_id(anon_block))
+          end
         end
 
         def inside_condition?(node)
@@ -274,16 +284,45 @@ module RuboCop
         end
 
         def found_instance_method(node, name)
-          return found_sclass_method(node, name) unless (scope = node.parent_module_name)
+          if (scope = node.parent_module_name)
+            found_method(node, "#{humanize_scope(scope)}#{name}")
+          elsif (anon_block = anonymous_class_block(node))
+            base = qualified_name(anon_block.parent_module_name, nil, 'Object')
+            scope = node.each_ancestor(:sclass).any? ? "#<Class:#{base}>" : base
+            found_method(
+              node, "#{humanize_scope(scope)}#{name}", scope_id: anon_block_scope_id(anon_block)
+            )
+          else
+            found_sclass_method(node, name)
+          end
+        end
 
-          # Humanize the scope
+        def humanize_scope(scope)
           scope = scope.sub(
             /(?:(?<name>.*)::)#<Class:\k<name>>|#<Class:(?<name>.*)>(?:::)?/,
             '\k<name>.'
           )
-          scope << '#' unless scope.end_with?('.')
+          scope.end_with?('.') ? scope : "#{scope}#"
+        end
+
+        def anonymous_class_block(node)
+          first_block = node.each_ancestor(:block).first
+          return unless class_or_module_new_block?(first_block)
+          return if first_block.parent&.type?(:lvasgn, :block)
+          return if node.each_ancestor(:sclass).any? { |s| !s.children.first.self_type? }
+
+          first_block
+        end
 
-          found_method(node, "#{scope}#{name}")
+        def anon_block_scope_id(anon_block)
+          parent = anon_block.parent
+          return unless parent&.call_type?
+
+          if parent.receiver
+            "#{parent.receiver.source}.#{parent.method_name}"
+          else
+            source_location(anon_block)
+          end
         end
 
         def found_sclass_method(node, name)
@@ -296,8 +335,10 @@ module RuboCop
           found_method(node, "#{singleton_receiver_node.method_name}.#{name}")
         end
 
-        def found_method(node, method_name)
+        # rubocop:disable Metrics/AbcSize
+        def found_method(node, method_name, scope_id: nil)
           key = method_key(node, method_name)
+          key = "#{key}@#{scope_id}" if scope_id
           scope = node.each_ancestor(:rescue, :ensure).first&.type
 
           if @definitions.key?(key)
@@ -314,6 +355,7 @@ module RuboCop
             @definitions[key] = node
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def method_key(node, method_name)
           if (ancestor_def = node.each_ancestor(:any_def).first)

data/lib/rubocop/cop/lint/empty_conditional_body.rb

@@ -70,7 +70,7 @@ module RuboCop
 
         def on_if(node)
           return if node.body || same_line?(node.loc.begin, node.loc.end)
-          return if cop_config['AllowComments'] && contains_comments?(node)
+          return if allow_comments?(node)
 
           range = offense_range(node)
 
@@ -83,6 +83,11 @@ module RuboCop
 
         private
 
+        def allow_comments?(node)
+          cop_config['AllowComments'] && contains_comments?(node) &&
+            !comments_contain_disables?(node, name)
+        end
+
         def offense_range(node)
           if node.loc.else
             node.source_range.begin.join(node.loc.else.begin)

data/lib/rubocop/cop/lint/empty_in_pattern.rb

@@ -53,11 +53,18 @@ module RuboCop
         def on_case_match(node)
           node.in_pattern_branches.each do |branch|
             next if branch.body
-            next if cop_config['AllowComments'] && contains_comments?(branch)
+            next if allow_comments?(branch)
 
             add_offense(branch)
           end
         end
+
+        private
+
+        def allow_comments?(node)
+          cop_config['AllowComments'] && contains_comments?(node) &&
+            !comments_contain_disables?(node, name)
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/empty_when.rb

@@ -50,11 +50,18 @@ module RuboCop
         def on_case(node)
           node.when_branches.each do |when_node|
             next if when_node.body
-            next if cop_config['AllowComments'] && contains_comments?(when_node)
+            next if allow_comments?(when_node)
 
             add_offense(when_node)
           end
         end
+
+        private
+
+        def allow_comments?(node)
+          cop_config['AllowComments'] && contains_comments?(node) &&
+            !comments_contain_disables?(node, name)
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -162,7 +162,7 @@ module RuboCop
         end
 
         def allow_receiver?(receiver)
-          if receiver.numeric_type? || (receiver.send_type? &&
+          if receiver.numeric_type? || (receiver.call_type? &&
             (conversion_method?(receiver.method_name) ||
             allowed_method_name?(receiver.method_name)))
             true

data/lib/rubocop/cop/lint/redundant_safe_navigation.rb

@@ -62,6 +62,22 @@ module RuboCop
       #   do_something if attrs.respond_to?(:[])
       #
       #   # bad
+      #   foo&.bar ? foo&.bar.baz : qux
+      #
+      #   # good
+      #   foo&.bar ? foo.bar.baz : qux
+      #
+      #   # bad
+      #   if foo&.bar
+      #     foo&.bar.baz
+      #   end
+      #
+      #   # good
+      #   if foo&.bar
+      #     foo.bar.baz
+      #   end
+      #
+      #   # bad
       #   while node&.is_a?(BeginNode)
       #     node = node.parent
       #   end