rubocop-rails 2.27.0 → 2.30.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a20ef13a67612f99cb522625350e57836511b07a2666b75a8cbc556620adf01
-  data.tar.gz: 436aaa2f094779e0101e17d2cb56f4a7bdd64fbf14360e9e22102be13da413af
+  metadata.gz: 69854cebe11dde8160c57b94c6ebbe60e7df48c1357aae64b932f73bb2f230ad
+  data.tar.gz: 04b388703ccde52554cb01f0e04a50291beada4dec9199fbb46b3dd750d8a4ff
 SHA512:
-  metadata.gz: 4d73f8ec4a0567acff57d0e39b267a24ee615e58d20114fa8fd37d5614ea2d4b3e6435c9ed34db322d7368086f9df150de0646c5e63cfd2987d0847dc3abd057
-  data.tar.gz: 93f42a0c60daec890a8cd363f588e37e5f65210d63dbb7e85e1c19cd32dc6459d6e593fbc3947b1cef832b981ca7b06bb5871c60cf6439a07e32c3df54257bcc
+  metadata.gz: 79fda1fbb14ab98b4472576b7cb776294f3c46eb56c3b0751e47c5fba308615b4f1579a41ea3b14a8c2fb22e19e693ea1e615fe48c5d9fff6f8c857ef887a53f
+  data.tar.gz: f219f779b57f3ecd44937c02e85872058b453bdd7ce5c83cc1d6ac05175b2c93c01d2548a02c9b46ca26bc2dca6af116611a9d9595d81b53e5a165e47a8b6cf4

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-23 Bozhidar Batsov
+Copyright (c) 2012-25 Bozhidar Batsov
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -31,13 +31,13 @@ ways to do this:
 Put this into your `.rubocop.yml`.
 
 ```yaml
-require: rubocop-rails
+plugins: rubocop-rails
 ```
 
 Alternatively, use the following array notation when specifying multiple extensions.
 
 ```yaml
-require:
+plugins:
   - rubocop-other-extension
   - rubocop-rails
 ```
@@ -45,21 +45,22 @@ require:
 Now you can run `rubocop` and it will automatically load the RuboCop Rails
 cops together with the standard cops.
 
+> [!NOTE]
+> The plugin system is supported in RuboCop 1.72+. In earlier versions, use `require` instead of `plugins`.
+
 ### Command line
 
 ```sh
-$ rubocop --require rubocop-rails
+$ rubocop --plugin rubocop-rails
 ```
 
-Note: `--rails` option is required while `rubocop` command supports `--rails` option.
-
 ### Rake task
 
 ```ruby
 require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new do |task|
-  task.requires << 'rubocop-rails'
+  task.plugins << 'rubocop-rails'
 end
 ```
 
@@ -83,6 +84,22 @@ gems.locked file to find the version of Rails that has been bound to the
 application. If neither of those files exist, RuboCop will use Rails 5.0
 as the default.
 
+### `AllCops: MigratedSchemaVersion`
+
+By specifying the `MigratedSchemaVersion` option, migration files that have already been run can be ignored.
+When `MigratedSchemaVersion: '20241225000000'` is set, migration files lower than or equal to '20241225000000' will be ignored.
+For example, to ignore db/migrate/20241225000000_create_articles.rb and earlier migrations you would configure it the following way:
+
+```yaml
+AllCops:
+  MigratedSchemaVersion: '20241225000000'
+```
+
+This prevents inspecting schema settings for already applied migration files.
+Changing already applied migrations should be avoided because it can lead to the schema getting out of sync
+between your local copy and what it actually is in production, depending on when `bin/rails db:migrate` was executed.
+If you want to modify your schema to comply with the cops, you should instead create new migrations.
+
 ## Rails configuration tip
 
 In Rails 6.1+, add the following `config.generators.after_generate` setting to

data/config/default.yml

@@ -25,6 +25,10 @@ AllCops:
   # application. If neither of those files exist, RuboCop will use Rails 5.0
   # as the default.
   TargetRailsVersion: ~
+  # By specifying `MigratedSchemaVersion` option, migration files that have been migrated can be ignored.
+  # When `MigratedSchemaVersion: '20241231000000'` is set. Migration files lower than or equal to '20250101000000' will be ignored.
+  # For example, this is the timestamp in db/migrate/20250101000000_create_articles.rb.
+  MigratedSchemaVersion: '19700101000000' # NOTE: Used as a sentinel value for the UNIX epoch time.
 
 Lint/NumberConversion:
   # Add Rails' duration methods to the ignore list for `Lint/NumberConversion`
@@ -694,6 +698,15 @@ Rails/MigrationClassName:
   Include:
     - db/**/*.rb
 
+Rails/MultipleRoutePaths:
+  Description: 'Checks for mapping a route with multiple paths, which is deprecated and will be removed in Rails 8.1.'
+  Enabled: pending
+  Severity: warning
+  VersionAdded: '2.29'
+  Include:
+    - config/routes.rb
+    - config/routes/**/*.rb
+
 Rails/NegateInclude:
   Description: 'Prefer `collection.exclude?(obj)` over `!collection.include?(obj)`.'
   StyleGuide: 'https://rails.rubystyle.guide#exclude'
@@ -1068,6 +1081,15 @@ Rails/StripHeredoc:
   Enabled: pending
   VersionAdded: '2.15'
 
+Rails/StrongParametersExpect:
+  Description: 'Enforces the use of `ActionController::Parameters#expect` as a method for strong parameter handling.'
+  Reference: 'https://api.rubyonrails.org/classes/ActionController/Parameters.html#method-i-expect'
+  Enabled: pending
+  Include:
+    - app/controllers/**/*.rb
+  SafeAutoCorrect: false
+  VersionAdded: '2.29'
+
 Rails/TableNameAssignment:
   Description: >-
     Do not use `self.table_name =`. Use Inflections or `table_name_prefix` instead.

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

@@ -87,7 +87,7 @@ module RuboCop
 
         options.each_pair.find do |pair|
           next unless pair.key.sym_type? && pair.key.value == :foreign_key
-          next unless pair.value.sym_type? || pair.value.str_type?
+          next unless pair.value.type?(:sym, :str)
 
           break pair.value.value.to_s
         end

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

@@ -6,7 +6,72 @@ module RuboCop
     module IndexMethod # rubocop:disable Metrics/ModuleLength
       RESTRICT_ON_SEND = %i[each_with_object to_h map collect []].freeze
 
-      def on_block(node) # rubocop:todo InternalAffairs/NumblockHandler
+      # Internal helper class to hold match data
+      Captures = ::Struct.new(
+        :transformed_argname,
+        :transforming_body_expr
+      ) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? && transforming_body_expr.children == [transformed_argname]
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = ::Struct.new(:match, :block_node, :leading, :trailing) do
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_map_to_h(node, match)
+          if node.block_literal?
+            strip_trailing_chars = 0
+          else
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, "#{node.receiver.source}[".length, ']'.length)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.source_range
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object` case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          return if block_node.numblock_type?
+
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          body_source = transforming_body_expr.source
+          body_source = "{ #{body_source} }" if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+
+          corrector.replace(block_node.body, body_source)
+        end
+      end
+
+      def on_block(node)
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
@@ -18,6 +83,8 @@ module RuboCop
         end
       end
 
+      alias on_numblock on_block
+
       def on_send(node)
         on_bad_map_to_h(node) do |*match|
           handle_possible_offense(node, match, 'map { ... }.to_h')
@@ -100,66 +167,6 @@ module RuboCop
         correction.set_new_arg_name(captures.transformed_argname, corrector)
         correction.set_new_body_expression(captures.transforming_body_expr, corrector)
       end
-
-      # Internal helper class to hold match data
-      Captures = ::Struct.new(
-        :transformed_argname,
-        :transforming_body_expr
-      ) do
-        def noop_transformation?
-          transforming_body_expr.lvar_type? && transforming_body_expr.children == [transformed_argname]
-        end
-      end
-
-      # Internal helper class to hold autocorrect data
-      Autocorrection = ::Struct.new(:match, :block_node, :leading, :trailing) do
-        def self.from_each_with_object(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_to_h(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_map_to_h(node, match)
-          strip_trailing_chars = 0
-
-          unless node.parent&.block_type?
-            map_range = node.children.first.source_range
-            node_range = node.source_range
-            strip_trailing_chars = node_range.end_pos - map_range.end_pos
-          end
-
-          new(match, node.children.first, 0, strip_trailing_chars)
-        end
-
-        def self.from_hash_brackets_map(node, match)
-          new(match, node.children.last, "#{node.receiver.source}[".length, ']'.length)
-        end
-
-        def strip_prefix_and_suffix(node, corrector)
-          expression = node.source_range
-          corrector.remove_leading(expression, leading)
-          corrector.remove_trailing(expression, trailing)
-        end
-
-        def set_new_method_name(new_method_name, corrector)
-          range = block_node.send_node.loc.selector
-          if (send_end = block_node.send_node.loc.end)
-            # If there are arguments (only true in the `each_with_object` case)
-            range = range.begin.join(send_end)
-          end
-          corrector.replace(range, new_method_name)
-        end
-
-        def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
-        end
-
-        def set_new_body_expression(transforming_body_expr, corrector)
-          corrector.replace(block_node.body, transforming_body_expr.source)
-        end
-      end
     end
   end
 end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops working with routes.
+    module RoutesHelper
+      extend NodePattern::Macros
+
+      HTTP_METHODS = %i[get post put patch delete].freeze
+
+      def_node_matcher :routes_draw?, <<~PATTERN
+        (send (send _ :routes) :draw)
+      PATTERN
+
+      def within_routes?(node)
+        node.each_ancestor(:block).any? { |block| routes_draw?(block.send_node) }
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/add_column_index.rb

@@ -19,6 +19,7 @@ module RuboCop
       class AddColumnIndex < Base
         extend AutoCorrector
         include RangeHelp
+        include MigrationsHelper
 
         MSG = '`add_column` does not accept an `index` key, use `add_index` instead.'
         RESTRICT_ON_SEND = %i[add_column].freeze

data/lib/rubocop/cop/rails/belongs_to.rb

@@ -66,7 +66,7 @@ module RuboCop
 
         def_node_matcher :match_belongs_to_with_options, <<~PATTERN
           (send _ :belongs_to ...
-            (hash <$(pair (sym :required) ${true false}) ...>)
+            (hash <$(pair (sym :required) $boolean) ...>)
           )
         PATTERN
 

data/lib/rubocop/cop/rails/blank.rb

@@ -123,7 +123,7 @@ module RuboCop
         def on_if(node)
           return unless cop_config['UnlessPresent']
           return unless node.unless?
-          return if node.else? && config.for_cop('Style/UnlessElse')['Enabled']
+          return if node.else? && config.cop_enabled?('Style/UnlessElse')
 
           unless_present?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)

data/lib/rubocop/cop/rails/bulk_change_table.rb

@@ -65,6 +65,7 @@ module RuboCop
       #   end
       class BulkChangeTable < Base
         include DatabaseTypeResolvable
+        include MigrationsHelper
 
         MSG_FOR_CHANGE_TABLE = <<~MSG.chomp
           You can combine alter queries using `bulk: true` options.

data/lib/rubocop/cop/rails/content_tag.rb

@@ -79,7 +79,7 @@ module RuboCop
         end
 
         def allowed_name?(argument)
-          return false unless argument.str_type? || argument.sym_type?
+          return false unless argument.type?(:str, :sym)
 
           !/^[a-zA-Z-][a-zA-Z\-0-9]*$/.match?(argument.value)
         end

data/lib/rubocop/cop/rails/dangerous_column_names.rb

@@ -14,6 +14,8 @@ module RuboCop
       #   # good
       #   add_column :users, :saved
       class DangerousColumnNames < Base # rubocop:disable Metrics/ClassLength
+        include MigrationsHelper
+
         COLUMN_TYPE_METHOD_NAMES = %i[
           bigint
           binary

data/lib/rubocop/cop/rails/delegate.rb

@@ -68,12 +68,13 @@ module RuboCop
 
         def_node_matcher :delegate?, <<~PATTERN
           (def _method_name _args
-            (send {(send nil? _) (self)} _ ...))
+            (send {(send nil? _) (self) (send (self) :class) ({cvar gvar ivar} _) (const _ _)} _ ...))
         PATTERN
 
         def on_def(node)
           return unless trivial_delegate?(node)
           return if private_or_protected_delegation(node)
+          return if module_function_declared?(node)
 
           register_offense(node)
         end
@@ -82,15 +83,40 @@ module RuboCop
 
         def register_offense(node)
           add_offense(node.loc.keyword) do |corrector|
-            body = node.body
+            receiver = determine_register_offense_receiver(node.body.receiver)
+            delegation = build_delegation(node, receiver)
 
-            receiver = body.receiver.self_type? ? 'self' : ":#{body.receiver.method_name}"
+            corrector.replace(node, delegation)
+          end
+        end
 
-            delegation = ["delegate :#{body.method_name}", "to: #{receiver}"]
-            delegation << ['prefix: true'] if node.method?(prefixed_method_name(node.body))
+        def determine_register_offense_receiver(receiver)
+          case receiver.type
+          when :self
+            'self'
+          when :const
+            full_name = full_const_name(receiver)
+            full_name.include?('::') ? ":'#{full_name}'" : ":#{full_name}"
+          when :cvar, :gvar, :ivar
+            ":#{receiver.source}"
+          else
+            ":#{receiver.method_name}"
+          end
+        end
 
-            corrector.replace(node, delegation.join(', '))
+        def build_delegation(node, receiver)
+          delegation = ["delegate :#{node.body.method_name}", "to: #{receiver}"]
+          delegation << ['prefix: true'] if node.method?(prefixed_method_name(node.body))
+          delegation.join(', ')
+        end
+
+        def full_const_name(node)
+          return unless node.const_type?
+          unless node.namespace
+            return node.absolute? ? "::#{node.source}" : node.source
           end
+
+          "#{full_const_name(node.namespace)}::#{node.short_name}"
         end
 
         def trivial_delegate?(def_node)
@@ -120,13 +146,30 @@ module RuboCop
         def prefixed_method_name(body)
           return '' if body.receiver.self_type?
 
-          [body.receiver.method_name, body.method_name].join('_').to_sym
+          [determine_prefixed_method_receiver_name(body.receiver), body.method_name].join('_').to_sym
+        end
+
+        def determine_prefixed_method_receiver_name(receiver)
+          case receiver.type
+          when :cvar, :gvar, :ivar
+            receiver.source
+          when :const
+            full_const_name(receiver)
+          else
+            receiver.method_name.to_s
+          end
         end
 
         def private_or_protected_delegation(node)
           private_or_protected_inline(node) || node_visibility(node) != :public
         end
 
+        def module_function_declared?(node)
+          node.each_ancestor(:module, :begin).any? do |ancestor|
+            ancestor.children.any? { |child| child.send_type? && child.method?(:module_function) }
+          end
+        end
+
         def private_or_protected_inline(node)
           processed_source[node.first_line - 1].strip.match?(/\A(private )|(protected )/)
         end

data/lib/rubocop/cop/rails/duplicate_association.rb

@@ -63,11 +63,15 @@ module RuboCop
         private
 
         def register_offense(name, nodes, message_template)
-          nodes.each do |node|
-            add_offense(node, message: format(message_template, name: name)) do |corrector|
-              next if same_line?(nodes.last, node)
+          last_node = nodes.last
 
-              corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+          nodes.each_with_index do |node, index|
+            add_offense(node, message: format(message_template, name: name)) do |corrector|
+              if index.zero?
+                corrector.replace(node, last_node.source)
+              else
+                corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+              end
             end
           end
         end

data/lib/rubocop/cop/rails/file_path.rb

@@ -6,6 +6,9 @@ module RuboCop
       # Identifies usages of file path joining process to use `Rails.root.join` clause.
       # It is used to add uniformity when joining paths.
       #
+      # NOTE: This cop ignores leading slashes in string literal arguments for `Rails.root.join`
+      #       and multiple slashes in string literal arguments for `Rails.root.join` and `File.join`.
+      #
       # @example EnforcedStyle: slashes (default)
       #   # bad
       #   Rails.root.join('app', 'models', 'goober')
@@ -66,6 +69,8 @@ module RuboCop
 
         def on_send(node)
           check_for_file_join_with_rails_root(node)
+          return unless node.receiver
+
           check_for_rails_root_join_with_slash_separated_path(node)
           check_for_rails_root_join_with_string_arguments(node)
         end
@@ -76,6 +81,7 @@ module RuboCop
           rails_root_index = find_rails_root_index(node)
           slash_node = node.children[rails_root_index + 1]
           return unless slash_node&.str_type? && slash_node.source.start_with?(File::SEPARATOR)
+          return unless node.children[rails_root_index].children.first.send_type?
 
           register_offense(node, require_to_s: false) do |corrector|
             autocorrect_slash_after_rails_root_in_dstr(corrector, node, rails_root_index)
@@ -94,7 +100,7 @@ module RuboCop
 
         def check_for_file_join_with_rails_root(node)
           return unless file_join_nodes?(node)
-          return unless node.arguments.any? { |e| rails_root_nodes?(e) }
+          return unless valid_arguments_for_file_join_with_rails_root?(node.arguments)
 
           register_offense(node, require_to_s: true) do |corrector|
             autocorrect_file_join(corrector, node) unless node.first_argument.array_type?
@@ -105,8 +111,7 @@ module RuboCop
           return unless style == :slashes
           return unless rails_root_nodes?(node)
           return unless rails_root_join_nodes?(node)
-          return unless node.arguments.size > 1
-          return unless node.arguments.all?(&:str_type?)
+          return unless valid_string_arguments_for_rails_root_join?(node.arguments)
 
           register_offense(node, require_to_s: false) do |corrector|
             autocorrect_rails_root_join_with_string_arguments(corrector, node)
@@ -117,15 +122,42 @@ module RuboCop
           return unless style == :arguments
           return unless rails_root_nodes?(node)
           return unless rails_root_join_nodes?(node)
-          return unless node.arguments.any? { |arg| string_with_slash?(arg) }
+          return unless valid_slash_separated_path_for_rails_root_join?(node.arguments)
 
           register_offense(node, require_to_s: false) do |corrector|
             autocorrect_rails_root_join_with_slash_separated_path(corrector, node)
           end
         end
 
-        def string_with_slash?(node)
-          node.str_type? && node.source.include?(File::SEPARATOR)
+        def valid_arguments_for_file_join_with_rails_root?(arguments)
+          return false unless arguments.any? { |arg| rails_root_nodes?(arg) }
+
+          arguments.none? { |arg| arg.variable? || arg.const_type? || string_contains_multiple_slashes?(arg) }
+        end
+
+        def valid_string_arguments_for_rails_root_join?(arguments)
+          return false unless arguments.size > 1
+          return false unless arguments.all?(&:str_type?)
+
+          arguments.none? { |arg| string_with_leading_slash?(arg) || string_contains_multiple_slashes?(arg) }
+        end
+
+        def valid_slash_separated_path_for_rails_root_join?(arguments)
+          return false unless arguments.any? { |arg| string_contains_slash?(arg) }
+
+          arguments.none? { |arg| string_with_leading_slash?(arg) || string_contains_multiple_slashes?(arg) }
+        end
+
+        def string_contains_slash?(node)
+          node.str_type? && node.value.include?(File::SEPARATOR)
+        end
+
+        def string_contains_multiple_slashes?(node)
+          node.str_type? && node.value.include?('//')
+        end
+
+        def string_with_leading_slash?(node)
+          node.str_type? && node.value.start_with?(File::SEPARATOR)
         end
 
         def register_offense(node, require_to_s:, &block)
@@ -170,7 +202,17 @@ module RuboCop
         end
 
         def autocorrect_file_join(corrector, node)
+          replace_receiver_with_rails_root(corrector, node)
+          remove_first_argument_with_comma(corrector, node)
+          process_arguments(corrector, node.arguments)
+          append_to_string_conversion(corrector, node)
+        end
+
+        def replace_receiver_with_rails_root(corrector, node)
           corrector.replace(node.receiver, 'Rails.root')
+        end
+
+        def remove_first_argument_with_comma(corrector, node)
           corrector.remove(
             range_with_surrounding_space(
               range_with_surrounding_comma(
@@ -180,9 +222,19 @@ module RuboCop
               side: :right
             )
           )
-          node.arguments.filter(&:str_type?).each do |argument|
-            corrector.replace(argument, argument.value.delete_prefix('/').inspect)
+        end
+
+        def process_arguments(corrector, arguments)
+          arguments.each do |argument|
+            if argument.str_type?
+              corrector.replace(argument, argument.value.delete_prefix('/').inspect)
+            elsif argument.array_type?
+              corrector.replace(argument, "*#{argument.source}")
+            end
           end
+        end
+
+        def append_to_string_conversion(corrector, node)
           corrector.insert_after(node, '.to_s')
         end
 
@@ -203,7 +255,7 @@ module RuboCop
 
         def autocorrect_rails_root_join_with_slash_separated_path(corrector, node)
           node.arguments.each do |argument|
-            next unless string_with_slash?(argument)
+            next unless string_contains_slash?(argument)
 
             index = argument.source.index(File::SEPARATOR)
             rest = inner_range_of(argument).adjust(begin_pos: index - 1)

data/lib/rubocop/cop/rails/http_positional_arguments.rb

@@ -40,6 +40,10 @@ module RuboCop
           (hash (kwsplat _))
         PATTERN
 
+        def_node_matcher :forwarded_kwrestarg?, <<~PATTERN
+          (hash (forwarded-kwrestarg))
+        PATTERN
+
         def_node_matcher :include_rack_test_methods?, <<~PATTERN
           (send nil? :include
             (const
@@ -83,7 +87,9 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def needs_conversion?(data)
+          return false if data.forwarded_args_type? || forwarded_kwrestarg?(data)
           return true unless data.hash_type?
           return false if kwsplat_hash?(data)
 
@@ -91,6 +97,7 @@ module RuboCop
             special_keyword_arg?(pair.key) || (format_arg?(pair.key) && data.pairs.one?)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def special_keyword_arg?(node)
           node.sym_type? && KEYWORD_ARGS.include?(node.value)