factory_bot-with 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a279f1170ba696ac48614f1c95572bf4be5a9b3f5ac5e47a3574813deafd5623
+  data.tar.gz: dddb6e8f841108fd70a80d509ea847a9daf6b0613111bf9977c8b79a6e32bf20
+SHA512:
+  metadata.gz: 2dc2904bb72bee299282e42f9daa0ba697e7c4eb7febd3475697ff0db2df89c03aa71c5bc55e2e97d2a786a3f3449b6666d68b643874a70bc32a5f6ef0a379ee
+  data.tar.gz: 3b322dbad72231b9e16e97113a3a300db5a88a90d2a67c06ef026711881c2de52f48ca0326810be0ab3e1ce7f57ca56d238a1070d6a78eca2ddf5d667dd226ea

data/.github/workflows/main.yml

@@ -0,0 +1,28 @@
+name: Ruby
+
+on:
+  push:
+    branches:
+      - main
+
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Ruby ${{ matrix.ruby }}
+    strategy:
+      matrix:
+        ruby:
+          - '3.3.6'
+          - '3.2.6'
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run the default task
+        run: bundle exec rake

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.solargraph.yml

@@ -0,0 +1,21 @@
+---
+include:
+- "**/*.rb"
+exclude:
+- spec/**/*
+- test/**/*
+- vendor/**/*
+- ".bundle/**/*"
+require: []
+domains: []
+reporters:
+- rubocop
+formatter:
+  rubocop:
+    cops: safe
+    except: []
+    only: []
+    extra_args: []
+require_paths: []
+plugins: []
+max_files: 5000

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-11-27
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 yubrot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,186 @@
+# FactoryBot::With
+
+FactoryBot::With is a FactoryBot extension that wraps `FactoryBot::Syntax::Methods` to make it a little easier to use.
+
+For example, with these factories:
+
+```ruby
+FactoryBot.define do
+  factory(:blog)
+  factory(:article) { blog }
+  factory(:comment) { article }
+end
+```
+
+Instead of writing like this:
+
+```ruby
+create(:blog) do |blog|
+  create(:article, blog:) { |article| create(:comment, article:) }
+  create(:article, blog:) { |article| create_list(:comment, 3, article:) }
+end
+```
+
+FactoryBot::With allows you to write:
+
+```ruby
+create.blog(
+  with.article(with.comment),
+  with.article(with_list.comment(3)),
+)
+```
+
+## Installation
+
+On your Gemfile:
+
+```ruby
+gem "factory_bot-with"
+```
+
+Then, instead of including `FactoryBot::Syntax::Methods`, include `FactoryBot::With::Methods`:
+
+```ruby
+# RSpec example
+RSpec.configure do |config|
+  # ...
+  config.include FactoryBot::With::Methods
+  # ...
+end
+```
+
+## What differs from `FactoryBot::Syntax::Methods`?
+
+### Method style syntax
+
+FactoryBot::With overrides the behavior when factory methods are called without arguments.
+
+```ruby
+create(:foo, ...)  # behaves in the same way as FactoryBot.create
+create             # returns a Proxy (an intermadiate) 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
+build_stubbed.foo(...)
+create_list.foo(10, ...)
+```
+
+### `with`, `with_pair`, and `with_list` operator
+
+FactoryBot::With provides a new operator `with` (and its family).
+
+```ruby
+with(:factory_name, ...)
+with_pair(:factory_name, ...)
+with_list(:factory_name, number_of_items, ...)
+```
+
+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.
+
+```ruby
+create.blog(with.article)
+# is equivalent to ...
+blog = create.blog
+create.article(blog:)
+```
+
+The overridden factory methods collect these `with` arguments before delegating object creation to the actual factory methods.
+
+<details>
+<summary>Automatic association resolution</summary>
+
+`with` automatically resolves references to ancestor objects based on the definition of the FactoryBot associations.
+
+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.
+
+```ruby
+FactoryBot.define do
+  factory(:video)
+  factory(:photo)
+  factory(:tag) do
+    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"))  # ...
+```
+
+Due to technical limitations, [inline associations](https://thoughtbot.github.io/factory_bot/associations/inline-definition.html) cannot be resolved.
+
+</details>
+
+<details>
+<summary>Autocomplete fully-qualified factory name</summary>
+
+For a factory name that is prefixed by the parent object's factory name, the prefix can be omitted.
+
+```ruby
+FactoryBot.define do
+  factory(:blog)
+  factory(:blog_article) { blog }
+end
+
+create.blog(with.article) # autocomplete to :blog_article
+```
+
+</details>
+
+### `with` as a template
+
+`with` can also be used stand-alone. 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) { {} }
+
+context "when published more than one year ago" do
+  let(:story_args) { [*super(), :published] }
+  let(:story_kwargs) { { **super(), start_at: 2.year.ago } }
+
+  # ...
+end
+```
+
+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 }
+
+context "when published more than one year ago" do
+  let(:story_template) { with(super(), :published, start_at: 2.year.ago) }
+
+  # ...
+end
+```
+
+## Development
+
+```bash
+git clone https://github.com/yubrot/factory_bot-with
+cd gems/factory_bot-with
+bin/setup
+bundle exec rake --tasks
+bundle exec rake
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/yubrot/factory_bot-with. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/yubrot/factory_bot-with/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the FactoryBot::With project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/yubrot/factory_bot-with/blob/main/CODE_OF_CONDUCT.md).

data/lib/factory_bot/with/assoc_info.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module FactoryBot
+  class With
+    # An association information of a FactoryBot factory.
+    class AssocInfo
+      # @return [Set<Symbol>] List of factory names to be considered compatible with this factory
+      attr_reader :factory_names
+      # @return [{Symbol => Symbol}] a map from factory names to association names
+      attr_reader :map
+
+      # @!visibility private
+      def initialize(factory_names, map)
+        unless factory_names.is_a?(Set) && factory_names.all? { _1.is_a?(Symbol) }
+          raise ArgumentError, "factory_names must be a Set of Symbols"
+        end
+        unless map.is_a?(Hash) && map.all? { _1.is_a?(Symbol) && _2.is_a?(Symbol) }
+          raise ArgumentError, "map must be a Hash of Symbol"
+        end
+
+        @factory_names = factory_names
+        @map = map
+      end
+
+      # @param ancestors [Array<Array(AssocInfo, Object)>]
+      # @param dest [{Symbol => Object}]
+      def perform_automatic_association_resolution(ancestors, dest)
+        priorities = {}
+        map.each do |factory_name, attribute|
+          # skip if this attribute is explicitly specified
+          next if dest.member?(attribute) && !priorities.member?(attribute)
+
+          # closer ancestors have higher (lower integer) priority
+          ancestor, priority = ancestors.each_with_index.find do |(ancestor_assoc_info, _), _|
+            ancestor_assoc_info.factory_names.include?(factory_name)
+          end
+          next if !ancestor || priorities.fetch(attribute, Float::INFINITY) <= priority
+
+          priorities[attribute] = priority
+          dest[attribute] = ancestor[1]
+        end
+      end
+
+      class << self
+        # @param ancestors [Array<Array(AssocInfo, Object)>]
+        # @param partial_factory_name [Symbol]
+        # @return [Symbol]
+        def autocomplete_fully_qualified_factory_name(ancestors, partial_factory_name)
+          return partial_factory_name if exists?(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}"
+              return factory_name if exists?(factory_name)
+            end
+          end
+
+          raise ArgumentError, "FactoryBot factory #{partial_factory_name} is not defined"
+        end
+
+        # @param factory_name [Symbol]
+        # @return [Boolean]
+        def exists?(factory_name)
+          !!cache.fetch(factory_name) { FactoryBot.factories.registered?(factory_name) }
+        end
+
+        # @param factory_name [Symbol]
+        # @return [AssocInfo]
+        def get(factory_name)
+          cache.fetch(factory_name) { cache[factory_name] = from_factory_bot_factory(factory_name) }
+        end
+
+        # @param factory_name [Symbol]
+        # @return [AssocInfo]
+        def from_factory_bot_factory(factory_name)
+          unless FactoryBot.factories.registered?(factory_name)
+            raise ArgumentError, "FactoryBot factory #{factory_name} is not defined"
+          end
+
+          factory = FactoryBot.factories.find(factory_name)
+
+          # NOTE: We consider aliases to be incompatible with each other
+          factory_names = Set[factory_name]
+          map = {}
+          while factory.is_a?(FactoryBot::Factory)
+            factory_names << factory.name
+            # Here, we use reverse_each to prioritize the upper association
+            factory.with_traits(factory.defined_traits.map(&:name)).associations.reverse_each do |assoc|
+              map[Array(assoc.factory)[0].to_sym] = assoc.name
+            end
+
+            factory = factory.__send__(:parent)
+          end
+
+          new(factory_names, map)
+        end
+
+        # @return [{Symbol => AssocInfo}]
+        def cache = @cache ||= {}
+      end
+    end
+  end
+end

data/lib/factory_bot/with/methods.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module FactoryBot
+  class With
+    # 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 =
+              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)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/factory_bot/with/proxy.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module FactoryBot
+  class With
+    # An intermediate object to provide some notation combined with <code>method_missing</code>.
+    # @example
+    #   class Foo
+    #     def foo(name = nil)
+    #       return FactoryBot::With::Proxy.new(self, __method__) unless name
+    #
+    #       name
+    #     end
+    #   end
+    #
+    #   Foo.new.foo.bar #=> :bar
+    class Proxy < BasicObject
+      # @param receiver [Object]
+      # @param method [Symbol]
+      # @param preargs [Array]
+      def initialize(receiver, method, *preargs)
+        @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
+    end
+  end
+end

data/lib/factory_bot/with/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module FactoryBot
+  class With
+    VERSION = "0.1.0"
+  end
+end

data/lib/factory_bot/with.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "factory_bot"
+require_relative "with/version"
+require_relative "with/proxy"
+require_relative "with/assoc_info"
+require_relative "with/methods"
+
+module FactoryBot
+  # An intermediate state for <code>with</code> operator.
+  class With
+    # @return [:unit, :pair, :list]
+    attr_reader :variation
+    # @return [Symbol]
+    attr_reader :factory_name
+    # @return [Array<With>]
+    attr_reader :withes
+    # @return [Array<Object>]
+    attr_reader :args
+    # @return [{Symbol => Object}]
+    attr_reader :kwargs
+    # @return [Proc, nil]
+    attr_reader :block
+
+    # @!visibility private
+    def initialize(variation, factory_name, *args, **kwargs, &block)
+      @variation = variation
+      @factory_name = factory_name
+      @withes, @args = args.partition { _1.is_a? self.class }
+      @kwargs = kwargs
+      @block = block
+    end
+
+    # @!visibility private
+    # @return [Boolean]
+    def plain? = withes.empty? && args.empty? && kwargs.empty? && block.nil?
+
+    # @!visibility private
+    # @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 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
+
+      return self if other.plain?
+      return other if plain?
+
+      self.class.new(
+        variation,
+        factory_name,
+        *args, *other.args, *withes, *other.withes,
+        **kwargs, **other.kwargs,
+        &self.class.merge_block(block, other.block)
+      )
+    end
+
+    # @!visibility private
+    # @param build_strategy [:build, :build_stubbed, :create, :attributes_for, :with]
+    # @param ancestors [Array<Array(AssocInfo, Object)>, nil]
+    # @return [Object]
+    def instantiate(build_strategy, ancestors = nil)
+      return self if build_strategy == :with
+
+      factory_bot_method = Methods::VARIATIONS[variation][build_strategy]
+      factory_name, kwargs =
+        if ancestors
+          kwargs = @kwargs.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]
+        else
+          [@factory_name, @kwargs]
+        end
+      result = FactoryBot.__send__(factory_bot_method, factory_name, *args, **kwargs, &block)
+
+      unless withes.empty?
+        parents = variation == :unit ? [result] : result
+        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) }
+        end
+      end
+
+      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
+
+      lambda do |*args|
+        first.call(*args)
+        second.call(*args)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: factory_bot-with
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- yubrot
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: FactoryBot extension that wraps FactoryBot::Syntax::Methods to make it
+  a little easier to use
+email:
+- yubrot@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".solargraph.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- lib/factory_bot/with.rb
+- lib/factory_bot/with/assoc_info.rb
+- lib/factory_bot/with/methods.rb
+- lib/factory_bot/with/proxy.rb
+- lib/factory_bot/with/version.rb
+homepage: https://github.com/yubrot/factory_bot-with
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/yubrot/factory_bot-with
+  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
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key:
+specification_version: 4
+summary: FactoryBot extension that wraps FactoryBot::Syntax::Methods to make it a
+  little easier to use
+test_files: []