factrey 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 30e4d58ea43d66a45f4d22cb563acaa3a5f7811d09cd6e7bb3a6f617c57f4223
+  data.tar.gz: a0ba9e04f9d0a387d3cf643e27c7ae8d7ace5529c5dd7bca75f0ae7cbe3d1819
+SHA512:
+  metadata.gz: 765c317be9294d3837c19e172ef05093b16b08d6903313f43ffaeeec9d39dc9e46e08fca2d07dddde9010595909f44bebe8cdcd735d8dd5f940760c6226fe829
+  data.tar.gz: 2fcc20ada4f208d4341cc5165241349690bb08131eb18e11b7623ff9ed8374326fc79012f88ec4b2429870175f33ac029a644b5ba67806f17f84809118a2dd54

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,10 @@
+# `factrey` gem
+
+This is a part of [FactoryBot::Blueprint](https://github.com/yubrot/factory_bot-blueprint) library.
+
+Factrey provides a declarative DSL to represent the creation plan of objects, for FactoryBot::Blueprint.
+The name Factrey is derived from the words factory and tree.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/factrey/blueprint/instantiator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Factrey
+  class Blueprint
+    # An internal class used by {Blueprint#instantiate}.
+    class Instantiator
+      # @return [Hash{Symbol => Object}]
+      attr_reader :objects
+
+      # @param context [Object]
+      # @param blueprint [Blueprint]
+      def initialize(context, blueprint)
+        @context = context
+        @objects = {}
+        @visited = Set.new
+        @blueprint = blueprint
+      end
+
+      # @param node [Node]
+      # @return [Object]
+      def visit(node)
+        @objects.fetch(node.name) do
+          unless @visited.add?(node.name)
+            raise ArgumentError, "Circular references detected around #{node.type_annotated_name}"
+          end
+
+          @objects[node.name] = instantiate_object(node)
+        end
+      end
+
+      private
+
+      # @param node [Node]
+      # @return [Object]
+      def instantiate_object(node)
+        resolver = Ref::Resolver.new(recursion_limit: 5) do |name|
+          visit(
+            @blueprint.nodes.fetch(name) do
+              raise ArgumentError, "Missing definition #{name} around #{node.type_annotated_name}"
+            end,
+          )
+        end
+
+        args = resolver.resolve(node.args)
+        kwargs = resolver.resolve(node.kwargs)
+
+        # Resolve auto references to the ancestors
+        auto_references = {}
+        node.type.auto_references.each do |type_name, attribute|
+          next if kwargs.member? attribute # explicitly specified
+
+          compatible_ancestor, index = node.ancestors.reverse_each.with_index.find do |ancestor, _|
+            ancestor.type.compatible_types.include?(type_name)
+          end
+          next unless compatible_ancestor
+          next if auto_references.member?(attribute) && auto_references[attribute][1] <= index
+
+          auto_references[attribute] = [compatible_ancestor, index]
+        end
+        auto_references.each { |attribute, (ancestor, _)| kwargs[attribute] = visit(ancestor) }
+
+        node.type.factory.call(node.type, @context, *args, **kwargs)
+      end
+    end
+  end
+end

data/lib/factrey/blueprint/node.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Factrey
+  class Blueprint
+    # A node corresponds to an object to be created. A {Blueprint} consists of a set of nodes.
+    class Node
+      ANONYMOUS_NAME_PREFIX = "_anon_"
+
+      # @return [Symbol] name given to the object to be created
+      attr_reader :name
+      # @return [Type] type of the object
+      attr_reader :type
+      # @return [Array<Node>] list of ancestor nodes, from root to terminal nodes
+      attr_reader :ancestors
+      # @return [Array<Object>] positional arguments to be passed to the factory
+      attr_reader :args
+      # @return [Hash{Object => Object}] keyword arguments to be passed to the factory
+      attr_reader :kwargs
+
+      def initialize(name, type, ancestors: [], args: [], kwargs: {})
+        raise TypeError, "name must be a Symbol" if name && !name.is_a?(Symbol)
+        raise TypeError, "type must be a Blueprint::Type" unless type.is_a? Blueprint::Type
+        unless ancestors.is_a?(Array) && ancestors.all? { _1.is_a?(Node) }
+          raise TypeError, "ancestors must be an Array of Nodes"
+        end
+        raise TypeError, "args must be an Array" unless args.is_a? Array
+        raise TypeError, "kwargs must be a Hash" unless kwargs.is_a? Hash
+
+        @name = name || :"#{ANONYMOUS_NAME_PREFIX}#{SecureRandom.hex(6)}"
+        @type = type
+        @ancestors = ancestors
+        @args = args
+        @kwargs = kwargs
+      end
+
+      # @return [Boolean]
+      def root? = ancestors.empty?
+
+      # @return [Boolean]
+      def anonymous? = name.start_with?(ANONYMOUS_NAME_PREFIX)
+
+      # Used for debugging and error reporting.
+      # @return [String]
+      def type_annotated_name = "#{name}(#{type.name})"
+    end
+  end
+end

data/lib/factrey/blueprint/type.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Factrey
+  class Blueprint
+    # A type representation on Factrey blueprints.
+    # This definition includes how the actual object is created ({#factory}) and
+    # what other types the object refers to ({#auto_references}).
+    class Type
+      # @return [Symbol] the name of this type. It is also used as the default object name at instantiation phase
+      attr_reader :name
+      # @return [Set<Symbol>] List of type names to be considered compatible with this type
+      attr_reader :compatible_types
+      # @return [Hash{Symbol => Symbol}] a name-to-attribute mapping for auto-referencing
+      attr_reader :auto_references
+      # @return [Proc] procedure that actually creates an object. See {Blueprint::Instantiator} implementation
+      attr_reader :factory
+
+      # @param name [Symbol]
+      # @param compatible_types [Array<Symbol>, Symbol]
+      # @param auto_references [Hash{Symbol => Symbol}, Array<Symbol>, Symbol]
+      # @yield [type, context, *args, **kwargs]
+      def initialize(name, compatible_types: [], auto_references: {}, &factory)
+        compatible_types = [compatible_types] if compatible_types.is_a? Symbol
+        auto_references = [auto_references] if auto_references.is_a? Symbol
+        auto_references = auto_references.to_h { [_1, _1] } if auto_references.is_a? Array
+
+        raise TypeError, "name must be a Symbol" unless name.is_a? Symbol
+        unless compatible_types.is_a?(Array) && compatible_types.all? { _1.is_a?(Symbol) }
+          raise TypeError, "compatible_types must be an Array of Symbols"
+        end
+        unless auto_references.is_a?(Hash) && auto_references.all? { |k, v| k.is_a?(Symbol) && v.is_a?(Symbol) }
+          raise TypeError, "auto_references must be a Hash containing Symbol keys and values"
+        end
+        raise ArgumentError, "factory must be provided" unless factory
+
+        compatible_types = [name] + compatible_types unless compatible_types.include? name
+
+        @name = name
+        @compatible_types = Set.new(compatible_types).freeze
+        @auto_references = auto_references.freeze
+        @factory = factory
+      end
+    end
+  end
+end

data/lib/factrey/blueprint.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "blueprint/type"
+require_relative "blueprint/node"
+require_relative "blueprint/instantiator"
+
+module Factrey
+  # Represents how to create a set of objects.
+  # {Blueprint} can be created and extended by the Blueprint DSL. See {Factrey.blueprint}.
+  class Blueprint
+    # @return [Hash{Symbol => Node}] a set of nodes
+    attr_reader :nodes
+
+    # Creates an empty blueprint.
+    def initialize
+      @nodes = {}
+    end
+
+    # @return [Blueprint]
+    def dup
+      result = self.class.new
+
+      nodes.each_value do |node|
+        result.add_node(
+          node.name,
+          node.type,
+          # This is OK since Hash insertion order in Ruby is retained
+          ancestors: node.ancestors.map { result.nodes[_1.name] },
+          args: node.args.dup,
+          kwargs: node.kwargs.dup,
+        )
+      end
+
+      result
+    end
+
+    # Get the last root node.
+    # @return [Node, nil]
+    def representative_node = nodes.each_value.reverse_each.find(&:root?)
+
+    # Add a node. This method is used by {DSL} and usually does not need to be called directly.
+    # @return [Node]
+    def add_node(...)
+      node = Node.new(...)
+      raise ArgumentError, "duplicate node: #{node.name}" if nodes.member?(node.name)
+
+      nodes[node.name] = node
+      node
+    end
+
+    # Create a set of objects based on this blueprint.
+    # @param context [Object] context object to be passed to the factories
+    # @return [Hash{Symbol => Object}]
+    def instantiate(context = nil)
+      instantiator = Instantiator.new(context, self)
+
+      nodes.each_value { instantiator.visit(_1) }
+
+      instantiator.objects
+    end
+  end
+end

data/lib/factrey/dsl/let.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Factrey
+  class DSL
+    # An intermediate object for <code>let(:name).node(...)</code> notation. See {DSL#let}.
+    class Let < BasicObject
+      attr_reader :name
+
+      # @param dsl [DSL]
+      # @param name [Symbol, nil]
+      def initialize(dsl, name)
+        @dsl = dsl
+        @name = name
+      end
+
+      # @!visibility private
+      def respond_to_missing?(_method_name, _) = true
+
+      def method_missing(method_name, ...) = @dsl.let(@name) { @dsl.__send__(method_name, ...) }
+    end
+  end
+end

data/lib/factrey/dsl/on.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Factrey
+  class DSL
+    # An intermediate object for <code>on.name(...)</code> notation. See {DSL#on}.
+    class On < BasicObject
+      # @param dsl [DSL]
+      def initialize(dsl) = @dsl = dsl
+
+      # @!visibility private
+      def respond_to_missing?(_name, _) = true
+
+      def method_missing(name, ...) = @dsl.on(name, ...)
+    end
+  end
+end

data/lib/factrey/dsl.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "set"
+require "securerandom"
+
+require_relative "dsl/let"
+require_relative "dsl/on"
+
+module Factrey
+  # {Blueprint} DSL implementation.
+  class DSL
+    # Methods reserved for DSL.
+    RESERVED_METHODS = %i[
+      ref ext let let_default_name node on type args
+      __send__ __id__ nil? object_id class instance_exec initialize block_given? raise
+    ].to_set.freeze
+
+    (instance_methods + private_instance_methods).each do |method|
+      undef_method(method) unless RESERVED_METHODS.include?(method)
+    end
+
+    # @param blueprint [Blueprint]
+    # @param ext [Object]
+    def initialize(blueprint:, ext:)
+      @blueprint = blueprint
+      @ext = ext
+      @ancestors = []
+    end
+
+    include Ref::ShorthandMethods
+
+    # @return [Object] the external object passed to {Factrey.blueprint}
+    attr_reader :ext
+
+    # By preceding <code>let(name).</code> to the declaration, give a name to the node.
+    # @param name [Symbol, nil] defaults to {Blueprint::Type#name} if omitted
+    # @return [Let]
+    # @example
+    #   bp =
+    #     Factrey.blueprint do
+    #       article                 # no meaningful name is given (See Blueprint::Node#anonymous?)
+    #       let.article             # named as article
+    #       let(:article2).article  # named as article2
+    #     end
+    #   bp.instantiate              #=> { article: ..., article2: ..., ... }
+    def let(name = nil, &)
+      raise TypeError, "name must be a Symbol" if name && !name.is_a?(Symbol)
+      raise ArgumentError, "nested let" if @let_scope
+
+      let = Let.new(self, name)
+      return let unless block_given?
+
+      @let_scope = let
+      ret = yield
+      @let_scope = nil
+      ret
+    end
+
+    # Overrides the default name given by {#let}.
+    #
+    # This method does nothing if it is not preceded by {#let}.
+    # @param name [Symbol]
+    # @return [Let, Blueprint]
+    # @example
+    #   class Factrey::DSL do
+    #     # Define a shortcut method for user(:admin)
+    #     def admin_user(...) = let_default_name(:admin_user).user(:admin, ...)
+    #   end
+    #   Factrey.blueprint do
+    #     admin_user              # no meaningful name is given (See Blueprint::Node#anonymous?)
+    #     let.admin_user          # named as admin_user
+    #     let(:user2).admin_user  # named as user2
+    #   end
+    def let_default_name(name, &)
+      raise TypeError, "name must be a Symbol" unless name.is_a?(Symbol)
+
+      if @let_scope && @let_scope.name.nil?
+        @let_scope = nil # consumed
+
+        let(name, &)
+      else
+        return self unless block_given?
+
+        yield
+      end
+    end
+
+    # Add a node to the blueprint.
+    #
+    # This method is usually not called directly. Use the shorthand method defined by {.add_type} instead.
+    # @param type [Blueprint::Type]
+    def node(type, ...)
+      name = @let_scope ? (@let_scope.name || type.name) : nil
+      @let_scope = nil # consumed
+
+      node = @blueprint.add_node(name, type, ancestors: @ancestors)
+      on(node.name, ...)
+    end
+
+    # Enter the node to configure arguments and child nodes.
+    # @example
+    #   Factrey.blueprint do
+    #     let.blog do
+    #       let(:article1).article
+    #       let(:article2).article
+    #     end
+    #
+    #     # Add article to `blog`
+    #     on.blog { let(:article3).article }
+    #     # Add title to `article2`
+    #     on.article2(title: "This is an article 2")
+    #   end
+    def on(name = nil, ...)
+      return On.new(self) if name.nil? && !block_given?
+
+      node = @blueprint.nodes[name]
+      raise ArgumentError, "unknown node: #{name}" unless node
+
+      stashed_ancestors = @ancestors
+      @ancestors = node.ancestors + [node]
+      args(...)
+      @ancestors = stashed_ancestors
+      node
+    end
+
+    # Add arguments to the current node.
+    # @example
+    #   Factrey.blueprint do
+    #     let.blog
+    #
+    #     # The following two lines are equivalent:
+    #     on.blog { args :premium, title: "Who-ha" }
+    #     on.blog(:premium, title: "Who-ha")
+    #   end
+    def args(*args, **kwargs)
+      raise NameError, "Cannot use args at toplevel" if @ancestors.empty?
+
+      @ancestors.last.args.concat(args)
+      @ancestors.last.kwargs.update(kwargs)
+      yield if block_given?
+    end
+
+    class << self
+      # @return [Hash{Symbol => Type}] the types defined in this DSL
+      def types
+        @types ||= {}
+      end
+
+      # Add a new type that will be available in this DSL.
+      # A helper method with the same name as the type name is also defined in the DSL. For example,
+      # if you have added the <code>foo</code> type, you can declare node with <code>#foo</code>.
+      #
+      # {.add_type} is called automatically when you use <code>factory_bot-blueprint</code> gem.
+      # @param type [Blueprint::Type] blueprint type
+      # @example
+      #   factory = ->(type, _ctx, *args, **kwargs) { FactoryBot.create(type.name, *args, **kwargs) }
+      #   Factrey::DSL.add_type(Factrey::Blueprint::Type.new(:blog, &factory))
+      #   Factrey::DSL.add_type(Factrey::Blueprint::Type.new(:article, auto_references: :blog, &factory))
+      #
+      #   Factrey.blueprint do
+      #     blog do
+      #       article(title: "Article 1")
+      #       article(title: "Article 2")
+      #     end
+      #   end
+      def add_type(type)
+        if RESERVED_METHODS.member? type.name
+          raise ArgumentError, "Cannot use reserved method name '#{type.name}' for type name"
+        end
+
+        if types.member? type.name
+          raise ArgumentError, "duplicate type definition: #{type.name}" if types[type.name] != type
+
+          return
+        end
+
+        types[type.name] = type
+        define_method(type.name) { |*args, **kwargs, &block| node(type, *args, **kwargs, &block) }
+      end
+    end
+  end
+end

data/lib/factrey/ref/builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Factrey
+  class Ref
+    # An intermediate object for creating {Ref}s. See {ShorthandMethods#ref}.
+    class Builder < BasicObject
+      # @!visibility private
+      def respond_to_missing?(_name, _) = true
+
+      # @example
+      #   ref = Factrey::Ref::Builder.new
+      #   ref.hoge # same as Factrey::Ref.new(:hoge)
+      # @return [Ref]
+      def method_missing(name) = Ref.new(name)
+    end
+  end
+end

data/lib/factrey/ref/defer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Factrey
+  class Ref
+    # A thin wrapper around {Proc} to represent the procedure using the results of the reference resolution.
+    # Each argument name is considered as a reference.
+    # These references are resolved and the results are passed to the {Proc}.
+    #
+    # {Ref}s and {Defer}s are usually created through {ShorthandMethods#ref}.
+    class Defer
+      # @return [Proc]
+      attr_reader :body
+
+      # @return [Array<Ref>]
+      def refs = @body.parameters.map { Ref.new(_1[1]) }
+
+      # @example
+      #   Factrey::Ref::Defer.new { |foo, bar| foo + bar }
+      def initialize(&body)
+        body.parameters.all? { _1[0] == :req || _1[0] == :opt } or
+          raise ArgumentError, "block must take only fixed positional arguments"
+
+        @body = body
+      end
+    end
+  end
+end

data/lib/factrey/ref/resolver.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Factrey
+  class Ref
+    # {Resolver} resolves {Ref}s and {Defer}s.
+    class Resolver
+      # @param recursion_limit [Integer, nil] how many recursions are allowed
+      # @yieldparam name [Symbol] the name of the reference to be resolved
+      def initialize(recursion_limit: nil, &handler)
+        @recursion_limit = recursion_limit
+        @handler = handler
+      end
+
+      # Traverse data recursively and resolve all {Ref}s and {Defer}s.
+      #
+      # This method supports recursive traversal for {Array} and {Hash}. For other structures, consider using {Defer}.
+      # @param object [Object]
+      # @param recursion_count [Integer]
+      def resolve(object, recursion_count: 0)
+        return object if !@recursion_limit.nil? && @recursion_limit < recursion_count
+
+        recursion_count += 1
+        case object
+        when Array
+          object.map { resolve(_1, recursion_count:) }
+        when Hash
+          object.to_h { |key, value| [resolve(key, recursion_count:), resolve(value, recursion_count:)] }
+        when Ref
+          @handler.call(object.name)
+        when Defer
+          object.body.call(*object.refs.map { resolve(_1) })
+        else
+          object
+        end
+      end
+    end
+  end
+end

data/lib/factrey/ref/shorthand_methods.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Factrey
+  class Ref
+    # Provides shorthand methods for creating {Ref}s and {Defer}s.
+    module ShorthandMethods
+      # @return [Ref, Builder, Defer]
+      # @example
+      #   include Factrey::Ref::ShorthandMethods
+      #
+      #   # `ref(symbol)` returns a `Ref` instance
+      #   ref(:foo)
+      #   # `ref` returns a `Ref::Builder` instance; thus, we can write
+      #   ref.foo
+      #   # `ref { ... }` returns a `Ref::Defer` instance
+      #   ref { |foo, bar| foo + bar }
+      def ref(name = nil, &)
+        if name
+          raise ArgumentError, "both name and block given" if block_given?
+
+          Ref.new(name)
+        elsif block_given?
+          Defer.new(&)
+        else
+          Builder.new
+        end
+      end
+    end
+  end
+end

data/lib/factrey/ref.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "ref/builder"
+require_relative "ref/defer"
+require_relative "ref/resolver"
+require_relative "ref/shorthand_methods"
+
+module Factrey
+  # Represents a reference that can be embedded in the data and resolved later.
+  #
+  # {Ref}s and {Defer}s are usually created through {ShorthandMethods#ref}.
+  # @example
+  #   # Some data containing several references:
+  #   include Factrey::Ref::ShorthandMethods
+  #   some_data1 = [12, ref.foo, 34, ref.bar, 56]
+  #   some_data2 = { foo: ref.foo, foobar: ref { |foo, bar| foo + bar } }
+  #
+  #   # Resolve references by a `mapping` hash table:
+  #   mapping = { foo: 'hello', bar: 'world' }
+  #   resolver = Factrey::Ref::Resolver.new { mapping.fetch(_1) }
+  #   resolver.resolve(some_data1) #=> [12, 'hello', 34, 'world', 56]
+  #   resolver.resolve(some_data2) #=> { foo: 'hello', foobar: 'helloworld' }
+  class Ref
+    # @return [Symbol]
+    attr_reader :name
+
+    # @param name [Symbol]
+    def initialize(name)
+      raise TypeError, "name must be a Symbol" unless name.is_a?(Symbol)
+
+      @name = name
+    end
+
+    def ==(other) = other.is_a?(Ref) && other.name == name
+
+    def eql?(other) = self == other
+
+    def hash = name.hash
+  end
+end

data/lib/factrey/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Factrey
+  VERSION = "0.1.0"
+end

data/lib/factrey.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "factrey/version"
+require_relative "factrey/ref"
+require_relative "factrey/blueprint"
+require_relative "factrey/dsl"
+
+# Factrey provides a declarative DSL to represent the creation plan of objects.
+module Factrey
+  class << self
+    # Entry point to build or extend a {Blueprint}.
+    # @param blueprint [Blueprint, nil] to extend an existing blueprint
+    # @param ext [Object] an external object that can be accessed using {DSL#ext} in the DSL
+    # @param dsl [Class<DSL>] which DSL is used
+    # @yield Write Blueprint DSL code here. See {DSL} methods for DSL details
+    # @return [Blueprint] the built or extended blueprint
+    # @example
+    #   bp =
+    #     Factrey.blueprint do
+    #       let.blog do
+    #         article(title: "Article 1", body: "...")
+    #         article(title: "Article 2", body: "...")
+    #         article(title: "Article 3", body: "...") do
+    #           comment(name: "John", body: "...")
+    #           comment(name: "Doe", body: "...")
+    #         end
+    #       end
+    #     end
+    #
+    #   instance = bp.instantiate
+    #   # This creates...
+    #   # - a blog (can be accessed by `instance[:blog]`)
+    #   # - with three articles
+    #   # - and two comments to the last article
+    def blueprint(blueprint = nil, ext: nil, dsl: DSL, &)
+      raise TypeError, "blueprint must be a Blueprint" if blueprint && !blueprint.is_a?(Blueprint)
+      raise TypeError, "dsl must be a subclass of DSL" unless dsl <= DSL
+
+      blueprint ||= Blueprint.new
+      dsl.new(blueprint:, ext:).instance_exec(&) if block_given?
+      blueprint
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: factrey
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- yubrot
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-07-22 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Factrey provides a declarative DSL to represent the creation plan of objects, for FactoryBot::Blueprint.
+  The name Factrey is derived from the words factory and tree.
+email:
+- yubrot@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/factrey.rb
+- lib/factrey/blueprint.rb
+- lib/factrey/blueprint/instantiator.rb
+- lib/factrey/blueprint/node.rb
+- lib/factrey/blueprint/type.rb
+- lib/factrey/dsl.rb
+- lib/factrey/dsl/let.rb
+- lib/factrey/dsl/on.rb
+- lib/factrey/ref.rb
+- lib/factrey/ref/builder.rb
+- lib/factrey/ref/defer.rb
+- lib/factrey/ref/resolver.rb
+- lib/factrey/ref/shorthand_methods.rb
+- lib/factrey/version.rb
+homepage: https://github.com/yubrot/factory_bot-blueprint
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/yubrot/factory_bot-blueprint
+  source_code_uri: https://github.com/yubrot/factory_bot-blueprint
+  changelog_uri: https://github.com/yubrot/factory_bot-blueprint/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.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: Provides a declarative DSL to represent the creation plan of objects
+test_files: []