factory_bot-with 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abe0a558801602a366eb21e5aacf753e8cb3fb75a2e45b6df492308c4244d85f
-  data.tar.gz: 514e5d0190f7dfa9cd0744062217a99c2ba5964be8f2bcf2fa64864044a84465
+  metadata.gz: 880e6e75c055c95bf4c8afab93288afaeb01f1a8ea7d162ecec04c3adaba1498
+  data.tar.gz: d59eb2dbc2c24256e1c1b4053d194de41378cdd3773c06375bf8617ae63af642
 SHA512:
-  metadata.gz: 8243dd0f2ea730d9266964806a48934856254b2ecd1f73bf839f19198e2540061c373a8778413ddcfcc5a68aface18cd3debfa9ae0b5f8b1f8416a1ed2459d98
-  data.tar.gz: 78031d8c55fef101fb7cf9c5511beeae3374813faa62f5925deb3ed70a80872e01baf1c127192d694f1a7546f10e1156534408a91fb61e8e39d5e6830b4d320a
+  metadata.gz: 74ee4b6d1718cfef30a3ddfaaca2486f854c8c6db5c4b1fa63c1947f2ae3f2430e8ec67afd8dac052ff049df4d61c7f091b66a0080d187e51e58c4795534b66f
+  data.tar.gz: f01718b24e04fe024189d77cec858f0aad8ec88fac9de520ced36bf954863775e6c0ecb079d0831016fac2d863edec204c8a23bec82f304ecd2b8c4186c9ab5e

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,14 @@
 ## [Unreleased]
 
+## [0.4.0]
+
+- 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
+
 ## [0.2.1] - 2024-11-29
 
 - Fixed: Adjusted priority of factory names autocompletion

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
@@ -143,16 +145,18 @@ create.blog(with.article) # autocomplete to :blog_article
 
 </details>
 
+## Additional features
+
 ### `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 +171,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) }
@@ -176,6 +180,22 @@ 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/methods.rb

@@ -5,23 +5,6 @@ module FactoryBot
     # A <code>FactoryBot::Syntax::Methods</code> replacement to enable <code>factory_bot-with</code> features.
     module Methods
       include FactoryBot::Syntax::Methods
-
-      BUILD_STRATEGIES = %i[build build_stubbed create attributes_for with].freeze
-      VARIATIONS = {
-        unit: BUILD_STRATEGIES.to_h { [_1, _1] }.freeze,
-        pair: BUILD_STRATEGIES.to_h { [_1, :"#{_1}_pair"] }.freeze,
-        list: BUILD_STRATEGIES.to_h { [_1, :"#{_1}_list"] }.freeze,
-      }.freeze
-
-      VARIATIONS.each do |variation, build_strategies|
-        build_strategies.each do |build_strategy, method_name|
-          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)
-          end
-        end
-      end
     end
   end
 end

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.2.1"
+    VERSION = "0.4.0"
   end
 end

data/lib/factory_bot/with.rb

@@ -9,7 +9,7 @@ require_relative "with/methods"
 module FactoryBot
   # An intermediate state for <code>with</code> operator.
   class With
-    # @return [:unit, :pair, :list]
+    # @return [:singular, :pair, :list]
     attr_reader :variation
     # @return [Symbol]
     attr_reader :factory_name
@@ -24,7 +24,7 @@ module FactoryBot
 
     # @!visibility private
     def initialize(variation, factory_name, withes: [], traits: [], attrs: {}, &block)
-      raise ArgumentError unless %i[unit pair list].include? variation
+      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 }
       raise TypeError unless traits.is_a?(Array) && traits.all? { _1.is_a?(Symbol) || _1.is_a?(Numeric) }
@@ -59,18 +59,48 @@ module FactoryBot
         withes: [*withes, *other.withes],
         traits: [*traits, *other.traits],
         attrs: { **attrs, **other.attrs },
-        &self.class.merge_block(block, other.block)
+        &lambda do |first, second|
+          return first unless second
+          return second unless first
+
+          lambda do |*args|
+            first.call(*args)
+            second.call(*args)
+          end
+        end.call(block, other.block)
       )
     end
 
     # @!visibility private
-    # @param build_strategy [:build, :build_stubbed, :create, :attributes_for, :with]
+    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 = nil)
+    def instantiate(build_strategy, ancestors = self.class.scoped_ancestors)
       return self if build_strategy == :with
 
-      factory_bot_method = Methods::VARIATIONS[variation][build_strategy]
+      factory_bot_method =
+        variation == :singular ? build_strategy : :"#{build_strategy}_#{variation}"
       factory_name, attrs =
         if ancestors
           attrs = @attrs.dup
@@ -83,7 +113,7 @@ module FactoryBot
       result = FactoryBot.__send__(factory_bot_method, factory_name, *traits, **attrs, &block)
 
       unless withes.empty?
-        parents = variation == :unit ? [result] : result
+        parents = variation == :singular ? [result] : result
         assoc_info = AssocInfo.get(factory_name)
         parents.each do |parent|
           ancestors_for_children = [[assoc_info, parent], *ancestors || []]
@@ -96,51 +126,64 @@ module FactoryBot
 
     class << self
       # @!visibility private
-      # @param variation [:unit, :pair, :list]
+      # @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
 
-        with = new(variation, factory, &)
-        insert_args!(with, *)
-        with.attrs.merge!(**)
-        with
+        new(variation, factory, &).extend!(*, { ** })
       end
 
-      def insert_args!(with, *args)
-        args.each do |arg|
-          case arg
-          when self
-            with.withes << arg
-          when Symbol, Numeric
-            with.traits << arg
-          when Array
-            insert_args!(with, *arg)
-          when Hash
-            with.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}"
+      # If you want to use a custom strategy, call this along with <code>FactoryBot.register_strategy</code>.
+      # @param build_strategy [Symbol]
+      # @example
+      #   FactoryBot.register_strategy(:json, JsonStrategy)
+      #   FactoryBot::With.register_strategy(:json)
+      def register_strategy(build_strategy)
+        {
+          singular: build_strategy,
+          pair: :"#{build_strategy}_pair",
+          list: :"#{build_strategy}_list",
+        }.each do |variation, method_name|
+          Methods.define_method(method_name) do |factory = nil, *args, **kwargs, &block|
+            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?
+              # with(<factory_name>: <object>, ...) { ... }
+              With.with_scoped_ancestors(kwargs, &block)
+            else
+              raise ArgumentError, "Invalid use of #{__method__}"
+            end
           end
         end
       end
 
       # @!visibility private
-      # @param first [Proc, nil]
-      # @param second [Proc, nil]
-      # @return [Proc, nil]
-      def merge_block(first, second)
-        return first unless second
-        return second unless first
-
-        lambda do |*args|
-          first.call(*args)
-          second.call(*args)
-        end
+      # @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 }
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: factory_bot-with
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - yubrot
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-29 00:00:00.000000000 Z
+date: 2025-03-15 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