factory_bot-with 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a279f1170ba696ac48614f1c95572bf4be5a9b3f5ac5e47a3574813deafd5623
-  data.tar.gz: dddb6e8f841108fd70a80d509ea847a9daf6b0613111bf9977c8b79a6e32bf20
+  metadata.gz: 01b5be917f74ffbdc5643be7bb5f9c9e7f1009484f688a8442aed6dda8dc5a0b
+  data.tar.gz: d773865f81b4aad3e87dea573db938b5393f0ecc988b5810b827741051ee6864
 SHA512:
-  metadata.gz: 2dc2904bb72bee299282e42f9daa0ba697e7c4eb7febd3475697ff0db2df89c03aa71c5bc55e2e97d2a786a3f3449b6666d68b643874a70bc32a5f6ef0a379ee
-  data.tar.gz: 3b322dbad72231b9e16e97113a3a300db5a88a90d2a67c06ef026711881c2de52f48ca0326810be0ab3e1ce7f57ca56d238a1070d6a78eca2ddf5d667dd226ea
+  metadata.gz: 93c900afe0c21747d9837a5c8e1b31b11a7ae3e127873cdf86f43f5f83fac4ba10be0295e7b43542d3399a78be377fd240f57a9251a8433471015767170d96a5
+  data.tar.gz: 1af4669b1afb19783332b2bed70d7cb76d210bb205766dcc3aae06bd07de0a4a614da1aadc0841e6cca0bf8c3b3965241a05703a898172a0c575ddcd93f8d273

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.2.0] - 2024-11-29
+
+- Fixed: Fixed an incorrect factory resolution problem after factory names autocompletion
+- Added: Smarter interpretation of positional arguments passed to factory methods
+
 ## [0.1.0] - 2024-11-27
 
 - Initial release

data/README.md

@@ -1,5 +1,8 @@
 # FactoryBot::With
 
+[![](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.
 
 For example, with these factories:
@@ -68,6 +71,16 @@ 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.
+
+```ruby
+create.foo({ title: "Recipe" }, is_new && %i[latest hot])
+#=> create(:foo, :latest, :hot, title: "Recipe")  if is_new
+#   create(:foo, title: "Recipe")                 otherwise
+```
+
 ### `with`, `with_pair`, and `with_list` operator
 
 FactoryBot::With provides a new operator `with` (and its family).

data/lib/factory_bot/with/methods.rb

@@ -18,14 +18,7 @@ module FactoryBot
           define_method(method_name) do |factory = nil, *args, **kwargs, &block|
             return Proxy.new(self, __method__) unless factory
 
-            with =
-              if factory.is_a? With
-                factory.merge(With.new(variation, factory.factory_name, *args, **kwargs, &block))
-              else
-                With.new(variation, factory, *args, **kwargs, &block)
-              end
-
-            with.instantiate(build_strategy)
+            With.build(variation, factory, *args, **kwargs, &block).instantiate(build_strategy)
           end
         end
       end

data/lib/factory_bot/with/version.rb

@@ -2,6 +2,6 @@
 
 module FactoryBot
   class With
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/factory_bot/with.rb

@@ -15,25 +15,32 @@ module FactoryBot
     attr_reader :factory_name
     # @return [Array<With>]
     attr_reader :withes
-    # @return [Array<Object>]
-    attr_reader :args
+    # @return [Array<Numeric, Symbol>] Numeric is also treated as a trait for convenience
+    attr_reader :traits
     # @return [{Symbol => Object}]
-    attr_reader :kwargs
+    attr_reader :attrs
     # @return [Proc, nil]
     attr_reader :block
 
     # @!visibility private
-    def initialize(variation, factory_name, *args, **kwargs, &block)
+    def initialize(variation, factory_name, withes: [], traits: [], attrs: {}, &block)
+      raise ArgumentError unless %i[unit 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) }
+      raise TypeError unless attrs.is_a?(Hash) && attrs.keys.all? { _1.is_a? Symbol }
+
       @variation = variation
       @factory_name = factory_name
-      @withes, @args = args.partition { _1.is_a? self.class }
-      @kwargs = kwargs
+      @withes = withes
+      @traits = traits
+      @attrs = attrs
       @block = block
     end
 
     # @!visibility private
     # @return [Boolean]
-    def plain? = withes.empty? && args.empty? && kwargs.empty? && block.nil?
+    def plain? = withes.empty? && traits.empty? && attrs.empty? && block.nil?
 
     # @!visibility private
     # @param other [With]
@@ -49,8 +56,9 @@ module FactoryBot
       self.class.new(
         variation,
         factory_name,
-        *args, *other.args, *withes, *other.withes,
-        **kwargs, **other.kwargs,
+        withes: [*withes, *other.withes],
+        traits: [*traits, *other.traits],
+        attrs: { **attrs, **other.attrs },
         &self.class.merge_block(block, other.block)
       )
     end
@@ -63,20 +71,20 @@ module FactoryBot
       return self if build_strategy == :with
 
       factory_bot_method = Methods::VARIATIONS[variation][build_strategy]
-      factory_name, kwargs =
+      factory_name, attrs =
         if ancestors
-          kwargs = @kwargs.dup
+          attrs = @attrs.dup
           factory_name = AssocInfo.autocomplete_fully_qualified_factory_name(ancestors, @factory_name)
-          AssocInfo.get(factory_name).perform_automatic_association_resolution(ancestors, kwargs)
-          [factory_name, kwargs]
+          AssocInfo.get(factory_name).perform_automatic_association_resolution(ancestors, attrs)
+          [factory_name, attrs]
         else
-          [@factory_name, @kwargs]
+          [@factory_name, @attrs]
         end
-      result = FactoryBot.__send__(factory_bot_method, factory_name, *args, **kwargs, &block)
+      result = FactoryBot.__send__(factory_bot_method, factory_name, *traits, **attrs, &block)
 
       unless withes.empty?
         parents = variation == :unit ? [result] : result
-        assoc_info = AssocInfo.get(@factory_name)
+        assoc_info = AssocInfo.get(factory_name)
         parents.each do |parent|
           ancestors_for_children = [[assoc_info, parent], *ancestors || []]
           withes.each { _1.instantiate(build_strategy, ancestors_for_children) }
@@ -86,17 +94,52 @@ module FactoryBot
       result
     end
 
-    # @!visibility private
-    # @param first [Proc, nil]
-    # @param second [Proc, nil]
-    # @return [Proc, nil]
-    def self.merge_block(first, second)
-      return first unless second
-      return second unless first
+    class << self
+      # @!visibility private
+      # @param variation [:unit, :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
+      end
 
-      lambda do |*args|
-        first.call(*args)
-        second.call(*args)
+      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}"
+          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
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: factory_bot-with
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - yubrot
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-27 00:00:00.000000000 Z
+date: 2024-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: factory_bot
@@ -67,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: FactoryBot extension that wraps FactoryBot::Syntax::Methods to make it a