rubocop-factory_bot 2.22.0 → 2.23.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44482485fe839223a23464d6739cbd0160ebaffa5402c9057d2fdc0e3c9b3295
-  data.tar.gz: 035ac59bb998b1268bf0803bce35b9c2ab75ac6f232a427e28996f0ea857f386
+  metadata.gz: 5d8a45a48d47318e9e16e7b3bbde99ae9dcf94f6e90c068f0916ff2945511e85
+  data.tar.gz: 52ff0ffe8fb20bc0ed3ec4dca29aa13a29b106e39f7bacac370388f0c789bf1c
 SHA512:
-  metadata.gz: fd92b4d37f8a352e1acc98ae2bbbad05982248d3ef97dfb6b99edfe5173ba087a4259db3718e1e05c0b7951574652b657b694d2f02a5c34cf162d17fe427303a
-  data.tar.gz: 10cf9b7446c6fbd09a2ffcfe8629be12c2dc334132d6515acd8015b0f22a7e06e01d704f42316730e096901889f189adcaff8730571df86e401e7767688c07f3
+  metadata.gz: 53082b6baa7e6ebe69f3ebcc1404f2c8421bfcd3ee6905eba12789faca59c1c090b84abc4696a0773598ab06eb97e8aa2b70384864376b58e568d9eef5ce2549
+  data.tar.gz: 26f1817b168218b61f7657400f777ec5eb972cedab14501b2f6a5b1bd8691af9b4c3b04607969923eb58ffca49e4070622040950a7d00742624d4d5b03cf9ee1

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Master (Unreleased)
 
+## 2.23.1 (2023-05-15)
+
+- Fix `FactoryBot/AssociationStyle` cop for a blockless `factory`. ([@pirj])
+
+## 2.23.0 (2023-05-15)
+
+- Add `FactoryBot/FactoryAssociationWithStrategy` cop. ([@morissetcl])
+- Mark `FactoryBot/CreateList` as `SafeAutoCorrect: false`. ([@r7kamura])
+- Change `FactoryBot/CreateList` so that it considers `times.map`. ([@r7kamura])
+- Add `FactoryBot/RedundantFactoryOption` cop. ([@r7kamura])
+- Add `ExplicitOnly` configuration option to `FactoryBot/ConsistentParenthesesStyle`, `FactoryBot/CreateList` and `FactoryBot/FactoryNameStyle`. ([@ydah])
+- Change `FactoryBot/CreateList` so that it checks same factory calls in an Array. ([@r7kamura])
+- Add `FactoryBot/AssociationStyle` cop. ([@r7kamura])
+
 ## 2.22.0 (2023-05-04)
 
 - Extracted from `rubocop-rspec` into a separate repository for easier use with Minitest/Cucumber. ([@ydah])
@@ -57,6 +71,7 @@
 [@jonatas]: https://github.com/jonatas
 [@leoarnold]: https://github.com/leoarnold
 [@liberatys]: https://github.com/Liberatys
+[@morissetcl]: https://github.com/morissetcl
 [@ngouy]: https://github.com/ngouy
 [@pirj]: https://github.com/pirj
 [@r7kamura]: https://github.com/r7kamura

data/README.md

@@ -4,7 +4,7 @@
 [![Gem Version](https://badge.fury.io/rb/rubocop-factory_bot.svg)](https://rubygems.org/gems/rubocop-factory_bot)
 ![CI](https://github.com/rubocop/rubocop-factory_bot/workflows/CI/badge.svg)
 
-[Factory Bot](https://www.rubydoc.info/gems/factory_bot)-specific analysis for your projects, as an extension to
+[factory_bot](https://github.com/thoughtbot/factory_bot/blob/main/GETTING_STARTED.md)-specific analysis for your projects, as an extension to
 [RuboCop](https://github.com/rubocop/rubocop).
 
 ## Installation
@@ -17,13 +17,13 @@ gem install rubocop-factory_bot
 
 or if you use bundler put this in your `Gemfile`
 
-```
+```ruby
 gem 'rubocop-factory_bot', require: false
 ```
 
 ## Usage
 
-You need to tell RuboCop to load the Factory Bot extension. There are three
+You need to tell RuboCop to load the factory_bot extension. There are three
 ways to do this:
 
 ### RuboCop configuration file
@@ -69,7 +69,7 @@ All cops are located under
 [`lib/rubocop/cop/factory_bot`](lib/rubocop/cop/factory_bot), and contain
 examples/documentation.
 
-In your `.rubocop.yml`, you may treat the Factory Bot cops just like any other
+In your `.rubocop.yml`, you may treat the factory_bot cops just like any other
 cop. For example:
 
 ```yaml

data/config/default.yml

@@ -8,6 +8,22 @@ FactoryBot:
     - "**/features/support/factories/**/*.rb"
   DocumentationBaseURL: https://docs.rubocop.org/rubocop-factory_bot
 
+FactoryBot/AssociationStyle:
+  Description: Use a consistent style to define associations.
+  Enabled: pending
+  Safe: false
+  Include:
+    - spec/factories.rb
+    - spec/factories/**/*.rb
+    - features/support/factories/**/*.rb
+  VersionAdded: '2.23'
+  EnforcedStyle: implicit
+  SupportedStyles:
+    - explicit
+    - implicit
+  NonImplicitAssociationMethodNames: ~
+  Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/AssociationStyle
+
 FactoryBot/AttributeDefinedStatically:
   Description: Always declare attribute values as blocks.
   Enabled: true
@@ -20,13 +36,15 @@ FactoryBot/AttributeDefinedStatically:
   Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/AttributeDefinedStatically
 
 FactoryBot/ConsistentParenthesesStyle:
-  Description: Use a consistent style for parentheses in factory bot calls.
+  Description: Use a consistent style for parentheses in factory_bot calls.
   Enabled: pending
   EnforcedStyle: require_parentheses
   SupportedStyles:
     - require_parentheses
     - omit_parentheses
+  ExplicitOnly: false
   VersionAdded: '2.14'
+  VersionChanged: '2.23'
   Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/ConsistentParenthesesStyle
 
 FactoryBot/CreateList:
@@ -42,10 +60,19 @@ FactoryBot/CreateList:
   SupportedStyles:
     - create_list
     - n_times
+  ExplicitOnly: false
+  SafeAutoCorrect: false
   VersionAdded: '1.25'
-  VersionChanged: '2.0'
+  VersionChanged: '2.23'
   Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/CreateList
 
+FactoryBot/FactoryAssociationWithStrategy:
+  Description: Use definition in factory association instead of hard coding a strategy.
+  Enabled: pending
+  VersionAdded: '2.23'
+  VersionChanged: '2.23'
+  Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/FactoryAssociationWithStrategy
+
 FactoryBot/FactoryClassName:
   Description: Use string value when setting the class attribute explicitly.
   Enabled: true
@@ -60,13 +87,21 @@ FactoryBot/FactoryClassName:
 FactoryBot/FactoryNameStyle:
   Description: Checks for name style for argument of FactoryBot::Syntax::Methods.
   Enabled: pending
-  VersionAdded: '2.16'
   EnforcedStyle: symbol
   SupportedStyles:
     - symbol
     - string
+  ExplicitOnly: false
+  VersionAdded: '2.16'
+  VersionChanged: '2.23'
   Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/FactoryNameStyle
 
+FactoryBot/RedundantFactoryOption:
+  Description: Checks for redundant `factory` option.
+  Enabled: pending
+  VersionAdded: '2.23'
+  Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/RedundantFactoryOption
+
 FactoryBot/SyntaxMethods:
   Description: Use shorthands from `FactoryBot::Syntax::Methods` in your specs.
   Enabled: pending

data/lib/rubocop/cop/factory_bot/association_style.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module FactoryBot
+      # Use a consistent style to define associations.
+      #
+      # @safety
+      #   This cop may cause false-positives in `EnforcedStyle: explicit`
+      #   case. It recognizes any method call that has no arguments as an
+      #   implicit association but it might be a user-defined trait call.
+      #
+      # @example EnforcedStyle: implicit (default)
+      #   # bad
+      #   factory :post do
+      #     association :user
+      #   end
+      #
+      #   # good
+      #   factory :post do
+      #     user
+      #   end
+      #
+      # @example EnforcedStyle: explicit
+      #   # bad
+      #   factory :post do
+      #     user
+      #   end
+      #
+      #   # good
+      #   factory :post do
+      #     association :user
+      #   end
+      #
+      #   # good (NonImplicitAssociationMethodNames: ['email'])
+      #   sequence :email do |n|
+      #     "person#{n}@example.com"
+      #   end
+      #
+      #   factory :user do
+      #     email
+      #   end
+      class AssociationStyle < ::RuboCop::Cop::Base # rubocop:disable Metrics/ClassLength
+        extend AutoCorrector
+
+        include ConfigurableEnforcedStyle
+
+        DEFAULT_NON_IMPLICIT_ASSOCIATION_METHOD_NAMES = %w[
+          association
+          sequence
+          skip_create
+          traits_for_enum
+        ].freeze
+
+        RESTRICT_ON_SEND = %i[factory trait].freeze
+
+        def on_send(node)
+          bad_associations_in(node).each do |association|
+            add_offense(
+              association,
+              message: "Use #{style} style to define associations."
+            ) do |corrector|
+              autocorrect(corrector, association)
+            end
+          end
+        end
+
+        private
+
+        # @!method explicit_association?(node)
+        def_node_matcher :explicit_association?, <<~PATTERN
+          (send nil? :association sym ...)
+        PATTERN
+
+        # @!method implicit_association?(node)
+        def_node_matcher :implicit_association?, <<~PATTERN
+          (send nil? !#non_implicit_association_method_name? ...)
+        PATTERN
+
+        # @!method factory_option_matcher(node)
+        def_node_matcher :factory_option_matcher, <<~PATTERN
+          (send
+            nil?
+            :association
+            ...
+            (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
+
+        def autocorrect(corrector, node)
+          if style == :explicit
+            autocorrect_to_explicit_style(corrector, node)
+          else
+            autocorrect_to_implicit_style(corrector, node)
+          end
+        end
+
+        def autocorrect_to_explicit_style(corrector, node)
+          arguments = [
+            ":#{node.method_name}",
+            *node.arguments.map(&:source)
+          ]
+          corrector.replace(node, "association #{arguments.join(', ')}")
+        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}"
+          end
+          corrector.replace(node, source)
+        end
+
+        def bad?(node)
+          if style == :explicit
+            implicit_association?(node)
+          else
+            explicit_association?(node)
+          end
+        end
+
+        def bad_associations_in(node)
+          children_of_factory_block(node).select do |child|
+            bad?(child)
+          end
+        end
+
+        def children_of_factory_block(node)
+          block = node.block_node
+          return [] unless block
+          return [] unless block.body
+
+          if block.body.begin_type?
+            block.body.children
+          else
+            [block.body]
+          end
+        end
+
+        def factory_names_from_explicit(node)
+          trait_names = trait_names_from_explicit(node)
+          factory_names = Array(factory_option_matcher(node))
+          result = factory_names + trait_names
+          if factory_names.empty? && !trait_names.empty?
+            result.prepend(node.first_argument.value)
+          end
+          result
+        end
+
+        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
+          DEFAULT_NON_IMPLICIT_ASSOCIATION_METHOD_NAMES +
+            (cop_config['NonImplicitAssociationMethodNames'] || [])
+        end
+
+        def options_from_explicit(node)
+          return {} unless node.last_argument.hash_type?
+
+          node.last_argument.pairs.inject({}) do |options, pair|
+            options.merge(pair.key.value => pair.value.source)
+          end
+        end
+
+        def options_for_autocorrect_to_implicit_style(node)
+          options = options_from_explicit(node)
+          factory_names = factory_names_from_explicit(node)
+          unless factory_names.empty?
+            options[:factory] = "%i[#{factory_names.join(' ')}]"
+          end
+          options
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/factory_bot/attribute_defined_statically.rb

@@ -30,13 +30,13 @@ module RuboCop
         MSG = 'Use a block to declare attribute values.'
 
         # @!method value_matcher(node)
-        def_node_matcher :value_matcher, <<-PATTERN
-            (send _ !#reserved_method? $...)
+        def_node_matcher :value_matcher, <<~PATTERN
+          (send _ !#reserved_method? $...)
         PATTERN
 
         # @!method factory_attributes(node)
-        def_node_matcher :factory_attributes, <<-PATTERN
-            (block (send _ #attribute_defining_method? ...) _ { (begin $...) $(send ...) } )
+        def_node_matcher :factory_attributes, <<~PATTERN
+          (block (send _ #attribute_defining_method? ...) _ { (begin $...) $(send ...) } )
         PATTERN
 
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler

data/lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb

@@ -3,31 +3,27 @@
 module RuboCop
   module Cop
     module FactoryBot
-      # Use a consistent style for parentheses in factory bot calls.
+      # Use a consistent style for parentheses in factory_bot calls.
       #
-      # @example
+      # @example `EnforcedStyle: require_parentheses` (default)
       #
       #   # bad
       #   create :user
-      #   build(:user)
-      #   create(:login)
-      #   create :login
-      #
-      # @example `EnforcedStyle: require_parentheses` (default)
+      #   build :login
       #
       #   # good
       #   create(:user)
-      #   create(:user)
-      #   create(:login)
       #   build(:login)
       #
       # @example `EnforcedStyle: omit_parentheses`
       #
+      #   # bad
+      #   create(:user)
+      #   build(:login)
+      #
       #   # good
       #   create :user
-      #   build :user
-      #   create :login
-      #   create :login
+      #   build :login
       #
       #   # also good
       #   # when method name and first argument are not on same line
@@ -39,49 +35,67 @@ module RuboCop
       #     name: 'foo'
       #   )
       #
+      # @example `ExplicitOnly: false` (default)
+      #
+      #   # bad - with `EnforcedStyle: require_parentheses`
+      #   FactoryBot.create :user
+      #   build :user
+      #
+      #   # good - with `EnforcedStyle: require_parentheses`
+      #   FactoryBot.create(:user)
+      #   build(:user)
+      #
+      # @example `ExplicitOnly: true`
+      #
+      #   # bad - with `EnforcedStyle: require_parentheses`
+      #   FactoryBot.create :user
+      #   FactoryBot.build :user
+      #
+      #   # good - with `EnforcedStyle: require_parentheses`
+      #   FactoryBot.create(:user)
+      #   FactoryBot.build(:user)
+      #   create :user
+      #   build :user
+      #
       class ConsistentParenthesesStyle < ::RuboCop::Cop::Base
         extend AutoCorrector
         include ConfigurableEnforcedStyle
-        include RuboCop::FactoryBot::Language
-        include RuboCop::Cop::Util
-
-        def self.autocorrect_incompatible_with
-          [Style::MethodCallWithArgsParentheses]
-        end
+        include ConfigurableExplicitOnly
 
         MSG_REQUIRE_PARENS = 'Prefer method call with parentheses'
         MSG_OMIT_PARENS = 'Prefer method call without parentheses'
-
         FACTORY_CALLS = RuboCop::FactoryBot::Language::METHODS
-
         RESTRICT_ON_SEND = FACTORY_CALLS
 
         # @!method factory_call(node)
-        def_node_matcher :factory_call, <<-PATTERN
-            (send
-              {#factory_bot? nil?} %FACTORY_CALLS
-              {sym str send lvar} _*
-            )
+        def_node_matcher :factory_call, <<~PATTERN
+          (send
+            #factory_call? %FACTORY_CALLS
+            {sym str send lvar} _*
+          )
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return if ambiguous_without_parentheses?(node)
 
-          factory_call(node) do
-            return if node.method?(:generate) && node.arguments.count > 1
-
-            if node.parenthesized?
-              process_with_parentheses(node)
-            else
-              process_without_parentheses(node)
-            end
-          end
+          factory_call(node) { register_offense(node) }
         end
 
         private
 
-        def process_with_parentheses(node)
-          return unless style == :omit_parentheses
+        def register_offense(node)
+          return if node.method?(:generate) && node.arguments.count > 1
+
+          register_offense_with_parentheses(node)
+          register_offense_without_parentheses(node)
+        end
+
+        def register_offense_with_parentheses(node)
+          return if style == :require_parentheses || !node.parenthesized?
           return unless same_line?(node, node.first_argument)
 
           add_offense(node.loc.selector,
@@ -90,8 +104,8 @@ module RuboCop
           end
         end
 
-        def process_without_parentheses(node)
-          return unless style == :require_parentheses
+        def register_offense_without_parentheses(node)
+          return if style == :omit_parentheses || node.parenthesized?
 
           add_offense(node.loc.selector,
                       message: MSG_REQUIRE_PARENS) do |corrector|

data/lib/rubocop/cop/factory_bot/create_list.rb

@@ -7,9 +7,16 @@ module RuboCop
       #
       # This cop can be configured using the `EnforcedStyle` option
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because replacing `n.times` to
+      #   `create_list` changes its returned value.
+      #
       # @example `EnforcedStyle: create_list` (default)
       #   # bad
       #   3.times { create :user }
+      #   3.times.map { create :user }
+      #   [create(:user), create(:user), create(:user)]
+      #   Array.new(3) { create :user }
       #
       #   # good
       #   create_list :user, 3
@@ -26,58 +33,105 @@ module RuboCop
       # @example `EnforcedStyle: n_times`
       #   # bad
       #   create_list :user, 3
+      #   [create(:user), create(:user), create(:user)]
       #
       #   # good
+      #   3.times.map { create :user }
+      #
+      # @example `ExplicitOnly: false` (default)
+      #
+      #   # bad - with `EnforcedStyle: create_list`
+      #   3.times { FactoryBot.create :user }
+      #   3.times { create :user }
+      #
+      #   # good - with `EnforcedStyle: create_list`
+      #   FactoryBot.create_list :user, 3
+      #   create_list :user, 3
+      #
+      # @example `ExplicitOnly: true`
+      #
+      #   # bad - with `EnforcedStyle: create_list`
+      #   3.times { FactoryBot.create :user }
+      #
+      #   # good - with `EnforcedStyle: create_list`
+      #   FactoryBot.create_list :user, 3
+      #   create_list :user, 3
       #   3.times { create :user }
       #
       class CreateList < ::RuboCop::Cop::Base
         extend AutoCorrector
         include ConfigurableEnforcedStyle
         include RuboCop::FactoryBot::Language
+        include ConfigurableExplicitOnly
 
         MSG_CREATE_LIST = 'Prefer create_list.'
-        MSG_N_TIMES = 'Prefer %<number>s.times.'
+        MSG_N_TIMES = 'Prefer %<number>s.times.map.'
         RESTRICT_ON_SEND = %i[create_list].freeze
 
-        # @!method array_new_or_n_times_block?(node)
-        def_node_matcher :array_new_or_n_times_block?, <<-PATTERN
-            (block
-              {
-                (send (const {nil? | cbase} :Array) :new (int _)) |
-                (send (int _) :times)
-              }
-              ...
-            )
+        # @!method repetition_block?(node)
+        def_node_matcher :repetition_block?, <<-PATTERN
+          (block {#array_new? #n_times? #n_times_map?} ...)
+        PATTERN
+
+        # @!method array_new?(node)
+        def_node_matcher :array_new?, <<-PATTERN
+          (send (const {nil? cbase} :Array) :new (int _))
+        PATTERN
+
+        # @!method n_times?(node)
+        def_node_matcher :n_times?, <<-PATTERN
+          (send (int _) :times)
+        PATTERN
+
+        # @!method n_times_map?(node)
+        def_node_matcher :n_times_map?, <<-PATTERN
+          (send #n_times? :map)
         PATTERN
 
         # @!method block_with_arg_and_used?(node)
-        def_node_matcher :block_with_arg_and_used?, <<-PATTERN
-            (block
-              _
-              (args (arg _value))
-              `_value
-            )
+        def_node_matcher :block_with_arg_and_used?, <<~PATTERN
+          (block
+            _
+            (args (arg _value))
+            `_value
+          )
         PATTERN
 
         # @!method arguments_include_method_call?(node)
-        def_node_matcher :arguments_include_method_call?, <<-PATTERN
-            (send ${nil? #factory_bot?} :create (sym $_) `$(send ...))
+        def_node_matcher :arguments_include_method_call?, <<~PATTERN
+          (send #factory_call? :create sym `$(send ...))
         PATTERN
 
         # @!method factory_call(node)
-        def_node_matcher :factory_call, <<-PATTERN
-            (send ${nil? #factory_bot?} :create (sym $_) $...)
+        def_node_matcher :factory_call, <<~PATTERN
+          (send #factory_call? :create sym ...)
         PATTERN
 
         # @!method factory_list_call(node)
-        def_node_matcher :factory_list_call, <<-PATTERN
-            (send {nil? #factory_bot?} :create_list (sym _) (int $_) ...)
+        def_node_matcher :factory_list_call, <<~PATTERN
+          (send #factory_call? :create_list (sym _) (int $_) ...)
         PATTERN
 
+        # @!method factory_calls_in_array?(node)
+        def_node_search :factory_calls_in_array?, <<-PATTERN
+          (array #factory_call+)
+        PATTERN
+
+        def on_array(node)
+          return unless same_factory_calls_in_array?(node)
+
+          add_offense(
+            node,
+            message: preferred_message_for_array(node)
+          ) do |corrector|
+            autocorrect_same_factory_calls_in_array(corrector, node)
+          end
+        end
+
         def on_block(node) # rubocop:todo InternalAffairs/NumblockHandler
           return unless style == :create_list
 
-          return unless array_new_or_n_times_block?(node)
+          return unless repetition_block?(node)
           return if block_with_arg_and_used?(node)
           return unless node.body
           return if arguments_include_method_call?(node.body)
@@ -101,6 +155,20 @@ module RuboCop
 
         private
 
+        # For ease of modification, it is replaced with the `n_times` style,
+        # but if it is not appropriate for the configured style,
+        # it will be replaced in the subsequent autocorrection.
+        def autocorrect_same_factory_calls_in_array(corrector, node)
+          corrector.replace(
+            node,
+            format(
+              '%<count>s.times.map { %<factory_call>s }',
+              count: node.children.count,
+              factory_call: node.children.first.source
+            )
+          )
+        end
+
         def contains_only_factory?(node)
           if node.block_type?
             factory_call(node.send_node)
@@ -109,6 +177,20 @@ module RuboCop
           end
         end
 
+        def preferred_message_for_array(node)
+          if style == :create_list &&
+              !arguments_include_method_call?(node.children.first)
+            MSG_CREATE_LIST
+          else
+            format(MSG_N_TIMES, number: node.children.count)
+          end
+        end
+
+        def same_factory_calls_in_array?(node)
+          factory_calls_in_array?(node) &&
+            node.children.map(&:source).uniq.one?
+        end
+
         # :nodoc
         module Corrector
           private
@@ -159,7 +241,7 @@ module RuboCop
             replacement = format_receiver(node.receiver)
             replacement += format_method_call(node, 'create', arguments)
             replacement += " #{factory_call_block_source}" if node.block_node
-            "#{count.source}.times { #{replacement} }"
+            "#{count.source}.times.map { #{replacement} }"
           end
 
           def factory_call_block_source
@@ -224,10 +306,13 @@ module RuboCop
 
           def count_from(node)
             count_node =
-              if node.receiver.int_type?
-                node.receiver
-              else
+              case node.method_name
+              when :map
+                node.receiver.receiver
+              when :new
                 node.send_node.first_argument
+              when :times
+                node.receiver
               end
             count_node.source
           end

data/lib/rubocop/cop/factory_bot/factory_association_with_strategy.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module FactoryBot
+      # Use definition in factory association instead of hard coding a strategy.
+      #
+      # @example
+      #   # bad - only works for one strategy
+      #   factory :foo do
+      #     profile { create(:profile) }
+      #   end
+      #
+      #   # good - implicit
+      #   factory :foo do
+      #     profile
+      #   end
+      #
+      #   # good - explicit
+      #   factory :foo do
+      #     association :profile
+      #   end
+      #
+      #   # good - inline
+      #   factory :foo do
+      #     profile { association :profile }
+      #   end
+      #
+      class FactoryAssociationWithStrategy < ::RuboCop::Cop::Base
+        MSG = 'Use an implicit, explicit or inline definition instead of ' \
+              'hard coding a strategy for setting association within factory.'
+
+        HARDCODED = Set.new(%i[create build build_stubbed]).freeze
+
+        # @!method factory_declaration(node)
+        def_node_matcher :factory_declaration, <<~PATTERN
+          (block (send nil? {:factory :trait} ...)
+            ...
+          )
+        PATTERN
+
+        # @!method factory_strategy_association(node)
+        def_node_matcher :factory_strategy_association, <<~PATTERN
+          (block
+            (send nil? _association_name)
+            (args)
+            < $(send nil? HARDCODED ...) ... >
+          )
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          factory_declaration(node) do
+            node.each_node do |statement|
+              factory_strategy_association(statement) do |hardcoded_association|
+                add_offense(hardcoded_association)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/factory_bot/factory_name_style.rb

@@ -23,19 +23,42 @@ module RuboCop
       #   create('user')
       #   build "user", username: "NAME"
       #
+      # @example `ExplicitOnly: false` (default)
+      #
+      #   # bad - with `EnforcedStyle: symbol`
+      #   FactoryBot.create('user')
+      #   create('user')
+      #
+      #   # good - with `EnforcedStyle: symbol`
+      #   FactoryBot.create(:user)
+      #   create(:user)
+      #
+      # @example `ExplicitOnly: true`
+      #
+      #   # bad - with `EnforcedStyle: symbol`
+      #   FactoryBot.create(:user)
+      #   FactoryBot.build "user", username: "NAME"
+      #
+      #   # good - with `EnforcedStyle: symbol`
+      #   FactoryBot.create('user')
+      #   FactoryBot.build "user", username: "NAME"
+      #   FactoryBot.create(:user)
+      #   create(:user)
+      #
       class FactoryNameStyle < ::RuboCop::Cop::Base
         extend AutoCorrector
         include ConfigurableEnforcedStyle
         include RuboCop::FactoryBot::Language
+        include ConfigurableExplicitOnly
 
         MSG = 'Use %<prefer>s to refer to a factory.'
         FACTORY_CALLS = RuboCop::FactoryBot::Language::METHODS
         RESTRICT_ON_SEND = FACTORY_CALLS
 
         # @!method factory_call(node)
-        def_node_matcher :factory_call, <<-PATTERN
+        def_node_matcher :factory_call, <<~PATTERN
           (send
-            {#factory_bot? nil?} %FACTORY_CALLS
+            #factory_call? %FACTORY_CALLS
             ${str sym} ...
           )
         PATTERN

data/lib/rubocop/cop/factory_bot/mixin/configurable_explicit_only.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module FactoryBot
+      # Handles `ExplicitOnly` configuration parameters.
+      module ConfigurableExplicitOnly
+        include RuboCop::FactoryBot::Language
+
+        def factory_call?(node)
+          return factory_bot?(node) if explicit_only?
+
+          factory_bot?(node) || node.nil?
+        end
+
+        def explicit_only?
+          cop_config['ExplicitOnly']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/factory_bot/redundant_factory_option.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module FactoryBot
+      # Checks for redundant `factory` option.
+      #
+      # @example
+      #   # bad
+      #   association :user, factory: :user
+      #
+      #   # good
+      #   association :user
+      class RedundantFactoryOption < ::RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include RangeHelp
+
+        MSG = 'Remove redundant `factory` option.'
+
+        RESTRICT_ON_SEND = %i[association].freeze
+
+        # @!method association_with_a_factory_option(node)
+        def_node_matcher :association_with_a_factory_option, <<~PATTERN
+          (send nil? :association
+            (sym $_association_name)
+            ...
+            (hash
+              <$(pair
+                  (sym :factory)
+                  {
+                    (sym $_factory_name)
+                    (array (sym $_factory_name))
+                  }
+                )
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        def on_send(node)
+          association_with_a_factory_option(node) do
+            |association_name, factory_option, factory_name|
+            next if association_name != factory_name
+
+            add_offense(factory_option) do |corrector|
+              autocorrect(corrector, factory_option)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/factory_bot_cops.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require_relative 'factory_bot/association_style'
 require_relative 'factory_bot/attribute_defined_statically'
 require_relative 'factory_bot/consistent_parentheses_style'
 require_relative 'factory_bot/create_list'
+require_relative 'factory_bot/factory_association_with_strategy'
 require_relative 'factory_bot/factory_class_name'
 require_relative 'factory_bot/factory_name_style'
+require_relative 'factory_bot/redundant_factory_option'
 require_relative 'factory_bot/syntax_methods'

data/lib/rubocop/factory_bot/factory_bot.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RuboCop
-  # RuboCop FactoryBot project namespace
+  # RuboCop factory_bot project namespace
   module FactoryBot
     ATTRIBUTE_DEFINING_METHODS = %i[
       factory

data/lib/rubocop/factory_bot/language.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module FactoryBot
-    # Contains node matchers for common FactoryBot DSL.
+    # Contains node matchers for common factory_bot DSL.
     module Language
       extend RuboCop::NodePattern::Macros
 

data/lib/rubocop/factory_bot/version.rb

@@ -2,9 +2,9 @@
 
 module RuboCop
   module FactoryBot
-    # Version information for the FactoryBot RuboCop plugin.
+    # Version information for the factory_bot RuboCop plugin.
     module Version
-      STRING = '2.22.0'
+      STRING = '2.23.1'
     end
   end
 end

data/lib/rubocop-factory_bot.rb

@@ -8,6 +8,8 @@ require 'rubocop'
 require_relative 'rubocop/factory_bot/factory_bot'
 require_relative 'rubocop/factory_bot/language'
 
+require_relative 'rubocop/cop/factory_bot/mixin/configurable_explicit_only'
+
 require_relative 'rubocop/cop/factory_bot_cops'
 
 project_root = File.join(__dir__, '..')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-factory_bot
 version: !ruby/object:Gem::Version
-  version: 2.22.0
+  version: 2.23.1
 platform: ruby
 authors:
 - John Backus
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-05 00:00:00.000000000 Z
+date: 2023-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -28,9 +28,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.33'
-description: |2
-      Code style checking for FactoryBot files.
-      A plugin for the RuboCop code style enforcing & linting tool.
+description: |
+  Code style checking for factory_bot files.
+  A plugin for the RuboCop code style enforcing & linting tool.
 email:
 executables: []
 extensions: []
@@ -44,11 +44,15 @@ files:
 - README.md
 - config/default.yml
 - lib/rubocop-factory_bot.rb
+- lib/rubocop/cop/factory_bot/association_style.rb
 - lib/rubocop/cop/factory_bot/attribute_defined_statically.rb
 - lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb
 - lib/rubocop/cop/factory_bot/create_list.rb
+- lib/rubocop/cop/factory_bot/factory_association_with_strategy.rb
 - lib/rubocop/cop/factory_bot/factory_class_name.rb
 - lib/rubocop/cop/factory_bot/factory_name_style.rb
+- lib/rubocop/cop/factory_bot/mixin/configurable_explicit_only.rb
+- lib/rubocop/cop/factory_bot/redundant_factory_option.rb
 - lib/rubocop/cop/factory_bot/syntax_methods.rb
 - lib/rubocop/cop/factory_bot_cops.rb
 - lib/rubocop/factory_bot/config_formatter.rb
@@ -78,8 +82,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.13
 signing_key:
 specification_version: 4
-summary: Code style checking for FactoryBot files
+summary: Code style checking for factory_bot files
 test_files: []