factory_bot-with 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 330ba97b29d7109bb0cb89cf0493cced5300e17c3a1465066405e46c66cbcd76
-  data.tar.gz: 504cbcee6a16323d2a9494f10bcb68754d84130b343c316eab7a9f4c01432a0c
+  metadata.gz: fa2396f8ce3d44a17caacc293e2b5914b781eb167c50de541c2950b6f3e8ce0f
+  data.tar.gz: a5b0e4b93ba6f97439dd25290c2ab5c3832175799e7e45f538e0c9db28be14bf
 SHA512:
-  metadata.gz: 11ed1a26a0ebd2590398eef94ebbf8aaeb23419cdd2b0d5e3979f3a64bbe4179e1f96d731804ccbd042535806a4999de62f5a6d5b72cf7ff5c2fbf379cd30372
-  data.tar.gz: 5da17d95d18e8c746ddd5ce0a1213a8cf24dec8766753655ea912bc91a6b7c38dde9c7d85d73bca4165b7d17f126af31c2a4fd71be3cdbb5807c40a0434ef259
+  metadata.gz: a655f59ca867e26316fb08d3fd80e9352d4cefeb600c9d324de89358096a031e549acc5d98da43d67f608f615084bfc384a4c8d45f9e528891d4f90f9fe9de5f
+  data.tar.gz: 4709882eea9a1a90e6719a44133d66e1de9c189da2c602963f77b9c80b14952b99dbd2b350085d496f15cf70f20bbbce4edc1a5a37b2dcf9272d244be31d7589

data/.github/workflows/main.yml

@@ -14,7 +14,8 @@ jobs:
     strategy:
       matrix:
         ruby:
-          - '3.3.6'
+          - '3.4.2'
+          - '3.3.7'
           - '3.2.6'
 
     steps:

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [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
+
 ## [0.3.0] - 2024-12-09
 
 - Added: Added `FactoryBot::With.register_strategy` to support custom strategies

data/README.md

@@ -5,6 +5,8 @@
 
 FactoryBot::With is a FactoryBot extension that wraps `FactoryBot::Syntax::Methods` to make it a little easier to use.
 
+[FactoryBot における関連の扱いと、factory_bot-with gem を作った話 (Japanese)](https://zenn.dev/yubrot/articles/032447068e308e)
+
 For example, with these factories:
 
 ```ruby
@@ -60,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, ...)
 ```
 
@@ -143,16 +145,82 @@ create.blog(with.article) # autocomplete to :blog_article
 
 </details>
 
+## 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. It works as a template for factory method calls.
+`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.
 
 Instead of writing:
 
 ```ruby
 let(:story) { create(:story, *story_args, **story_kwargs) }
 let(:story_args) { [] }
-let(:story_kwargs) { {} }
+let(:story_kwargs) { { category: "SF" } }
 
 context "when published more than one year ago" do
   let(:story_args) { [*super(), :published] }
@@ -167,7 +235,7 @@ You can write like this:
 ```ruby
 # Factory methods accept a With instance as a first argument:
 let(:story) { create(story_template) }
-let(:story_template) { with.story }
+let(:story_template) { with.story(category: "SF") }
 
 context "when published more than one year ago" do
   let(:story_template) { with(super(), :published, start_at: 2.year.ago) }

data/lib/factory_bot/with/proxy.rb

@@ -4,31 +4,28 @@ module FactoryBot
   class With
     # An intermediate object to provide some notation combined with <code>method_missing</code>.
     # @example
-    #   class Foo
-    #     def foo(name = nil)
+    #   class Example
+    #     def foo(name = nil, ...)
     #       return FactoryBot::With::Proxy.new(self, __method__) unless name
     #
     #       name
     #     end
     #   end
     #
-    #   Foo.new.foo.bar #=> :bar
+    #   ex = Example.new
+    #   ex.foo.bar #=> :bar
     class Proxy < BasicObject
       # @param receiver [Object]
       # @param method [Symbol]
-      # @param preargs [Array]
-      def initialize(receiver, method, *preargs)
+      def initialize(receiver, method)
         @receiver = receiver
         @method = method
-        @preargs = preargs
       end
 
       # @!visibility private
       def respond_to_missing?(_method_name, _) = true
 
-      def method_missing(method_name, ...)
-        @receiver.__send__(@method, *@preargs, method_name, ...)
-      end
+      def method_missing(method_name, ...) = @receiver.__send__(@method, method_name, ...)
     end
   end
 end

data/lib/factory_bot/with/version.rb

@@ -2,6 +2,6 @@
 
 module FactoryBot
   class With
-    VERSION = "0.3.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)
       )
@@ -96,7 +96,7 @@ module FactoryBot
     # @param build_strategy [Symbol]
     # @param ancestors [Array<Array(AssocInfo, Object)>, nil]
     # @return [Object]
-    def instantiate(build_strategy, ancestors = nil)
+    def instantiate(build_strategy, ancestors = self.class.scoped_ancestors)
       return self if build_strategy == :with
 
       factory_bot_method =
@@ -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
 
@@ -148,12 +151,57 @@ module FactoryBot
           list: :"#{build_strategy}_list",
         }.each do |variation, method_name|
           Methods.define_method(method_name) do |factory = nil, *args, **kwargs, &block|
-            return Proxy.new(self, __method__) unless factory
-
-            With.build(variation, factory, *args, **kwargs, &block).instantiate(build_strategy)
+            if factory
+              # <__method__>(<factory_name>, ...)
+              With.build(variation, factory, *args, **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? && block
+              # with(<factory_name>: <object>, ...) { ... }
+              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
           end
         end
       end
+
+      # @!visibility private
+      # @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] = [*ancestors, *tmp_scoped_ancestors || []]
+        result = yield
+        Thread.current[:factory_bot_with_scoped_ancestors] = tmp_scoped_ancestors
+        result
+      end
+
+      # @!visibility private
+      # @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,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: factory_bot-with
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - yubrot
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-09 00:00:00.000000000 Z
+date: 2025-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: factory_bot
@@ -52,7 +51,6 @@ metadata:
   source_code_uri: https://github.com/yubrot/factory_bot-with
   changelog_uri: https://github.com/yubrot/factory_bot-with/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -67,8 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: FactoryBot extension that wraps FactoryBot::Syntax::Methods to make it a
   little easier to use