rubocop 1.62.1 → 1.63.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8daa4ef7dd74b8608039d7dfda5f1e3fe739738949390a6f1347acaccf7bd1c4
-  data.tar.gz: 271a978db956def596a5b06a7fd69d189d807b27db0acdda03fd6200b95ef541
+  metadata.gz: 2e73eb2f54012899b388f6a92a079c80233fe1dfc570abfeedf2091cb0abc71d
+  data.tar.gz: cc1ef25acb1541f1873ebeb945254c430b175b468bc9645000008a5f7d9aea88
 SHA512:
-  metadata.gz: 484294f43781f114ba01470b22331ef17648219e26dc4ba2f28073f609c909af2997c47e1f1aad62860124f6f4594a2e536cd793f05352a78d588f979732a290
-  data.tar.gz: 6a8313e61422bcd568eea747c0f9a88f61f50620b4dd4f478da0bdd3e067c1aa8bcf70e15744e02118d4c525eb0632fae3cc19caf73db6db1f63ea76dbb84b45
+  metadata.gz: c4a4d23a528df832913cd6e469942415f2e9af4b2c8893862f7cd2dada8da960f8fbd3525934ab325d290a0161a576c38318222edc55e26a150596ca99235d11
+  data.tar.gz: c84f81ba55dd33a44a42ea9851d910738e8faffc3a02b0e6095eb17b17e4e1bf5fa90a0db5aac365a58bde4ff748782f6d6941575fb506122bc4afd2627b966c

data/README.md

@@ -53,7 +53,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.62', require: false
+gem 'rubocop', '~> 1.63', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/config/default.yml

@@ -156,13 +156,14 @@ AllCops:
   # included.
   SuggestExtensions:
     rubocop-rails: [rails]
-    rubocop-rspec: [rspec, rspec-rails]
+    rubocop-rspec: [rspec]
     rubocop-minitest: [minitest]
     rubocop-sequel: [sequel]
     rubocop-rake: [rake]
     rubocop-graphql: [graphql]
     rubocop-capybara: [capybara]
     rubocop-factory_bot: [factory_bot, factory_bot_rails]
+    rubocop-rspec_rails: [rspec-rails]
   # Enable/Disable checking the methods extended by Active Support.
   ActiveSupportExtensionsEnabled: false
 
@@ -1657,7 +1658,7 @@ Lint/Debugger:
   Description: 'Check for debugger calls.'
   Enabled: true
   VersionAdded: '0.14'
-  VersionChanged: '1.46'
+  VersionChanged: '1.63'
   DebuggerMethods:
     # Groups are available so that a specific group can be disabled in
     # a user's configuration, but are otherwise not significant.
@@ -1670,8 +1671,14 @@ Lint/Debugger:
       - Kernel.byebug
       - Kernel.remote_byebug
     Capybara:
+      - page.save_and_open_page
+      - page.save_and_open_screenshot
+      - page.save_page
+      - page.save_screenshot
       - save_and_open_page
       - save_and_open_screenshot
+      - save_page
+      - save_screenshot
     debug.rb:
       - binding.b
       - binding.break
@@ -1693,6 +1700,11 @@ Lint/Debugger:
       - jard
     WebConsole:
       - binding.console
+  DebuggerRequires:
+    debug.rb:
+      - debug/open
+      - debug/open_nonstop
+      - debug/start
 
 Lint/DeprecatedClassMethods:
   Description: 'Check for deprecated class method calls.'
@@ -2762,7 +2774,8 @@ Naming/FileName:
   VersionChanged: '1.23'
   # Camel case file names listed in `AllCops:Include` and all file names listed
   # in `AllCops:Exclude` are excluded by default. Add extra excludes here.
-  Exclude: []
+  Exclude:
+    - Rakefile.rb
   # When `true`, requires that each source file should define a class or module
   # with a name which matches the file name (converted to ... case).
   # It further expects it to be nested inside modules which match the names
@@ -4276,6 +4289,13 @@ Style/MapCompactWithConditionalBlock:
   Enabled: pending
   VersionAdded: '1.30'
 
+Style/MapIntoArray:
+  Description: 'Checks for usages of `each` with `<<`, `push`, or `append` which can be replaced by `map`.'
+  StyleGuide: '#functional-code'
+  Enabled: pending
+  VersionAdded: '1.63'
+  Safe: false
+
 Style/MapToHash:
   Description: 'Prefer `to_h` with a block over `map.to_h`.'
   Enabled: pending

data/lib/rubocop/config.rb

@@ -263,6 +263,7 @@ module RuboCop
       PathUtil.smart_path(@loaded_path)
     end
 
+    # @return [String, nil]
     def bundler_lock_file_path
       return nil unless loaded_path
 
@@ -286,27 +287,49 @@ module RuboCop
       end
     end
 
+    # Returns target's locked gem versions (i.e. from Gemfile.lock or gems.locked)
+    # @returns [Hash{String => Gem::Version}] The locked gem versions, keyed by the gems' names.
+    def gem_versions_in_target
+      @gem_versions_in_target ||= read_gem_versions_from_target_lockfile
+    end
+
     def inspect # :nodoc:
       "#<#{self.class.name}:#{object_id} @loaded_path=#{loaded_path}>"
     end
 
     private
 
+    # @return [Float, nil] The Rails version as a `major.minor` Float.
     def target_rails_version_from_bundler_lock_file
       @target_rails_version_from_bundler_lock_file ||= read_rails_version_from_bundler_lock_file
     end
 
+    # @return [Float, nil] The Rails version as a `major.minor` Float.
     def read_rails_version_from_bundler_lock_file
-      lock_file_path = bundler_lock_file_path
-      return nil unless lock_file_path
-
-      File.foreach(lock_file_path) do |line|
-        # If Rails (or one of its frameworks) is in Gemfile.lock or gems.lock, there should be
-        # a line like:
-        #         railties (X.X.X)
-        result = line.match(/^\s+railties\s+\((\d+\.\d+)/)
-        return result.captures.first.to_f if result
-      end
+      return nil unless gem_versions_in_target
+
+      # Look for `railties` instead of `rails`, to support apps that only use a subset of `rails`
+      # See https://github.com/rubocop/rubocop/pull/11289
+      rails_version_in_target = gem_versions_in_target['railties']
+      return nil unless rails_version_in_target
+
+      gem_version_to_major_minor_float(rails_version_in_target)
+    end
+
+    # @param [Gem::Version] gem_version an object like `Gem::Version.new("7.1.2.3")`
+    # @return [Float] The major and minor version, like `7.1`
+    def gem_version_to_major_minor_float(gem_version)
+      segments = gem_version.canonical_segments
+      # segments.fetch(0).to_f + (segments.fetch(1, 0.0).to_f / 10)
+      Float("#{segments.fetch(0)}.#{segments.fetch(1, 0)}")
+    end
+
+    # @returns [Hash{String => Gem::Version}] The locked gem versions, keyed by the gems' names.
+    def read_gem_versions_from_target_lockfile
+      lockfile_path = bundler_lock_file_path
+      return nil unless lockfile_path
+
+      Lockfile.new(lockfile_path).gem_versions
     end
 
     def enable_cop?(qualified_cop_name, cop_options)

data/lib/rubocop/config_obsoletion.rb

@@ -52,7 +52,7 @@ module RuboCop
     def load_rules # rubocop:disable Metrics/AbcSize
       rules = LOAD_RULES_CACHE[self.class.files] ||=
         self.class.files.each_with_object({}) do |filename, hash|
-          hash.merge!(YAML.safe_load(File.read(filename))) do |_key, first, second|
+          hash.merge!(YAML.safe_load(File.read(filename)) || {}) do |_key, first, second|
             case first
             when Hash
               first.merge(second)

data/lib/rubocop/cop/base.rb

@@ -70,6 +70,7 @@ module RuboCop
 
       def self.inherited(subclass)
         super
+        subclass.instance_variable_set(:@gem_requirements, gem_requirements.dup)
         Registry.global.enlist(subclass)
       end
 
@@ -126,6 +127,29 @@ module RuboCop
         false
       end
 
+      ## Gem requirements
+
+      @gem_requirements = {}
+
+      class << self
+        attr_reader :gem_requirements
+
+        # Register a version requirement for the given gem name.
+        # This cop will be skipped unless the target satisfies *all* requirements.
+        # @param [String] gem_name
+        # @param [Array<String>] version_requirements The version requirements,
+        #   using the same syntax as a Gemfile, e.g. ">= 1.2.3"
+        #
+        #   If omitted, any version of the gem will be accepted.
+        #
+        #   https://guides.rubygems.org/patterns/#declaring-dependencies
+        #
+        # @api public
+        def requires_gem(gem_name, *version_requirements)
+          @gem_requirements[gem_name] = Gem::Requirement.new(version_requirements)
+        end
+      end
+
       def initialize(config = nil, options = nil)
         @config = config || Config.new
         @options = options || { debug: false }
@@ -245,6 +269,7 @@ module RuboCop
       end
 
       def relevant_file?(file)
+        return false unless target_satisfies_all_gem_version_requirements?
         return true unless @config.clusivity_config_for_badge?(self.class.badge)
 
         file == RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME ||
@@ -496,6 +521,18 @@ module RuboCop
           range.end_pos + @current_offset
         )
       end
+
+      def target_satisfies_all_gem_version_requirements?
+        self.class.gem_requirements.all? do |gem_name, version_req|
+          all_gem_versions_in_target = @config.gem_versions_in_target
+          next false unless all_gem_versions_in_target
+
+          gem_version_in_target = all_gem_versions_in_target[gem_name]
+          next false unless gem_version_in_target
+
+          version_req.satisfied_by?(gem_version_in_target)
+        end
+      end
     end
   end
 end

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

@@ -45,6 +45,7 @@ module RuboCop
         EXPECT_OFFENSE_DESCRIPTION_MAPPING = {
           /\A(does not|doesn't) (register|find|flag|report)/ => 'registers',
           /\A(does not|doesn't) add (a|an|any )?offense/ => 'registers an offense',
+          /\Aregisters no offense/ => 'registers an offense',
           /\Aaccepts\b/ => 'registers'
         }.freeze
 

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

@@ -50,7 +50,7 @@ module RuboCop
         MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED =
           'Use `==` if you meant to do a comparison or move the assignment ' \
           'up out of the condition.'
-        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send].freeze
+        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send, :csend].freeze
 
         def on_if(node)
           return if node.condition.block_type?
@@ -88,7 +88,7 @@ module RuboCop
         end
 
         def skip_children?(asgn_node)
-          (asgn_node.send_type? && !asgn_node.assignment_method?) ||
+          (asgn_node.call_type? && !asgn_node.assignment_method?) ||
             empty_condition?(asgn_node) ||
             (safe_assignment_allowed? && safe_assignment?(asgn_node))
         end

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

@@ -29,6 +29,11 @@ module RuboCop
       #       MyDebugger.debug_this
       # ----
       #
+      # Some gems also ship files that will start a debugging session when required,
+      # for example `require 'debug/start'` from `ruby/debug`. These requires can
+      # be configured through `DebuggerRequires`. It has the same structure as
+      # `DebuggerMethods`, which you can read about above.
+      #
       # @example
       #
       #   # bad (ok during development)
@@ -64,14 +69,20 @@ module RuboCop
       #   def some_method
       #     my_debugger
       #   end
+      #
+      # @example DebuggerRequires: [my_debugger/start]
+      #
+      #   # bad (ok during development)
+      #
+      #   require 'my_debugger/start'
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
         BLOCK_TYPES = %i[block numblock kwbegin].freeze
 
         def on_send(node)
-          return if !debugger_method?(node) || assumed_usage_context?(node)
+          return if assumed_usage_context?(node)
 
-          add_offense(node)
+          add_offense(node) if debugger_method?(node) || debugger_require?(node)
         end
 
         private
@@ -87,12 +98,26 @@ module RuboCop
           end
         end
 
+        def debugger_requires
+          @debugger_requires ||= begin
+            config = cop_config.fetch('DebuggerRequires', [])
+            config.is_a?(Array) ? config : config.values.flatten
+          end
+        end
+
         def debugger_method?(send_node)
           return false if send_node.parent&.send_type? && send_node.parent.receiver == send_node
 
           debugger_methods.include?(chained_method_name(send_node))
         end
 
+        def debugger_require?(send_node)
+          return false unless send_node.method?(:require) && send_node.arguments.one?
+          return false unless (argument = send_node.first_argument).str_type?
+
+          debugger_requires.include?(argument.value)
+        end
+
         def assumed_usage_context?(node)
           # Basically, debugger methods are not used as a method argument without arguments.
           return false unless node.arguments.empty? && node.each_ancestor(:send, :csend).any?

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

@@ -146,7 +146,7 @@ module RuboCop
             node.source_range.with(end_pos: node.condition.source_range.end_pos)
           elsif all_branches_body_missing?(node)
             if_node = node.ancestors.detect(&:if?)
-            node.source_range.with(end_pos: if_node.loc.end.end_pos)
+            node.source_range.join(if_node.loc.end.end)
           else
             node.source_range
           end

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

@@ -130,7 +130,7 @@ module RuboCop
         # @return [Parser::Source::Range]
         #
         def last_arg_range(node)
-          node.last_argument.source_range.with(begin_pos: node.arguments[-2].source_range.end_pos)
+          node.last_argument.source_range.join(node.arguments[-2].source_range.end)
         end
 
         def unsorted_dir_loop?(node)

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

@@ -33,8 +33,10 @@ module RuboCop
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
+        # rubocop:disable Metrics/AbcSize
         def on_block(node)
           return unless node.receiver
+          return if node.method?(:with_index) && !node.receiver.receiver
           return unless (send = redundant_with_index?(node))
 
           range = with_index_range(send)
@@ -48,6 +50,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         alias on_numblock on_block
 

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

@@ -36,7 +36,7 @@ module RuboCop
         length = calculator.calculate
         return if length <= max_length
 
-        location = node.casgn_type? ? node.loc.name : node.source_range
+        location = location(node)
 
         add_offense(location, message: message(length, max_length)) { self.max = length }
       end
@@ -54,6 +54,17 @@ module RuboCop
           foldable_types: count_as_one
         )
       end
+
+      def location(node)
+        return node.loc.name if node.casgn_type?
+
+        if LSP.enabled?
+          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          node.source_range.begin.join(end_range)
+        else
+          node.source_range
+        end
+      end
     end
   end
 end

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

@@ -49,13 +49,13 @@ module RuboCop
 
         return unless complexity > max
 
-        msg = format(self.class::MSG,
-                     method: method_name,
-                     complexity: complexity,
-                     abc_vector: abc_vector,
-                     max: max)
+        msg = format(
+          self.class::MSG,
+          method: method_name, complexity: complexity, abc_vector: abc_vector, max: max
+        )
+        location = location(node)
 
-        add_offense(node, message: msg) { self.max = complexity.ceil }
+        add_offense(location, message: msg) { self.max = complexity.ceil }
       end
 
       def complexity(body)
@@ -69,6 +69,15 @@ module RuboCop
         end
         score
       end
+
+      def location(node)
+        if LSP.enabled?
+          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          node.source_range.begin.join(end_range)
+        else
+          node.source_range
+        end
+      end
     end
   end
 end

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

@@ -14,7 +14,7 @@ module RuboCop
       def_node_matcher :empty_condition?, '(begin)'
 
       # @!method setter_method?(node)
-      def_node_matcher :setter_method?, '[(send ...) setter_method?]'
+      def_node_matcher :setter_method?, '[(call ...) setter_method?]'
 
       # @!method safe_assignment?(node)
       def_node_matcher :safe_assignment?, '(begin {equals_asgn? #setter_method?})'

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

@@ -51,29 +51,25 @@ module RuboCop
           [Lint::AmbiguousOperator, Style::ArgumentsForwarding]
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def on_def(node)
           return if node.arguments.empty?
 
           last_argument = node.last_argument
           return if expected_block_forwarding_style?(node, last_argument)
 
-          invalid_syntax = false
-          node.each_descendant(:block_pass) do |block_pass_node|
-            next if block_pass_node.children.first&.sym_type? ||
-                    last_argument.source != block_pass_node.source
+          forwarded_args = node.each_descendant(:block_pass).with_object([]) do |block_pass, result|
+            return nil if invalidates_syntax?(block_pass)
+            next unless block_argument_name_matched?(block_pass, last_argument)
 
-            if block_pass_node.each_ancestor(:block, :numblock).any?
-              invalid_syntax = true
-              next
-            end
+            result << block_pass
+          end
 
-            register_offense(block_pass_node, node)
+          forwarded_args.each do |forwarded_arg|
+            register_offense(forwarded_arg, node)
           end
 
-          register_offense(last_argument, node) unless invalid_syntax
+          register_offense(last_argument, node)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
         alias on_defs on_def
 
         private
@@ -88,6 +84,29 @@ module RuboCop
           end
         end
 
+        def block_argument_name_matched?(block_pass_node, last_argument)
+          return false if block_pass_node.children.first&.sym_type?
+
+          last_argument.source == block_pass_node.source
+        end
+
+        # Prevents the following syntax error:
+        #
+        # # foo.rb
+        # def foo(&)
+        #   block_method do
+        #     bar(&)
+        #   end
+        # end
+        #
+        # $ ruby -vc foo.rb
+        # ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [x86_64-darwin22]
+        # foo.rb: foo.rb:4: anonymous block parameter is also used within block (SyntaxError)
+        #
+        def invalidates_syntax?(block_pass_node)
+          block_pass_node.each_ancestor(:block, :numblock).any?
+        end
+
         def use_kwarg_in_method_definition?(node)
           node.arguments.each_descendant(:kwarg, :kwoptarg).any?
         end

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

@@ -57,7 +57,7 @@ module RuboCop
           file_path = processed_source.file_path
           return if config.file_to_exclude?(file_path) || config.allowed_camel_case_file?(file_path)
 
-          for_bad_filename(file_path) { |range, msg| add_offense(range, message: msg) }
+          for_bad_filename(file_path)
         end
 
         private
@@ -71,7 +71,7 @@ module RuboCop
             msg = other_message(basename) unless bad_filename_allowed?
           end
 
-          yield source_range(processed_source.buffer, 1, 0), msg if msg
+          add_global_offense(msg) if msg
         end
 
         def perform_class_and_module_naming_checks(file_path, basename)

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

@@ -207,8 +207,7 @@ module RuboCop
             message = create_multiple_word_message_for_file(words)
           end
 
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(range, message: message)
+          add_global_offense(message)
         end
 
         def create_single_word_message_for_file(word)

data/lib/rubocop/cop/style/alias.rb

@@ -41,6 +41,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:alias_method)
           return unless style == :prefer_alias && alias_keyword_possible?(node)
+          return unless node.arguments.count == 2
 
           msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
           add_offense(node.loc.selector, message: msg) do |corrector|

data/lib/rubocop/cop/style/collection_compact.rb

@@ -19,9 +19,7 @@ module RuboCop
       # @example
       #   # bad
       #   array.reject(&:nil?)
-      #   array.delete_if(&:nil?)
       #   array.reject { |e| e.nil? }
-      #   array.delete_if { |e| e.nil? }
       #   array.select { |e| !e.nil? }
       #   array.grep_v(nil)
       #   array.grep_v(NilClass)
@@ -31,7 +29,9 @@ module RuboCop
       #
       #   # bad
       #   hash.reject!(&:nil?)
+      #   array.delete_if(&:nil?)
       #   hash.reject! { |k, v| v.nil? }
+      #   array.delete_if { |e| e.nil? }
       #   hash.select! { |k, v| !v.nil? }
       #
       #   # good
@@ -127,7 +127,7 @@ module RuboCop
         end
 
         def good_method_name(node)
-          if node.bang_method?
+          if node.bang_method? || node.method?(:delete_if)
             'compact!'
           else
             'compact'

data/lib/rubocop/cop/style/copyright.rb

@@ -28,18 +28,27 @@ module RuboCop
         def on_new_investigation
           return if notice.empty? || notice_found?(processed_source)
 
-          add_offense(offense_range, message: format(MSG, notice: notice)) do |corrector|
-            verify_autocorrect_notice!
-
-            token = insert_notice_before(processed_source)
-            range = token.nil? ? range_between(0, 0) : token.pos
-
-            corrector.insert_before(range, "#{autocorrect_notice}\n")
+          verify_autocorrect_notice!
+          message = format(MSG, notice: notice)
+          if processed_source.blank?
+            add_global_offense(message)
+          else
+            offense_range = source_range(processed_source.buffer, 1, 0)
+            add_offense(offense_range, message: message) do |corrector|
+              autocorrect(corrector)
+            end
           end
         end
 
         private
 
+        def autocorrect(corrector)
+          token = insert_notice_before(processed_source)
+          range = token.nil? ? range_between(0, 0) : token.pos
+
+          corrector.insert_before(range, "#{autocorrect_notice}\n")
+        end
+
         def notice
           cop_config['Notice']
         end
@@ -48,10 +57,6 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
-        def offense_range
-          source_range(processed_source.buffer, 1, 0)
-        end
-
         def verify_autocorrect_notice!
           raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
 

data/lib/rubocop/cop/style/eval_with_location.rb

@@ -141,7 +141,7 @@ module RuboCop
         end
 
         def check_file(node, file_node)
-          return true if special_file_keyword?(file_node)
+          return if special_file_keyword?(file_node)
 
           message = format(MSG_INCORRECT_FILE,
                            method_name: node.method_name,
@@ -155,6 +155,8 @@ module RuboCop
 
         def check_line(node, code)
           line_node = node.last_argument
+          return if line_node.variable? || (line_node.send_type? && !line_node.method?(:+))
+
           line_diff = line_difference(line_node, code)
           if line_diff.zero?
             add_offense_for_same_line(node, line_node)

data/lib/rubocop/cop/style/exact_regexp_match.rb

@@ -38,12 +38,13 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless (receiver = node.receiver)
           return unless (regexp = exact_regexp_match(node))
 
           parsed_regexp = Regexp::Parser.parse(regexp)
           return unless exact_match_pattern?(parsed_regexp)
 
-          prefer = "#{node.receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
+          prefer = "#{receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
             corrector.replace(node, prefer)