rubocop-rails 2.25.1 → 2.32.0

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for enums written with keyword arguments syntax.
+      #
+      # Defining enums with keyword arguments syntax is deprecated and will be removed in Rails 8.0.
+      # Positional arguments should be used instead:
+      #
+      # @example
+      #   # bad
+      #   enum status: { active: 0, archived: 1 }, _prefix: true
+      #
+      #   # good
+      #   enum :status, { active: 0, archived: 1 }, prefix: true
+      #
+      class EnumSyntax < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        extend TargetRailsVersion
+
+        minimum_target_ruby_version 3.0
+        minimum_target_rails_version 7.0
+
+        MSG = 'Enum defined with keyword arguments in `%<enum>s` enum declaration. Use positional arguments instead.'
+        MSG_OPTIONS = 'Enum defined with deprecated options in `%<enum>s` enum declaration. Remove the `_` prefix.'
+        RESTRICT_ON_SEND = %i[enum].freeze
+
+        # From https://github.com/rails/rails/blob/v7.2.1/activerecord/lib/active_record/enum.rb#L231
+        OPTION_NAMES = %w[prefix suffix scopes default instance_methods].freeze
+        UNDERSCORED_OPTION_NAMES = OPTION_NAMES.map { |option| "_#{option}" }.freeze
+
+        def_node_matcher :enum?, <<~PATTERN
+          (send nil? :enum (hash $...))
+        PATTERN
+
+        def_node_matcher :enum_with_options?, <<~PATTERN
+          (send nil? :enum $_ ${array hash} $_)
+        PATTERN
+
+        def on_send(node)
+          check_and_correct_keyword_args(node)
+          check_enum_options(node)
+        end
+
+        private
+
+        def check_and_correct_keyword_args(node)
+          enum?(node) do |pairs|
+            pairs.each do |pair|
+              next if option_key?(pair)
+
+              correct_keyword_args(node, pair.key, pair.value, pairs[1..])
+            end
+          end
+        end
+
+        def check_enum_options(node)
+          enum_with_options?(node) do |key, _, options|
+            options.children.each do |option|
+              next unless option_key?(option)
+
+              add_offense(option.key, message: format(MSG_OPTIONS, enum: enum_name_value(key))) do |corrector|
+                corrector.replace(option.key, option.key.source.delete_prefix('_'))
+              end
+            end
+          end
+        end
+
+        def correct_keyword_args(node, key, values, options)
+          add_offense(values, message: format(MSG, enum: enum_name_value(key))) do |corrector|
+            # TODO: Multi-line autocorrect could be implemented in the future.
+            next if multiple_enum_definitions?(node)
+
+            preferred_syntax = "enum #{enum_name(key)}, #{values.source}#{correct_options(options)}"
+
+            corrector.replace(node, preferred_syntax)
+          end
+        end
+
+        def multiple_enum_definitions?(node)
+          keys = node.first_argument.keys.map { |key| key.source.delete_prefix('_') }
+          filterred_keys = keys.filter { |key| !OPTION_NAMES.include?(key) }
+          filterred_keys.size >= 2
+        end
+
+        def enum_name_value(key)
+          case key.type
+          when :sym, :str
+            key.value
+          else
+            key.source
+          end
+        end
+
+        def enum_name(elem)
+          case elem.type
+          when :str
+            elem.value.dump
+          when :sym
+            elem.value.inspect
+          else
+            elem.source
+          end
+        end
+
+        def option_key?(pair)
+          return false unless pair.respond_to?(:key)
+
+          UNDERSCORED_OPTION_NAMES.include?(pair.key.source)
+        end
+
+        def correct_options(options)
+          corrected_options = options.map do |pair|
+            name = if pair.key.source[0] == '_'
+                     pair.key.source[1..]
+                   else
+                     pair.key.source
+                   end
+
+            "#{name}: #{pair.value.source}"
+          end.join(', ')
+
+          ", #{corrected_options}" unless corrected_options.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,18 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   enum :status, { active: 0, archived: 0 }
+      #
+      #   # good
+      #   enum :status, { active: 0, archived: 1 }
+      #
+      #   # bad
+      #   enum :status, [:active, :archived, :active]
+      #
+      #   # good
+      #   enum :status, [:active, :archived]
+      #
+      #   # bad
       #   enum status: { active: 0, archived: 0 }
       #
       #   # good
@@ -24,6 +36,10 @@ module RuboCop
         RESTRICT_ON_SEND = %i[enum].freeze
 
         def_node_matcher :enum?, <<~PATTERN
+          (send nil? :enum $_ ${array hash} ...)
+        PATTERN
+
+        def_node_matcher :enum_with_old_syntax?, <<~PATTERN
           (send nil? :enum (hash $...))
         PATTERN
 
@@ -32,15 +48,17 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          enum?(node) do |pairs|
+          enum?(node) do |key, args|
+            consecutive_duplicates(args.values).each do |item|
+              add_offense(item, message: message(key, item))
+            end
+          end
+
+          enum_with_old_syntax?(node) do |pairs|
             pairs.each do |pair|
               enum_values(pair) do |key, args|
-                items = args.values
-
-                next unless duplicates?(items)
-
-                consecutive_duplicates(items).each do |item|
-                  add_offense(item, message: format(MSG, value: item.source, enum: enum_name(key)))
+                consecutive_duplicates(args.values).each do |item|
+                  add_offense(item, message: message(key, item))
                 end
               end
             end
@@ -57,6 +75,10 @@ module RuboCop
             key.source
           end
         end
+
+        def message(key, item)
+          format(MSG, value: item.source, enum: enum_name(key))
+        end
       end
     end
   end

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

@@ -19,20 +19,33 @@ module RuboCop
         extend TargetRailsVersion
 
         MSG = 'Use `Rails.env.local?` instead.'
+        MSG_NEGATED = 'Use `!Rails.env.local?` instead.'
         LOCAL_ENVIRONMENTS = %i[development? test?].to_set.freeze
 
         minimum_target_rails_version 7.1
 
-        # @!method rails_env_local_candidate?(node)
-        def_node_matcher :rails_env_local_candidate?, <<~PATTERN
+        # @!method rails_env_local_or?(node)
+        def_node_matcher :rails_env_local_or?, <<~PATTERN
           (or
             (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
             (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
           )
         PATTERN
 
+        # @!method rails_env_local_and?(node)
+        def_node_matcher :rails_env_local_and?, <<~PATTERN
+          (and
+            (send
+              (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
+              :!)
+            (send
+              (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
+              :!)
+          )
+        PATTERN
+
         def on_or(node)
-          rails_env_local_candidate?(node) do |*environments|
+          rails_env_local_or?(node) do |*environments|
             next unless environments.to_set == LOCAL_ENVIRONMENTS
 
             add_offense(node) do |corrector|
@@ -40,6 +53,16 @@ module RuboCop
             end
           end
         end
+
+        def on_and(node)
+          rails_env_local_and?(node) do |*environments|
+            next unless environments.to_set == LOCAL_ENVIRONMENTS
+
+            add_offense(node, message: MSG_NEGATED) do |corrector|
+              corrector.replace(node, '!Rails.env.local?')
+            end
+          end
+        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,10 +100,10 @@ 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)
+            autocorrect_file_join(corrector, node) unless node.first_argument.array_type?
           end
         end
 
@@ -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)

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

@@ -52,7 +52,7 @@ module RuboCop
           (send
             nil?
             {#{FILTERS.join(' ')}}
-            _
+            ...
             $_)
         PATTERN
 

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

@@ -29,18 +29,34 @@ module RuboCop
         PATTERN
 
         def_node_matcher :on_bad_to_h, <<~PATTERN
-          (block
-            (call _ :to_h)
-            (args (arg $_el))
-            (array $_ (lvar _el)))
+          {
+            (block
+              (call _ :to_h)
+              (args (arg $_el))
+              (array $_ (lvar _el)))
+            (numblock
+              (call _ :to_h) $1
+              (array $_ (lvar :_1)))
+            (itblock
+              (call _ :to_h) $:it
+              (array $_ (lvar :it)))
+          }
         PATTERN
 
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array $_ (lvar _el)))
+            {
+              (block
+                (call _ {:map :collect})
+                (args (arg $_el))
+                (array $_ (lvar _el)))
+              (numblock
+                (call _ {:map :collect}) $1
+                (array $_ (lvar :_1)))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array $_ (lvar :it)))
+            }
             :to_h)
         PATTERN
 
@@ -48,10 +64,19 @@ module RuboCop
           (send
             (const {nil? cbase} :Hash)
             :[]
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array $_ (lvar _el))))
+            {
+              (block
+                (call _ {:map :collect})
+                (args (arg $_el))
+                (array $_ (lvar _el)))
+              (numblock
+                (call _ {:map :collect}) $1
+                (array $_ (lvar :_1)))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array $_ (lvar :it)))
+            }
+          )
         PATTERN
 
         private

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

@@ -32,18 +32,34 @@ module RuboCop
         PATTERN
 
         def_node_matcher :on_bad_to_h, <<~PATTERN
-          (block
-            (call _ :to_h)
-            (args (arg $_el))
-            (array (lvar _el) $_))
+          {
+            (block
+              (call _ :to_h)
+              (args (arg $_el))
+              (array (lvar _el) $_))
+            (numblock
+              (call _ :to_h) $1
+              (array (lvar :_1) $_))
+            (itblock
+              (call _ :to_h) $:it
+              (array (lvar :it) $_))
+          }
         PATTERN
 
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array (lvar _el) $_))
+            {
+              (block
+                (call _ {:map :collect})
+                (args (arg $_el))
+                (array (lvar _el) $_))
+              (numblock
+                (call _ {:map :collect}) $1
+                (array (lvar :_1) $_))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array (lvar :it) $_))
+            }
             :to_h)
         PATTERN
 
@@ -51,10 +67,19 @@ module RuboCop
           (send
             (const {nil? cbase} :Hash)
             :[]
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array (lvar _el) $_)))
+            {
+              (block
+                (call _ {:map :collect})
+                (args (arg $_el))
+                (array (lvar _el) $_))
+              (numblock
+                (call _ {:map :collect}) $1
+                (array (lvar :_1) $_))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array (lvar :it) $_))
+            }
+          )
         PATTERN
 
         private

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

@@ -29,7 +29,7 @@ module RuboCop
         def on_send(node)
           return unless node.arguments.empty?
           return unless (receiver = node.receiver)
-          return if !receiver.str_type? && !receiver.array_type?
+          return unless receiver.type?(:str, :array)
 
           add_offense(node.loc.selector)
         end

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

@@ -115,6 +115,10 @@ module RuboCop
                 $_)))
         PATTERN
 
+        def_node_matcher :delegated_methods, <<~PATTERN
+          (send nil? :delegate (sym $_)+ (hash <(pair (sym :to) _) ...>))
+        PATTERN
+
         def on_send(node)
           methods_node = only_or_except_filter_methods(node)
           return unless methods_node
@@ -139,7 +143,13 @@ module RuboCop
           return [] unless block
 
           defined_methods = block.each_child_node(:def).map(&:method_name)
-          defined_methods + aliased_action_methods(block, defined_methods)
+          defined_methods + delegated_action_methods(block) + aliased_action_methods(block, defined_methods)
+        end
+
+        def delegated_action_methods(node)
+          node.each_child_node(:send).flat_map do |child_node|
+            delegated_methods(child_node) || []
+          end
         end
 
         def aliased_action_methods(node, defined_methods)

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

@@ -21,11 +21,11 @@ module RuboCop
       #   match 'photos/:id', to: 'photos#show', via: :all
       #
       class MatchRoute < Base
+        include RoutesHelper
         extend AutoCorrector
 
         MSG = 'Use `%<http_method>s` instead of `match` to define a route.'
         RESTRICT_ON_SEND = %i[match].freeze
-        HTTP_METHODS = %i[get post put patch delete].freeze
 
         def_node_matcher :match_method_call?, <<~PATTERN
           (send nil? :match $_ $(hash ...) ?)
@@ -60,14 +60,6 @@ module RuboCop
           end
         end
 
-        def_node_matcher :routes_draw?, <<~PATTERN
-          (send (send _ :routes) :draw)
-        PATTERN
-
-        def within_routes?(node)
-          node.each_ancestor(:block).any? { |a| routes_draw?(a.send_node) }
-        end
-
         def extract_via(node)
           via_pair = via_pair(node)
           return %i[get] unless via_pair

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for mapping a route with multiple paths, which is deprecated and will be removed in Rails 8.1.
+      #
+      # @example
+      #
+      #   # bad
+      #   get '/users', '/other_path', to: 'users#index'
+      #
+      #   # good
+      #   get '/users', to: 'users#index'
+      #   get '/other_path', to: 'users#index'
+      #
+      class MultipleRoutePaths < Base
+        include RoutesHelper
+        extend AutoCorrector
+
+        MSG = 'Use separate routes instead of combining multiple route paths in a single route.'
+        RESTRICT_ON_SEND = HTTP_METHODS
+
+        IGNORED_ARGUMENT_TYPES = %i[array hash].freeze
+
+        def on_send(node)
+          return unless within_routes?(node)
+
+          route_paths = node.arguments.reject { |argument| IGNORED_ARGUMENT_TYPES.include?(argument.type) }
+          return if route_paths.count < 2
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, migrate_to_multiple_routes(node, route_paths))
+          end
+        end
+
+        private
+
+        def migrate_to_multiple_routes(node, route_paths)
+          rest = route_paths.last.source_range.end.join(node.source_range.end).source
+          indentation = ' ' * node.source_range.column
+
+          route_paths.map do |route_path|
+            "#{node.method_name} #{route_path.source}#{rest}"
+          end.join("\n#{indentation}")
+        end
+      end
+    end
+  end
+end