factrey 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1b0e688509760fb4e5a6c8c9426015e5168ebcaf58dee51c1457580d62d219f
-  data.tar.gz: 8447962706952260936adc9d386edaeeb4d85750f33266e5702fa42c87e5bfc2
+  metadata.gz: 3103ae36a9bc66cf15aa05d6f2731cbaa783bfb0139105a9636b865c762e427f
+  data.tar.gz: 51b7561b137fe05e919bf9e13cf517ad9208d5c9237573b0acb198a7dffcd169
 SHA512:
-  metadata.gz: 7b5b370ec393ebd9a9a99dc68c4c824b8e9e4af42a120a1c686e6db3c0558a9525164c64ac93dee49c323fbebfdc5cc5c9a158d15e4fb1e58576d9c15db22c8f
-  data.tar.gz: 447931fcff3033dfeb0b308c7012e23d85bfce06c26c1f5b429248518d9e41a339cd8e6f8e2dfbfea692c94a2e1e809ecec66ceba2bdc9e99d5ca28bc993b99f
+  metadata.gz: 44b1d62bc324437ab8a587b6906044711d7b65659b103bed1d6f789a3a5dd9cd2ca7caeb6ff69fd74e48ae0872627945276c3c58c03b28fd450b6af96d7763a0
+  data.tar.gz: d49aaed8a5f83620638b44ebe3963b1c68c6ef7d4effd9bfe9254e4e39de50c4859c7e33eb8be5e3a82d6b6fdbb9f04ecfa22f3fda7daeab042ed3a6e0ed5210

data/lib/factrey/blueprint/instantiator.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module Factrey
   class Blueprint
     # An internal class used by {Blueprint#instantiate}.
@@ -14,34 +12,31 @@ module Factrey
       def initialize(context, blueprint)
         @context = context
         @objects = {}
-        @visited = Set.new
         @blueprint = blueprint
+
+        # Intermediate state
+        @creating_objects = Set.new
       end
 
       def instantiate_objects
-        @blueprint.nodes.each_value { ensure_object_instantiated(_1) }
+        @blueprint.nodes.each_value { ensure_object_created(_1) }
         @objects
       end
 
-      def instantiate_result
-        instantiate_objects # To keep consistency in the order of instantiation
-        resolver.resolve(@blueprint.result)
-      end
-
       private
 
       # @param node [Node]
       # @return [Object]
-      def ensure_object_instantiated(node)
+      def ensure_object_created(node)
         @objects.fetch(node.name) do
-          unless @visited.add?(node.name)
+          unless @creating_objects.add?(node.name)
             raise ArgumentError, "Circular references detected around #{node.type_annotated_name}"
           end
 
           args = resolver.resolve(node.args)
           kwargs = resolver.resolve(node.kwargs)
-          resolve_auto_references(node.type.auto_references, node.ancestors, kwargs)
-          @objects[node.name] = node.type.factory.call(node.type, @context, *args, **kwargs)
+          node.auto_referenced_ancestors.each { kwargs[_1] = ensure_object_created(_2) }
+          @objects[node.name] = node.type.create_object(@context, *args, **kwargs)
         end
       end
 
@@ -49,31 +44,7 @@ module Factrey
       def resolver
         @resolver ||= Ref::Resolver.new(recursion_limit: 5) do |name|
           node = @blueprint.nodes.fetch(name) { raise ArgumentError, "Missing definition: #{name}" }
-          ensure_object_instantiated(node)
-        end
-      end
-
-      # @param auto_references [Hash{Symbol => Symbol}]
-      # @param referenceable_nodes [Array<Node>]
-      # @param dest [Hash{Symbol => Object}]
-      def resolve_auto_references(auto_references, referenceable_nodes, dest)
-        candidates = {}
-        auto_references.each do |type_name, attribute|
-          next if dest.member? attribute # this attribute is explicitly specified
-
-          compatible_node, index = referenceable_nodes.reverse_each.with_index.find do |node, _|
-            node.type.compatible_types.include?(type_name)
-          end
-          next unless compatible_node
-
-          # the node closest to the end of the array has priority
-          next if candidates.member?(attribute) && candidates[attribute][1] <= index
-
-          candidates[attribute] = [compatible_node, index]
-        end
-
-        candidates.each do |attribute, (node, _)|
-          dest[attribute] = ensure_object_instantiated(node)
+          ensure_object_created(node)
         end
       end
     end

data/lib/factrey/blueprint/node.rb

@@ -1,48 +1,89 @@
 # frozen_string_literal: true
 
-require "set"
+require "securerandom"
 
 module Factrey
   class Blueprint
     # A node corresponds to an object to be created. A {Blueprint} consists of a set of nodes.
     class Node
+      # A name prefix given to anonymous nodes for convenience.
       ANONYMOUS_NAME_PREFIX = "_anon_"
+      # Name used for the node that hold the results of the blueprint.
+      RESULT_NAME = :_result_
 
       # @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 [Node, nil] parent node
+      attr_reader :parent
       # @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: {})
+      def initialize(name, type, parent: nil, 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, "parent must be a Node" if parent && !parent.is_a?(Node)
         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
+        @parent = parent
         @args = args
         @kwargs = kwargs
       end
 
-      # @return [Ref]
-      def to_ref = Ref.new(name)
+      # @param name [Symbol, nil]
+      # @param value [Object]
+      # @param parent [Node, nil]
+      def self.computed(name, value, parent: nil)
+        new(name, Blueprint::Type::COMPUTED, parent:, args: [value])
+      end
 
       # @return [Boolean]
-      def root? = ancestors.empty?
+      def anonymous? = name.start_with?(ANONYMOUS_NAME_PREFIX)
 
       # @return [Boolean]
-      def anonymous? = name.start_with?(ANONYMOUS_NAME_PREFIX)
+      def result? = name == RESULT_NAME
+
+      # @return [Ref] the reference to this node
+      def to_ref = Ref.new(name)
+
+      # @return [Ref, nil] if this node works as an alias to another node, return the reference to the node
+      def alias_ref
+        case [type, args]
+        in Blueprint::Type::COMPUTED, [Ref => ref]
+          ref
+        else
+          nil
+        end
+      end
+
+      # @return [Array<Node>] a list of ancestor nodes
+      def ancestors = parent ? [parent].concat(parent.ancestors) : []
+
+      # @return [Hash{Symbol => Node}] a map from attributes to auto-referenced ancestor nodes
+      def auto_referenced_ancestors
+        ancestors = self.ancestors
+        candidates = {}
+        type.auto_references.each do |type_name, attribute|
+          next if kwargs.member? attribute # this attribute is explicitly specified
+
+          # closer ancestors have higher (lower integer) priority
+          compatible_node, priority = ancestors.each_with_index.find do |node, _|
+            node.type.compatible_types.include?(type_name)
+          end
+          next unless compatible_node
+          next if candidates.member?(attribute) && candidates[attribute][0] <= priority
+
+          candidates[attribute] = [priority, compatible_node]
+        end
+
+        candidates.transform_values { _2 }
+      end
 
       # Used for debugging and error reporting.
       # @return [String]

data/lib/factrey/blueprint/type.rb

@@ -12,13 +12,12 @@ module Factrey
       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]
+      #   procedure that actually creates an object. See {Blueprint::Instantiator} implementation
       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
@@ -40,6 +39,17 @@ module Factrey
         @auto_references = auto_references.freeze
         @factory = factory
       end
+
+      # Create an object of this type.
+      # @param context [Object] the context object that is passed to the factory
+      # @param args [Array<Object>] positional arguments for the factory
+      # @param kwargs [Hash{Symbol => Object}] keyword arguments for the factory
+      def create_object(context, *, **)
+        @factory.call(self, context, *, **)
+      end
+
+      # A special type that represents values computed from other objects. See {Node.computed}.
+      COMPUTED = new(:_computed) { |_, _, arg| arg }
     end
   end
 end

data/lib/factrey/blueprint.rb

@@ -10,8 +10,6 @@ module Factrey
   class Blueprint
     # @return [Hash{Symbol => Node}] a set of nodes
     attr_reader :nodes
-    # @return [Object] the result of the DSL code is defined here
-    attr_reader :result
 
     # Creates an empty blueprint.
     def initialize
@@ -23,46 +21,47 @@ module Factrey
       result = self.class.new
 
       nodes.each_value do |node|
-        result.add_node(
+        new_node = Node.new(
           node.name,
           node.type,
           # This is OK since Hash insertion order in Ruby is retained
-          ancestors: node.ancestors.map { result.nodes[_1.name] },
+          parent: node.parent&.then { result.nodes[_1.name] },
           args: node.args.dup,
           kwargs: node.kwargs.dup,
         )
+        result.add_node(new_node)
       end
 
       result
     end
 
     # Add a node. This method is used by {DSL} and usually does not need to be called directly.
+    # @param node [Node]
     # @return [Node]
-    def add_node(...)
-      node = Node.new(...)
+    def add_node(node)
       raise ArgumentError, "duplicate node: #{node.name}" if nodes.member?(node.name)
 
       nodes[node.name] = node
       node
     end
 
-    # Define the result. This method is used by {DSL} and usually does not need to be called directly.
-    # @param result [Object]
-    # @param overwrite [Boolean] whether to overwrite the existing result
-    def define_result(result, overwrite: false)
-      return if defined?(@result) && !overwrite
+    # Resolve a node.
+    # @param name [Symbol]
+    # @param follow_alias [Boolean] whether to follow an alias node. See {Node#alias_ref}
+    # @return [Node, nil]
+    def resolve_node(name, follow_alias: true)
+      node = nodes[name]
+      return node unless follow_alias
 
-      @result = result
+      ref = node&.alias_ref
+      ref ? resolve_node(ref.name) : node
     end
 
-    # Create a set of objects and compute the result based on this blueprint.
+    # Create a set of objects based on this blueprint.
     # @param context [Object] context object to be passed to the factories
-    # @return [(Object, {Symbol => Object})] the result and the created objects
+    # @return [Hash{Symbol => Object}] the created objects
     def instantiate(context = nil)
-      instantiator = Instantiator.new(context, self)
-      objects = instantiator.instantiate_objects
-      result = instantiator.instantiate_result
-      [result, objects]
+      Instantiator.new(context, self).instantiate_objects
     end
   end
 end

data/lib/factrey/dsl.rb

@@ -1,18 +1,13 @@
 # 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
+      ref ext object_node computed_node let on args
+      __send__ __method__ __id__ nil? is_a? to_s inspect object_id class instance_eval instance_variables
+      initialize block_given? enum_for raise
     ].to_set.freeze
 
     (instance_methods + private_instance_methods).each do |method|
@@ -32,100 +27,81 @@ module Factrey
     # @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]
+    # Add an object node to the blueprint.
+    #
+    # This method is usually not called directly. Use the shorthand method defined by {.add_type} instead.
+    # @param name [Symbol, nil]
+    # @param type [Blueprint::Type]
+    # @yieldparam ref [Ref]
+    # @return [Ref]
+    def object_node(name, type, ...)
+      node = @blueprint.add_node(Blueprint::Node.new(name, type, parent: @ancestors.last))
+      on(node.name, ...)
+    end
+
+    # Add a computed node to the blueprint.
+    #
+    # This method is usually not called directly. Use {#let} instead.
+    # @param name [Symbol, nil]
+    # @param value [Object]
+    def computed_node(name, value)
+      node = @blueprint.add_node(Blueprint::Node.computed(name, value, parent: @ancestors.last))
+      node.to_ref
+    end
+
+    # Define a computed node with name.
+    # @param setter_name [Symbol, nil] the setter name for the computed node
+    # @return [Ref, Proxy] returns a {Proxy} for <code>let.node_name = ...</code> notation if no argument is given
     # @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
+    #       article(title: "Foo")                # object itself has no meaningful name (See Blueprint::Node#anonymous?)
+    #       let.article = article(title: "Bar")  # an alias `article` to the article object is defined
+    #       let.article(title: "Bar")            # We can omit `.node_name =` if the name is the same as the method name
+    #       let.article2 = article(title: "Baz") # an alias `article2` to the article object is defined
     #     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
+    def let(setter_name = nil, *args, **kwargs, &block)
+      return Proxy.new(self, __method__) unless setter_name
 
-      let = Let.new(self, name)
-      return let unless block_given?
+      if setter_name.end_with? "="
+        raise ArgumentError, "Wrong setter use" if args.size != 1 || !kwargs.empty? || block
 
-      @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, &)
+        computed_node(setter_name[0..-2].to_sym, args[0])
       else
-        return self unless block_given?
-
-        yield
+        # `let.node_name(...)` is a shorthand for `let.node_name = node_name(...)`
+        let(:"#{setter_name}=", __send__(setter_name, *args, **kwargs, &block))
       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]
-    # @yieldparam ref [Ref]
-    # @return [Ref]
-    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.
-    # @yieldparam ref [Ref]
-    # @return [Ref]
+    # @param node_name [Symbol, nil] the node name to enter
+    # @return [Ref, Proxy] returns a {Proxy} for <code>on.node_name(...)</code> notation if no argument is given
     # @example
     #   Factrey.blueprint do
     #     let.blog do
-    #       let(:article1).article
-    #       let(:article2).article
+    #       let.article1 = article
+    #       let.article2 = article
     #     end
     #
     #     # Add article to `blog`
-    #     on.blog { let(:article3).article }
+    #     on.blog { let.article3 = article }
     #     # Add title to `article2`
     #     on.article2(title: "This is an article 2")
     #   end
-    def on(name = nil, *args, **kwargs)
-      return On.new(self) if name.nil? && !block_given?
+    def on(node_name = nil, ...)
+      return Proxy.new(self, __method__) unless node_name
 
-      node = @blueprint.nodes[name]
-      raise ArgumentError, "unknown node: #{name}" unless node
+      node = @blueprint.resolve_node(node_name)
+      raise ArgumentError, "unknown node: #{node_name}" unless node
 
       stashed_ancestors = @ancestors
       @ancestors = node.ancestors + [node]
-      args(*args, **kwargs)
-      yield node.to_ref if block_given?
-      @ancestors = stashed_ancestors
-      node.to_ref
+      begin
+        args(...)
+      ensure
+        @ancestors = stashed_ancestors
+      end
     end
 
     # Add arguments to the current node.
@@ -138,10 +114,13 @@ module Factrey
     #     on.blog(:premium, title: "Who-ha")
     #   end
     def args(*args, **kwargs)
-      raise NameError, "Cannot use args at toplevel" if @ancestors.empty?
+      raise NameError, "cannot use args at toplevel" if @ancestors.empty?
+      raise NameError, "cannot use args to computed nodes" if @ancestors.last.type == Blueprint::Type::COMPUTED
 
       @ancestors.last.args.concat(args)
       @ancestors.last.kwargs.update(kwargs)
+      yield @ancestors.last.to_ref if block_given?
+      @ancestors.last.to_ref
     end
 
     class << self
@@ -151,8 +130,8 @@ module Factrey
       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>.
+      # This method defines a helper method with the same name as the type name. For example,
+      # if you have added the <code>foo</code> type, you can declare an object 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
@@ -179,7 +158,7 @@ module Factrey
         end
 
         types[type.name] = type
-        define_method(type.name) { |*args, **kwargs, &block| node(type, *args, **kwargs, &block) }
+        define_method(type.name) { |*args, **kwargs, &block| object_node(nil, type, *args, **kwargs, &block) }
       end
     end
   end

data/lib/factrey/proxy.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Factrey
+  # An intermediate object to provide some notation combined with <code>method_missing</code>.
+  # @example
+  #   class Foo
+  #     def foo(name = nil)
+  #       return Factrey::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<Object>]
+    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

data/lib/factrey/ref/defer.rb

@@ -2,9 +2,9 @@
 
 module Factrey
   class Ref
-    # A thin wrapper around {Proc} to represent the procedure using the results of the reference resolution.
+    # A thin wrapper around <code>Proc</coode> 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}.
+    # These references are resolved and the results are passed to the <code>Proc</code>.
     #
     # {Ref}s and {Defer}s are usually created through {ShorthandMethods#ref}.
     class Defer

data/lib/factrey/ref/resolver.rb

@@ -13,7 +13,8 @@ module Factrey
 
       # 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}.
+      # This method supports recursive traversal for <code>Array</code> and <code>Hash</code>. For other structures,
+      # consider using {Defer}.
       # @param object [Object]
       # @param recursion_count [Integer]
       def resolve(object, recursion_count: 0)

data/lib/factrey/version.rb

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

data/lib/factrey.rb

@@ -2,6 +2,7 @@
 
 require_relative "factrey/version"
 require_relative "factrey/ref"
+require_relative "factrey/proxy"
 require_relative "factrey/blueprint"
 require_relative "factrey/dsl"
 
@@ -36,8 +37,12 @@ module Factrey
       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
 
+      is_extending = !blueprint.nil?
       blueprint ||= Blueprint.new
-      blueprint.define_result dsl.new(blueprint:, ext:).instance_exec(&) if block_given?
+
+      result = block_given? ? dsl.new(blueprint:, ext:).instance_eval(&) : nil
+      blueprint.add_node(Blueprint::Node.computed(Blueprint::Node::RESULT_NAME, result)) unless is_extending
+
       blueprint
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: factrey
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - yubrot
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-30 00:00:00.000000000 Z
+date: 2024-11-27 00:00:00.000000000 Z
 dependencies: []
 description: |
   Factrey provides a declarative DSL to represent the creation plan of objects, for FactoryBot::Blueprint.
@@ -27,8 +27,7 @@ files:
 - 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/proxy.rb
 - lib/factrey/ref.rb
 - lib/factrey/ref/builder.rb
 - lib/factrey/ref/defer.rb
@@ -51,14 +50,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Provides a declarative DSL to represent the creation plan of objects

data/lib/factrey/dsl/let.rb

@@ -1,22 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-# 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