factory_bot-with 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa2396f8ce3d44a17caacc293e2b5914b781eb167c50de541c2950b6f3e8ce0f
-  data.tar.gz: a5b0e4b93ba6f97439dd25290c2ab5c3832175799e7e45f538e0c9db28be14bf
+  metadata.gz: ab9e29f43a809164761618a28339cd98f4c26060183045f79dcd52cc107ee3aa
+  data.tar.gz: 2c4814ce52ed94f4120077410519424a19aa8b590a2af571429aadb059f59687
 SHA512:
-  metadata.gz: a655f59ca867e26316fb08d3fd80e9352d4cefeb600c9d324de89358096a031e549acc5d98da43d67f608f615084bfc384a4c8d45f9e528891d4f90f9fe9de5f
-  data.tar.gz: 4709882eea9a1a90e6719a44133d66e1de9c189da2c602963f77b9c80b14952b99dbd2b350085d496f15cf70f20bbbce4edc1a5a37b2dcf9272d244be31d7589
+  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,5 +1,10 @@
 ## [Unreleased]
 
+## [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

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(: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,70 +144,80 @@ 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>
 
-## Additional features
-
-### `with` scope syntax for automatic association resolution
+### Implicit context scope
 
-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.
+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
-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))
+# 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
 ```
 
-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>
+<summary>Incompatible behavior when calling <code>_list</code> or <code>_pair</code> factory methods with a block</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`.
+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 creates a blog with 2 articles, each with 1 comment
-# plain factory_bot:
+# 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 in plain factory_bot
+  create_list(:article, 2, blog:) do |articles| # yielded *once* with an array of articles
     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
+# 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
 
-# with as a scope syntax for existing blog:
-blog = create.blog
-with(blog:) do
-  create_list.article(2) { create.comment }
+# 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
+
+### Implicit context scope with existing objects
+
+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:
 
-# with_list can also be used as a scope syntax:
+```ruby
 blog = create.blog
 articles = create_list.article(2, blog:)
 with_list(article: articles) { create.comment } # yielded *for each article*
@@ -211,9 +225,9 @@ with_list(article: articles) { create.comment } # yielded *for each article*
 
 </details>
 
-### `with` as a template
+### `with` as a factory method call 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.
+A `With` instance can also be used as a template for factory method calls.
 
 Instead of writing:
 

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.5.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
 
@@ -71,32 +76,11 @@ module FactoryBot
       )
     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,7 +88,7 @@ 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
@@ -120,25 +104,35 @@ module FactoryBot
           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
+          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
@@ -151,57 +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? && block
               # with(<factory_name>: <object>, ...) { ... }
-              block = With.call_with_scope_adapter(&block)
-              With.call_with_scope(kwargs, &block)
+              Scoped.block(&block).call(kwargs)
             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) }
+              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
-      # @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,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: factory_bot-with
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - yubrot
 bindir: exe
 cert_chain: []
-date: 2025-03-20 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: []