factory_bot-with 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 880e6e75c055c95bf4c8afab93288afaeb01f1a8ea7d162ecec04c3adaba1498
-  data.tar.gz: d59eb2dbc2c24256e1c1b4053d194de41378cdd3773c06375bf8617ae63af642
+  metadata.gz: fa2396f8ce3d44a17caacc293e2b5914b781eb167c50de541c2950b6f3e8ce0f
+  data.tar.gz: a5b0e4b93ba6f97439dd25290c2ab5c3832175799e7e45f538e0c9db28be14bf
 SHA512:
-  metadata.gz: 74ee4b6d1718cfef30a3ddfaaca2486f854c8c6db5c4b1fa63c1947f2ae3f2430e8ec67afd8dac052ff049df4d61c7f091b66a0080d187e51e58c4795534b66f
-  data.tar.gz: f01718b24e04fe024189d77cec858f0aad8ec88fac9de520ced36bf954863775e6c0ecb079d0831016fac2d863edec204c8a23bec82f304ecd2b8c4186c9ab5e
+  metadata.gz: a655f59ca867e26316fb08d3fd80e9352d4cefeb600c9d324de89358096a031e549acc5d98da43d67f608f615084bfc384a4c8d45f9e528891d4f90f9fe9de5f
+  data.tar.gz: 4709882eea9a1a90e6719a44133d66e1de9c189da2c602963f77b9c80b14952b99dbd2b350085d496f15cf70f20bbbce4edc1a5a37b2dcf9272d244be31d7589

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 ## [Unreleased]
 
-## [0.4.0]
+## [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

@@ -62,7 +62,7 @@ FactoryBot::With overrides the behavior when factory methods are called without
 
 ```ruby
 create(:foo, ...)  # behaves in the same way as FactoryBot.create
-create             # returns a Proxy (an intermadiate) object
+create             # returns a Proxy (an intermediate) object
 create.foo(...)    # is equivalent to create(:foo, ...)
 ```
 
@@ -147,6 +147,70 @@ create.blog(with.article) # autocomplete to :blog_article
 
 ## Additional features
 
+### `with` scope syntax 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, it 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(with.article)`,
+    # `blog:` is completed automatically at each `create.article`
+    create.article(with.comment)
+    create.article(with_list.comment(3))
+  end
+end
+```
+
+The same behavior occurs when a block is passed to factory methods.
+
+```ruby
+create.blog do
+  create.article(with.comment)
+  create.article(with_list.comment(3))
+end
+```
+
+<details>
+<summary>Comparison</summary>
+
+`_pair` and `_list` methods have [an incompatible behavior](./lib/factory_bot/with.rb#L121) with FactoryBot. If you want to avoid this, just use `Object#tap`.
+
+```ruby
+# This creates a blog with 2 articles, each with 1 comment
+# plain factory_bot:
+create(:blog) do |blog|
+  create_list(:article, 2, blog:) do |articles| # yielded once with an array of articles in plain factory_bot
+    articles.each { |article| create(:comment, article:) }
+  end
+end
+
+# `with` operator:
+create.blog(
+  with_list.article(2, with.comment)
+)
+
+# factory methods with blocks:
+create.blog do
+  create_list.article(2) { create.comment } # yielded *for each article* in factory_bot-with
+end
+
+# with as a scope syntax for existing blog:
+blog = create.blog
+with(blog:) do
+  create_list.article(2) { create.comment }
+end
+
+# with_list can also be used as a scope syntax:
+blog = create.blog
+articles = create_list.article(2, blog:)
+with_list(article: articles) { create.comment } # yielded *for each article*
+```
+
+</details>
+
 ### `with` as a template
 
 `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.
@@ -180,22 +244,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/version.rb

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

data/lib/factory_bot/with.rb

@@ -63,9 +63,9 @@ 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)
       )
@@ -110,14 +110,17 @@ module FactoryBot
         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.
+          self.class.with_scoped_ancestors(ancestors_for_children) { block.call(result) } if block
         end
       end
 
@@ -154,9 +157,14 @@ module FactoryBot
             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)
+              block = With.call_with_scope_adapter(&block)
+              With.call_with_scope(kwargs, &block)
+            elsif __method__ == :with_list && args.empty? && !kwargs.empty? && block
+              # with_list(<factory_name>: [<object>, ...], ...) { ... }
+              block = With.call_with_scope_adapter(&block)
+              kwargs.values.inject(:product).map { With.call_with_scope(kwargs.keys.zip(_1).to_h, &block) }
             else
               raise ArgumentError, "Invalid use of #{__method__}"
             end
@@ -165,23 +173,35 @@ module FactoryBot
       end
 
       # @!visibility private
-      # @param objects [{Symbol => Object}]
-      def with_scoped_ancestors(objects)
-        return unless block_given?
+      # @return [Array<Array(AssocInfo, Object)>, nil]
+      def scoped_ancestors = Thread.current[:factory_bot_with_scoped_ancestors]
 
+      # @param ancestors [Array<Array(AssocInfo, Object)>]
+      def with_scoped_ancestors(ancestors, &)
         tmp_scoped_ancestors = scoped_ancestors
-        Thread.current[:factory_bot_with_scoped_ancestors] = [
-          *objects.map { [AssocInfo.get(_1), _2] },
-          *tmp_scoped_ancestors || [],
-        ]
+        Thread.current[:factory_bot_with_scoped_ancestors] = [*ancestors, *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]
+      # @param objects [{Symbol => Object}]
+      def call_with_scope(objects, &block)
+        with_scoped_ancestors(objects.map { [AssocInfo.get(_1), _2] }) { block.call(objects) }
+      end
+
+      # @!visibility private
+      def call_with_scope_adapter(&block)
+        params = block.parameters
+        if params.any? { %i[req opt rest].include?(_1[0]) }
+          ->(objects) { block.call(*objects.values) }
+        elsif params.any? { %i[keyreq key keyrest].include?(_1[0]) }
+          ->(objects) { block.call(**objects) }
+        else
+          ->(_) { block.call }
+        end
+      end
     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.5.0
 platform: ruby
 authors:
 - yubrot
 bindir: exe
 cert_chain: []
-date: 2025-03-15 00:00:00.000000000 Z
+date: 2025-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: factory_bot