Inspect inline style for FactoryBot/AssociationStyle

Author: r7kamura

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Master (Unreleased)
 
 - Add autocorrect for `FactoryBot/FactoryAssociationWithStrategy` cop. ([@r7kamura])
+- Inspect inline style for `FactoryBot/AssociationStyle`. ([@r7kamura])
 
 ## 2.28.0 (2025-11-12)
 

docs/modules/ROOT/pages/cops_factorybot.adoc

@@ -55,6 +55,21 @@ end
 factory :post do
   user factory: %i[user author]
 end
+
+# bad
+factory :post do
+  user { association :user }
+end
+
+# good
+factory :post do
+  user
+end
+
+# good (NonImplicitAssociationMethodNames: ['foo'])
+factory :post do
+  foo { association :foo }
+end
 ----
 
 [#_enforcedstyle_-explicit_-factorybotassociationstyle]
@@ -82,6 +97,16 @@ factory :post do
   association :user, :author
 end
 
+# bad
+factory :post do
+  user { association :user }
+end
+
+# good
+factory :post do
+  association :user
+end
+
 # good (NonImplicitAssociationMethodNames: ['email'])
 sequence :email do |n|
   "person#{n}@example.com"

lib/rubocop/cop/factory_bot/association_style.rb

@@ -31,6 +31,21 @@ module FactoryBot
       #     user factory: %i[user author]
       #   end
       #
+      #   # bad
+      #   factory :post do
+      #     user { association :user }
+      #   end
+      #
+      #   # good
+      #   factory :post do
+      #     user
+      #   end
+      #
+      #   # good (NonImplicitAssociationMethodNames: ['foo'])
+      #   factory :post do
+      #     foo { association :foo }
+      #   end
+      #
       # @example `EnforcedStyle: explicit`
       #   # bad
       #   factory :post do
@@ -52,6 +67,16 @@ module FactoryBot
       #     association :user, :author
       #   end
       #
+      #   # bad
+      #   factory :post do
+      #     user { association :user }
+      #   end
+      #
+      #   # good
+      #   factory :post do
+      #     association :user
+      #   end
+      #
       #   # good (NonImplicitAssociationMethodNames: ['email'])
       #   sequence :email do |n|
       #     "person#{n}@example.com"
@@ -66,19 +91,22 @@ class AssociationStyle < ::RuboCop::Cop::Base # rubocop:disable Metrics/ClassLen
         include ConfigurableEnforcedStyle
 
         RESTRICT_ON_SEND = %i[factory trait].freeze
+
         KEYWORDS = %i[alias and begin break case class def defined? do
                       else elsif end ensure false for if in module
                       next nil not or redo rescue retry return self
                       super then true undef unless until when while
-                      yield __FILE__ __LINE__ __ENCODING__].freeze
+                      yield __FILE__ __LINE__ __ENCODING__].to_set.freeze
 
         def on_send(node)
-          bad_associations_in(node).each do |association|
+          body_nodes_from(node).each do |maybe_association|
+            next unless correctable_to_enforced_style?(maybe_association)
+
             add_offense(
-              association,
+              maybe_association,
               message: "Use #{style} style to define associations."
             ) do |corrector|
-              autocorrect(corrector, association)
+              autocorrect(corrector, maybe_association)
             end
           end
         end
@@ -90,110 +118,118 @@ def on_send(node)
           (send nil? :association sym ...)
         PATTERN
 
-        # @!method with_strategy_build_option?(node)
-        def_node_matcher :with_strategy_build_option?, <<~PATTERN
-          (send nil? :association sym ...
-            (hash <(pair (sym :strategy) (sym :build)) ...>)
-          )
+        # @!method with_strategy_option?(node)
+        def_node_matcher :with_strategy_option?, <<~PATTERN
+          (send nil? ... (hash <(pair (sym :strategy) _) ...>))
         PATTERN
 
-        # @!method implicit_association?(node)
-        def_node_matcher :implicit_association?, <<~PATTERN
-          (send nil? !#non_implicit_association_method_name? ...)
+        # @!method receiverless_method_call?(node)
+        def_node_matcher :receiverless_method_call?, <<~PATTERN
+          (send nil? ...)
         PATTERN
 
         # @!method factory_option_matcher(node)
         def_node_matcher :factory_option_matcher, <<~PATTERN
-          (send
-            nil?
-            :association
-            ...
-            (hash
-              <
-                (pair
-                  (sym :factory)
-                  {
-                    (sym $_) |
-                    (array (sym $_)*)
-                  }
-                )
-                ...
-              >
-            )
-          )
+          (send nil? ... (hash <(pair (sym :factory) {(sym $_) (array (sym $_)*)}) ...>))
         PATTERN
 
         # @!method trait_names_from_explicit(node)
         def_node_matcher :trait_names_from_explicit, <<~PATTERN
           (send nil? :association _ (sym $_)* ...)
         PATTERN
 
-        # @!method association_names(node)
-        def_node_search :association_names, <<~PATTERN
-          (send nil? :association $...)
+        # @!method search_defined_trait_names_in(node)
+        def_node_search :search_defined_trait_names_in, <<~PATTERN
+          (send nil? :trait (sym $_) )
+        PATTERN
+
+        # @!method factory_definition_node?(node)
+        def_node_matcher :factory_definition_node?, <<~PATTERN
+          (block (send nil? :factory ...) ...)
         PATTERN
 
-        # @!method trait_name(node)
-        def_node_search :trait_name, <<~PATTERN
-          (send nil? :trait (sym $_) )
+        # @!method inline_associationish?(node)
+        def_node_matcher :inline_associationish?, <<~PATTERN
+          (block
+            (send nil? _)
+            (args)
+            (send nil? :association ...)
+          )
         PATTERN
 
-        def autocorrect(corrector, node)
-          if style == :explicit
-            autocorrect_to_explicit_style(corrector, node)
-          else
-            autocorrect_to_implicit_style(corrector, node)
+        def correctable_to_enforced_style?(node)
+          case style
+          when :explicit
+            correctable_to_explicit_style?(node)
+          when :implicit
+            correctable_to_implicit_style?(node)
           end
         end
 
-        def autocorrect_to_explicit_style(corrector, node)
-          arguments = [
-            ":#{node.method_name}",
-            *node.arguments.map(&:source)
-          ]
-          corrector.replace(node, "association #{arguments.join(', ')}")
+        def correctable_to_explicit_style?(node)
+          if explicit_association?(node)
+            false
+          elsif implicit_association?(node)
+            true
+          elsif inline_association?(node)
+            true
+          end
         end
 
-        def autocorrect_to_implicit_style(corrector, node)
-          source = node.first_argument.value.to_s
-          options = options_for_autocorrect_to_implicit_style(node)
-          unless options.empty?
-            rest = options.map { |option| option.join(': ') }.join(', ')
-            source += " #{rest}"
+        def correctable_to_implicit_style?(node)
+          if explicit_association?(node)
+            !with_strategy_option?(node) &&
+              !keyword_explicit_association_name?(node)
+          elsif implicit_association?(node)
+            false
+          elsif inline_association?(node)
+            !with_strategy_option?(node.body)
           end
-          corrector.replace(node, source)
         end
 
-        def bad?(node)
-          if style == :explicit
-            implicit_association?(node) &&
-              (factory_node = trait_factory_node(node)) && !trait_within_trait?(
-                node, factory_node
-              )
-          else
-            explicit_association?(node) &&
-              !with_strategy_build_option?(node) &&
-              !keyword?(node)
-          end
+        def inline_association?(node)
+          inline_associationish?(node) &&
+            implicit_association_method?(node)
         end
 
-        def keyword?(node)
-          association_names(node).any? do |associations|
-            associations.any? do |association|
-              next unless association.sym_type?
+        def implicit_association?(node)
+          receiverless_method_call?(node) &&
+            implicit_association_method?(node)
+        end
 
-              KEYWORDS.include?(association.value)
-            end
-          end
+        def implicit_association_method?(node)
+          !non_implicit_association_method_names_for(node)
+            .include?(node.method_name)
         end
 
-        def bad_associations_in(node)
-          children_of_factory_block(node).select do |child|
-            bad?(child)
+        def non_implicit_association_method_names_for(node)
+          RuboCop::FactoryBot.reserved_methods +
+            configured_non_implicit_association_method_names +
+            search_defined_trait_names_in_same_factory(node)
+        end
+
+        def configured_non_implicit_association_method_names
+          (cop_config['NonImplicitAssociationMethodNames'] || []).map(&:to_sym)
+        end
+
+        def search_defined_trait_names_in_same_factory(node)
+          factory_definition_node = find_factory_definition_node_from(node)
+          return [] unless factory_definition_node
+
+          search_defined_trait_names_in(factory_definition_node).to_a
+        end
+
+        def find_factory_definition_node_from(node)
+          node.ancestors.reverse.find do |ancestor|
+            factory_definition_node?(ancestor)
           end
         end
 
-        def children_of_factory_block(node)
+        def keyword_explicit_association_name?(node)
+          KEYWORDS.include?(node.first_argument.value)
+        end
+
+        def body_nodes_from(node)
           block = node.block_node
           return [] unless block
           return [] unless block.body
@@ -219,9 +255,69 @@ def non_implicit_association_method_name?(method_name)
           non_implicit_association_method_names.include?(method_name.to_s)
         end
 
-        def non_implicit_association_method_names
-          RuboCop::FactoryBot.reserved_methods.map(&:to_s) +
-            (cop_config['NonImplicitAssociationMethodNames'] || [])
+        def autocorrect(corrector, node)
+          case style
+          when :explicit
+            autocorrect_to_explicit_style(corrector, node)
+          when :implicit
+            autocorrect_to_implicit_style(corrector, node)
+          end
+        end
+
+        def autocorrect_to_explicit_style(corrector, node)
+          if implicit_association?(node)
+            autocorrect_from_implicit_to_explicit_style(corrector, node)
+          else
+            autocorrect_from_inline_to_explicit_style(corrector, node)
+          end
+        end
+
+        def autocorrect_to_implicit_style(corrector, node)
+          if explicit_association?(node)
+            autocorrect_from_explicit_to_implicit_style(corrector, node)
+          else
+            autocorrect_from_inline_to_implicit_style(corrector, node)
+          end
+        end
+
+        def autocorrect_from_explicit_to_implicit_style(corrector, node)
+          source = node.first_argument.value.to_s
+          options = options_for_autocorrect_to_implicit_style(node)
+          unless options.empty?
+            rest = options.map { |option| option.join(': ') }.join(', ')
+            source += " #{rest}"
+          end
+          corrector.replace(node, source)
+        end
+
+        def autocorrect_from_implicit_to_explicit_style(corrector, node)
+          arguments = [
+            ":#{node.method_name}",
+            *node.arguments.map(&:source)
+          ]
+          corrector.replace(node, "association #{arguments.join(', ')}")
+        end
+
+        def autocorrect_from_inline_to_explicit_style(corrector, node)
+          return unless autocorrectable_inline_association?(node)
+
+          corrector.replace(
+            node,
+            format(
+              'association %<association_name>s, factory: [%<factory_name>s]',
+              association_name: node.method_name.inspect,
+              factory_name: node.body.first_argument.source
+            )
+          )
+        end
+
+        # Autocorrect to implicit style with the next trial.
+        alias autocorrect_from_inline_to_implicit_style \
+          autocorrect_from_inline_to_explicit_style
+
+        # Parsing of options is too complex, so it is not currently supported.
+        def autocorrectable_inline_association?(node)
+          node.body.arguments.size == 1
         end
 
         def options_from_explicit(node)
@@ -240,16 +336,6 @@ def options_for_autocorrect_to_implicit_style(node)
           end
           options
         end
-
-        def trait_within_trait?(node, factory_node)
-          trait_name(factory_node).include?(node.method_name)
-        end
-
-        def trait_factory_node(node)
-          node.ancestors.reverse.find do |ancestor|
-            ancestor.method?(:factory) if ancestor.block_type?
-          end
-        end
       end
     end
   end