factory_bot-with 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 880e6e75c055c95bf4c8afab93288afaeb01f1a8ea7d162ecec04c3adaba1498
-  data.tar.gz: d59eb2dbc2c24256e1c1b4053d194de41378cdd3773c06375bf8617ae63af642
+  metadata.gz: ab9e29f43a809164761618a28339cd98f4c26060183045f79dcd52cc107ee3aa
+  data.tar.gz: 2c4814ce52ed94f4120077410519424a19aa8b590a2af571429aadb059f59687
 SHA512:
-  metadata.gz: 74ee4b6d1718cfef30a3ddfaaca2486f854c8c6db5c4b1fa63c1947f2ae3f2430e8ec67afd8dac052ff049df4d61c7f091b66a0080d187e51e58c4795534b66f
-  data.tar.gz: f01718b24e04fe024189d77cec858f0aad8ec88fac9de520ced36bf954863775e6c0ecb079d0831016fac2d863edec204c8a23bec82f304ecd2b8c4186c9ab5e
+  metadata.gz: 25a743163e0a1f248d0106534086ee928ecd4b46257985588287dfdf681a03309ea5f4c6db40bf9c5591aad3c2ba78edb80b071752fa992d7935b458b25bbf40
+  data.tar.gz: d01e0dcecfa6b765a7510f581d6197f324cfd464bb0f6c939477f067fb1dd76675c46c898c7d7759b3923477162ef161994cc60f86ddad5f9ae6f2a6be6956a7

data/.irbrc

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "factory_bot/with"
+require_relative "spec/factories"
+
+class << self
+  prepend FactoryBot::With::Methods
+end

data/CHANGELOG.md

@@ -1,6 +1,17 @@
 ## [Unreleased]
 
-## [0.4.0]
+## [0.6.0] - 2025-04-11
+
+- Added: Factory methods are now also provided as class methods of `FactoryBot::With`
+- Fixed: Removed some internal methods from `FactoryBot::With`
+
+## [0.5.0] - 2025-03-20
+
+- Added: When using `with` scope syntax, blocks can now take given objects as arguments
+- Added: `with_list` also works as a scope syntax, but calls a block for each product of objects
+- **Changed**: Passing blocks to factory methods behaves same as `with` scope syntax
+
+## [0.4.0] - 2025-03-15
 
 - Fixed: Improved error message for incorrect factory usage
 - Added: Added `with` scope syntax for automatic association resolution

data/README.md

@@ -3,11 +3,11 @@
 [![](https://badge.fury.io/rb/factory_bot-with.svg)](https://badge.fury.io/rb/factory_bot-with)
 [![](https://github.com/yubrot/factory_bot-with/actions/workflows/main.yml/badge.svg)](https://github.com/yubrot/factory_bot-with/actions/workflows/main.yml)
 
-FactoryBot::With is a FactoryBot extension that wraps `FactoryBot::Syntax::Methods` to make it a little easier to use.
+FactoryBot::With is a FactoryBot extension that enhances usability by wrapping factory methods.
 
 [FactoryBot における関連の扱いと、factory_bot-with gem を作った話 (Japanese)](https://zenn.dev/yubrot/articles/032447068e308e)
 
-For example, with these factories:
+For example, given these factories:
 
 ```ruby
 FactoryBot.define do
@@ -26,18 +26,18 @@ create(:blog) do |blog|
 end
 ```
 
-FactoryBot::With allows you to write:
+FactoryBot::With allows you to write like this:
 
 ```ruby
-create.blog(
-  with.article(with.comment),
-  with.article(with_list.comment(3)),
-)
+create.blog do
+  create.article { create.comment }
+  create.article { create_list.comment(3) }
+end
 ```
 
 ## Installation
 
-On your Gemfile:
+Add the following line to your Gemfile:
 
 ```ruby
 gem "factory_bot-with"
@@ -54,28 +54,29 @@ RSpec.configure do |config|
 end
 ```
 
+Alternatively, these factory methods are also provided as class methods of `FactoryBot::With`.
+
 ## What differs from `FactoryBot::Syntax::Methods`?
 
-### Method style syntax
+### Method-style syntax
 
-FactoryBot::With overrides the behavior when factory methods are called without arguments.
+FactoryBot::With overrides the behavior of factory methods called without arguments.
 
 ```ruby
-create(:foo, ...)  # behaves in the same way as FactoryBot.create
-create             # returns a Proxy (an intermadiate) object
+create(:foo, ...)  # normal usage
+create             # returns a Proxy (an intermediate) object
 create.foo(...)    # is equivalent to create(:foo, ...)
-```
 
-This applies to other factory methods such as `build_stubbed`, `create_list`, `with` (described later), etc. as well.
-
-```ruby
+# This also applies to other factory methods:
 build_stubbed.foo(...)
 create_list.foo(10, ...)
 ```
 
 ### Smarter interpretation of positional arguments
 
-FactoryBot::With adjusts the behavior of factory methods to accept `Hash`, `Array`, and falsy values (`false` or `nil`) as positional arguments.
+FactoryBot::With allows factory methods to accept `Hash`, `Array`, and falsy values (`false` or `nil`) as positional arguments[^1].
+
+[^1]: The idea for this behavior came from JavaScript libraries such as [clsx](https://github.com/lukeed/clsx).
 
 ```ruby
 create.foo({ title: "Recipe" }, is_new && %i[latest hot])
@@ -85,54 +86,57 @@ create.foo({ title: "Recipe" }, is_new && %i[latest hot])
 
 ### `with`, `with_pair`, and `with_list` operator
 
-FactoryBot::With provides a new operator `with` (and its family).
+FactoryBot::With introduces new operators: `with` (and its family).
+
+- `with(:factory_name, ...)`
+- `with_pair(:factory_name, ...)`
+- `with_list(:factory_name, number_of_items, ...)`
+
+These operators produce a `With` instance. This instance can be passed as an argument to factory methods such as `build` or `create`:
 
 ```ruby
-with(:factory_name, ...)
-with_pair(:factory_name, ...)
-with_list(:factory_name, number_of_items, ...)
+create.blog(with.article(with.comment))
 ```
 
-The result of this operator (`With` instance) can be passed as an argument to factory methods such as `build` or `create`, which can then create additional objects following the result of the factory.
+When the factory method is called, it first collects and removes `With` arguments, then delegates the actual object creation to the standard FactoryBot factory method, and finally creates additional objects based on the factory definition. Above example is equivalent to:
 
 ```ruby
-create.blog(with.article)
-# is equivalent to ...
-blog = create.blog
-create.article(blog:)
+_tmp1 = FactoryBot.create(:blog)
+_tmp2 = FactoryBot.create(:article, blog: _tmp1)
+_tmp3 = FactoryBot.create(:comment, article: _tmp2)
+# Here, `blog: _tmp1` and `article: _tmp2` are automatically completed by AAR (described later)
 ```
 
-The overridden factory methods collect these `with` arguments before delegating object creation to the actual factory methods.
-
 <details>
-<summary>Automatic association resolution</summary>
+<summary>Automatic Association Resolution (AAR)</summary>
 
-`with` automatically resolves references to ancestor objects based on the definition of the FactoryBot associations.
+`with` automatically resolves references to ancestor objects based on the definition in your FactoryBot factories.
 
-This automatic resolution takes into account any [traits](https://thoughtbot.github.io/factory_bot/traits/summary.html) in the factories, [aliases](https://thoughtbot.github.io/factory_bot/sequences/aliases.html) in the factories, and [factory specifications](https://thoughtbot.github.io/factory_bot/associations/specifying-the-factory.html) in the associations.
+This automatic resolution takes into account any [traits](https://thoughtbot.github.io/factory_bot/traits/summary.html), [aliases](https://thoughtbot.github.io/factory_bot/sequences/aliases.html), and [factory specifications](https://thoughtbot.github.io/factory_bot/associations/specifying-the-factory.html) in the definition.
 
 ```ruby
 FactoryBot.define do
   factory(:video)
   factory(:photo)
   factory(:tag) do
+    # `tag` potentially has an association on `taggable` field. `taggable` is either `video` or `photo`.
     trait(:for_video) { taggable factory: :video }
     trait(:for_photo) { taggable factory: :photo }
   end
 end
 
-create.video(with.tag(text: "latest"))  # resolved as taggable: video
-create.photo(with.tag(text: "latest"))  # ...
+create.video(with.tag(text: "latest"))  # resolved as `taggable: <created video object>`
+create.photo(with.tag(text: "latest"))  # resolved as `taggable: <created photo object>`
 ```
 
-Due to technical limitations, [inline associations](https://thoughtbot.github.io/factory_bot/associations/inline-definition.html) cannot be resolved.
+Due to technical limitations, [inline associations](https://thoughtbot.github.io/factory_bot/associations/inline-definition.html) are not taken into account.
 
 </details>
 
 <details>
-<summary>Autocomplete fully-qualified factory name</summary>
+<summary>Factory Name Completion (FNC)</summary>
 
-For a factory name that is prefixed by the parent object's factory name, the prefix can be omitted.
+For a factory name that is prefixed by the ancestor object's factory name, the prefix can be omitted.
 
 ```ruby
 FactoryBot.define do
@@ -140,16 +144,90 @@ FactoryBot.define do
   factory(:blog_article) { blog }
 end
 
-create.blog(with.article) # autocomplete to :blog_article
+create.blog(with.article) # completes to :blog_article
+```
+
+</details>
+
+### Implicit context scope
+
+FactoryBot::With factory methods can accept a block argument, just like standard FactoryBot. However, in FactoryBot::With, nested factory method calls within a block recognize ancestor objects. This means that nested factory method calls perform AAR and FNC in the same way as the `with` operator.
+
+```ruby
+# Instead of writing:
+create.blog(with.article(with.comment))
+# You can write:
+create.blog { create.article { create.comment } }
+# ^ This works in the same way as:
+create(:blog) do |blog|
+  create(:article, blog:) do |article|
+    create(:comment, article:)
+  end
+end
+```
+
+<details>
+<summary>Incompatible behavior when calling <code>_list</code> or <code>_pair</code> factory methods with a block</summary>
+
+To align the behavior with the `with_list` operator, there is [an incompatible behavior](./lib/factory_bot/with.rb#L121) compared to standard FactoryBot:
+
+```ruby
+# This code creates a blog with 2 articles, each with a comment in standard FactoryBot:
+# This does not work in FactoryBot::With!
+create(:blog) do |blog|
+  create_list(:article, 2, blog:) do |articles| # yielded *once* with an array of articles
+    articles.each { |article| create(:comment, article:) }
+  end
+end
+
+# In FactoryBot::With, blocks are yielded for each object. So we must write like this:
+create.blog do |blog|
+  create_list.article(2, blog:) do |article| # yielded *for each article*
+    create.comment(article:)
+  end
+end
+
+# Again, you can simplify this by (1)omitting the block or (2)using the `with` operator:
+create.blog { create_list.article(2) { create.comment } }  # (1)
+create.blog(with_list.article(2, with.comment))            # (2)
 ```
 
+If you want to avoid this incompatibility, you can use `Object#tap`.
+
 </details>
 
 ## Additional features
 
-### `with` as a template
+### Implicit context scope with existing objects
 
-`with` can also be used stand-alone. Stand-alone `with` can be used in place of the factory name. It works as a template for factory method calls.
+By calling `with` without positional arguments, but with keyword arguments that define the relationship between factory names and objects, along with a block, it creates a context scope where those objects become candidates for AAR and FNC.
+
+```ruby
+let(:blog) { create.blog }
+
+before do
+  with(blog:) do
+    # Just like `create.blog { ... }`,
+    # the `blog` object is available for AAR and FNC in the following `create.article` calls:
+    create.article(with.comment)
+    create.article(with_list.comment(3))
+  end
+end
+```
+
+`with_list` works similarly to `with`, except that it accepts arrays as its values:
+
+```ruby
+blog = create.blog
+articles = create_list.article(2, blog:)
+with_list(article: articles) { create.comment } # yielded *for each article*
+```
+
+</details>
+
+### `with` as a factory method call template
+
+A `With` instance can also be used as a template for factory method calls.
 
 Instead of writing:
 
@@ -180,22 +258,6 @@ context "when published more than one year ago" do
 end
 ```
 
-### `with` scope for automatic association resolution
-
-By calling `with` without positional arguments, but with keyword arguments that define the relationship between factory names and objects, along with a block, `factory_bot-with` creates a scope where those objects become candidates for automatic association resolution.
-
-```ruby
-let(:blog) { create.blog }
-
-before do
-  with(blog:) do
-    # Just like when using create.blog, blog is automatically resolved when create.article is called
-    create.article(with.comment)
-    create.article(with_list.comment(3))
-  end
-end
-```
-
 ## Development
 
 ```bash

data/lib/factory_bot/with/assoc_info.rb

@@ -45,7 +45,7 @@ module FactoryBot
         # @param ancestors [Array<Array(AssocInfo, Object)>]
         # @param partial_factory_name [Symbol]
         # @return [Symbol]
-        def autocomplete_fully_qualified_factory_name(ancestors, partial_factory_name)
+        def perform_factory_name_completion(ancestors, partial_factory_name)
           ancestors.each do |(ancestor_assoc_info, _)|
             ancestor_assoc_info.factory_names.each do |ancestor_factory_name|
               factory_name = :"#{ancestor_factory_name}_#{partial_factory_name}"
@@ -53,8 +53,8 @@ module FactoryBot
             end
           end
 
-          # Attempt to resolve with the autocompleted names, then attempt to resolve with the original name.
-          # If we want to avoid autocompletion, we should be able to simply use a factory such as build or create.
+          # Attempt to resolve with the completed names, then attempt to resolve with the original name.
+          # If we want to avoid completion, we should be able to simply use a factory such as build or create.
           return partial_factory_name if exists?(partial_factory_name)
 
           raise ArgumentError, "FactoryBot factory #{partial_factory_name} is not defined"

data/lib/factory_bot/with/scoped.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module FactoryBot
+  class With
+    # An internal class to implement implicit context scope.
+    class Scoped
+      class << self
+        # @!visibility private
+        # @return [Array<Array(AssocInfo, Object)>, nil]
+        def ancestors = Thread.current[:factory_bot_with_scoped_ancestors]
+
+        # @param ancestors [Array<Array(AssocInfo, Object)>]
+        def with_ancestors(ancestors, &)
+          tmp_ancestors = self.ancestors
+          Thread.current[:factory_bot_with_scoped_ancestors] = [*ancestors, *tmp_ancestors || []]
+          yield
+        ensure
+          Thread.current[:factory_bot_with_scoped_ancestors] = tmp_ancestors
+        end
+
+        # @!visibility private
+        # @param objects [{Symbol => Object}]
+        def with_objects(objects, &) = with_ancestors(objects.map { [AssocInfo.get(_1), _2] }, &)
+
+        # @!visibility private
+        def block(&block)
+          params = block.parameters
+          if params.any? { %i[req opt rest].include?(_1[0]) }
+            ->(objects) { with_objects(objects) { block.call(*objects.values) } }
+          elsif params.any? { %i[keyreq key keyrest].include?(_1[0]) }
+            ->(objects) { with_objects(objects) { block.call(**objects) } }
+          else
+            ->(objects) { with_objects(objects, &block) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/factory_bot/with/version.rb

@@ -2,6 +2,6 @@
 
 module FactoryBot
   class With
-    VERSION = "0.4.0"
+    VERSION = "0.6.0"
   end
 end

data/lib/factory_bot/with.rb

@@ -4,11 +4,14 @@ require "factory_bot"
 require_relative "with/version"
 require_relative "with/proxy"
 require_relative "with/assoc_info"
+require_relative "with/scoped"
 require_relative "with/methods"
 
 module FactoryBot
   # An intermediate state for <code>with</code> operator.
   class With
+    extend Methods
+
     # @return [:singular, :pair, :list]
     attr_reader :variation
     # @return [Symbol]
@@ -23,7 +26,7 @@ module FactoryBot
     attr_reader :block
 
     # @!visibility private
-    def initialize(variation, factory_name, withes: [], traits: [], attrs: {}, &block)
+    def initialize(variation, factory_name, *, withes: [], traits: [], attrs: {}, &block)
       raise ArgumentError unless %i[singular pair list].include? variation
       raise TypeError unless factory_name.is_a? Symbol
       raise TypeError unless withes.is_a?(Array) && withes.all? { _1.is_a? self.class }
@@ -36,6 +39,8 @@ module FactoryBot
       @traits = traits
       @attrs = attrs
       @block = block
+
+      collect!(*)
     end
 
     # @!visibility private
@@ -46,7 +51,7 @@ module FactoryBot
     # @param other [With]
     # @return [With]
     def merge(other)
-      raise TypeError, "oter must be an instance of #{self.class}" unless other.is_a? self.class
+      raise TypeError, "other must be an instance of #{self.class}" unless other.is_a? self.class
       raise ArgumentError, "other must have the same variation" if other.variation != variation
       raise ArgumentError, "other must have the same factory_name" if other.factory_name != factory_name
 
@@ -63,40 +68,19 @@ module FactoryBot
           return first unless second
           return second unless first
 
-          lambda do |*args|
-            first.call(*args)
-            second.call(*args)
+          proc do |arg|
+            first.call(arg)
+            second.call(arg)
           end
         end.call(block, other.block)
       )
     end
 
-    # @!visibility private
-    def extend!(*args)
-      args.each do |arg|
-        case arg
-        when self.class
-          withes << arg
-        when Symbol, Numeric
-          traits << arg
-        when Array
-          extend!(*arg)
-        when Hash
-          attrs.merge!(arg)
-        when false, nil
-          # Ignored. This behavior is useful for conditional arguments like `is_premium && :premium`
-        else
-          raise ArgumentError, "Unsupported type for factory argument: #{arg}"
-        end
-      end
-      self
-    end
-
     # @!visibility private
     # @param build_strategy [Symbol]
     # @param ancestors [Array<Array(AssocInfo, Object)>, nil]
     # @return [Object]
-    def instantiate(build_strategy, ancestors = self.class.scoped_ancestors)
+    def instantiate(build_strategy, ancestors = Scoped.ancestors)
       return self if build_strategy == :with
 
       factory_bot_method =
@@ -104,38 +88,51 @@ module FactoryBot
       factory_name, attrs =
         if ancestors
           attrs = @attrs.dup
-          factory_name = AssocInfo.autocomplete_fully_qualified_factory_name(ancestors, @factory_name)
+          factory_name = AssocInfo.perform_factory_name_completion(ancestors, @factory_name)
           AssocInfo.get(factory_name).perform_automatic_association_resolution(ancestors, attrs)
           [factory_name, attrs]
         else
           [@factory_name, @attrs]
         end
-      result = FactoryBot.__send__(factory_bot_method, factory_name, *traits, **attrs, &block)
+      result = FactoryBot.__send__(factory_bot_method, factory_name, *traits, **attrs)
 
-      unless withes.empty?
-        parents = variation == :singular ? [result] : result
+      if block || !withes.empty?
         assoc_info = AssocInfo.get(factory_name)
+        parents = variation == :singular ? [result] : result
         parents.each do |parent|
           ancestors_for_children = [[assoc_info, parent], *ancestors || []]
           withes.each { _1.instantiate(build_strategy, ancestors_for_children) }
+          # We call the block for each parent object. This is an incompatible behavior with FactoryBot!
+          # If you want to avoid this, use `Object#tap` manually.
+          Scoped.with_ancestors(ancestors_for_children) { block.call(result) } if block
         end
       end
 
       result
     end
 
-    class << self
-      # @!visibility private
-      # @param variation [:singular, :pair, :list]
-      # @param factory [Symbol, With]
-      # @param args [Array<Object>]
-      # @param kwargs [{Symbol => Object}]
-      def build(variation, factory, *, **, &)
-        return factory.merge(build(variation, factory.factory_name, *, **, &)) if factory.is_a? self
-
-        new(variation, factory, &).extend!(*, { ** })
+    private
+
+    def collect!(*args)
+      args.each do |arg|
+        case arg
+        when self.class
+          withes << arg
+        when Symbol, Numeric
+          traits << arg
+        when Array
+          collect!(*arg)
+        when Hash
+          attrs.merge!(arg)
+        when false, nil
+          # Ignored. This behavior is useful for conditional arguments like `is_premium && :premium`
+        else
+          raise ArgumentError, "Unsupported type for factory argument: #{arg}"
+        end
       end
+    end
 
+    class << self
       # If you want to use a custom strategy, call this along with <code>FactoryBot.register_strategy</code>.
       # @param build_strategy [Symbol]
       # @example
@@ -148,40 +145,30 @@ module FactoryBot
           list: :"#{build_strategy}_list",
         }.each do |variation, method_name|
           Methods.define_method(method_name) do |factory = nil, *args, **kwargs, &block|
-            if factory
+            if factory.is_a? With
+              # <__method__>(<with_instance>, ...)
+              factory
+                .merge(With.new(variation, factory.factory_name, *args, attrs: kwargs, &block))
+                .instantiate(build_strategy)
+            elsif factory
               # <__method__>(<factory_name>, ...)
-              With.build(variation, factory, *args, **kwargs, &block).instantiate(build_strategy)
+              With.new(variation, factory, *args, attrs: kwargs, &block).instantiate(build_strategy)
             elsif args.empty? && kwargs.empty? && !block
               # <__method__>.<factory_name>(...)
               Proxy.new(self, __method__)
-            elsif __method__ == :with && args.empty? && !kwargs.empty?
+            elsif __method__ == :with && args.empty? && !kwargs.empty? && block
               # with(<factory_name>: <object>, ...) { ... }
-              With.with_scoped_ancestors(kwargs, &block)
+              Scoped.block(&block).call(kwargs)
+            elsif __method__ == :with_list && args.empty? && !kwargs.empty? && block
+              # with_list(<factory_name>: [<object>, ...], ...) { ... }
+              block = Scoped.block(&block)
+              kwargs.values.inject(:product).map { block.call(kwargs.keys.zip(_1).to_h) }
             else
               raise ArgumentError, "Invalid use of #{__method__}"
             end
           end
         end
       end
-
-      # @!visibility private
-      # @param objects [{Symbol => Object}]
-      def with_scoped_ancestors(objects)
-        return unless block_given?
-
-        tmp_scoped_ancestors = scoped_ancestors
-        Thread.current[:factory_bot_with_scoped_ancestors] = [
-          *objects.map { [AssocInfo.get(_1), _2] },
-          *tmp_scoped_ancestors || [],
-        ]
-        result = yield
-        Thread.current[:factory_bot_with_scoped_ancestors] = tmp_scoped_ancestors
-        result
-      end
-
-      # @!visibility private
-      # @return [Array<Array(AssocInfo, Object)>, nil]
-      def scoped_ancestors = Thread.current[:factory_bot_with_scoped_ancestors]
     end
 
     %i[build build_stubbed create attributes_for with].each { register_strategy _1 }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: factory_bot-with
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - yubrot
 bindir: exe
 cert_chain: []
-date: 2025-03-15 00:00:00.000000000 Z
+date: 2025-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: factory_bot
@@ -23,8 +23,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
-description: FactoryBot extension that wraps FactoryBot::Syntax::Methods to make it
-  a little easier to use
+description: a FactoryBot extension that enhances usability by wrapping factory methods
 email:
 - yubrot@gmail.com
 executables: []
@@ -33,6 +32,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/main.yml"
 - ".gitignore"
+- ".irbrc"
 - ".solargraph.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -42,6 +42,7 @@ files:
 - lib/factory_bot/with/assoc_info.rb
 - lib/factory_bot/with/methods.rb
 - lib/factory_bot/with/proxy.rb
+- lib/factory_bot/with/scoped.rb
 - lib/factory_bot/with/version.rb
 homepage: https://github.com/yubrot/factory_bot-with
 licenses:
@@ -67,6 +68,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.2
 specification_version: 4
-summary: FactoryBot extension that wraps FactoryBot::Syntax::Methods to make it a
-  little easier to use
+summary: a FactoryBot extension that enhances usability by wrapping factory methods
 test_files: []