object_forge 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13df90e0eb14f3fb52c1b9be5706a3b2da6c844369005f0500fe31f67ced6091
-  data.tar.gz: 6ce301c70ae87b0e46662482cd46af63d8e282aca65f92e220dc02e4a6b3e2b6
+  metadata.gz: 83440b5319d1e909379d16b67830ad1f67f575358473dd4ba5914cb549c417b9
+  data.tar.gz: 279a5756a157f96252081cb60ce0541bdffdf1e21a25fe72db19b622c7d717e8
 SHA512:
-  metadata.gz: b75f0d0ddacd4f102a02bbb74bd0189e8b2759eb4e9a4f3f62de84a028356800908d3313ec5361299078e49a2101abcedda91358601cfc03cf76ac2bb3fb05b7
-  data.tar.gz: 76231dd798153526c679874b3528d120a7f3562c8dfc540001be54465b46f53a50afa46f04d17f8bc2ddfcb152708d9003e417fd4d8c6d220890c62597930104
+  metadata.gz: e16b3091daf563ffffbb5da39b50a6cc2298a288a1e71528ab9de905e0c959718555ff8d3b6b2a3478f094fa3ebff8727f0a95e97c6adef05d3c7abb1ae6676f
+  data.tar.gz: 04455c660052171b8a4456323b700f91805d0c05190329427baee1468b42ccfee3c315b79534f997b45a1f2cd716f85076e164f8007cad821f43047a5ea8fcbf

data/lib/object_forge/crucible.rb

@@ -12,7 +12,6 @@ module ObjectForge
   #
   # @thread_safety Attribute resolution is idempotent,
   #   but modifies instance variables, making it unsafe to share the Crucible
-  #
   # @since 0.1.0
   class Crucible < UnBasicObject
     %i[rand].each { |m| private define_method(m, ::Object.instance_method(m)) }

data/lib/object_forge/forge.rb

@@ -2,6 +2,7 @@
 
 require_relative "crucible"
 require_relative "forge_dsl"
+require_relative "molds"
 
 module ObjectForge
   # Object instantitation forge.
@@ -19,14 +20,22 @@ module ObjectForge
     # @!attribute [r] traits
     #   Attributes belonging to traits.
     #   @return [Hash{Symbol => Hash{Symbol => Any}}]
-    Parameters = Struct.new(:attributes, :traits, keyword_init: true)
+    #
+    # @!attribute [r] mold
+    #   An object that knows how to build the instance.
+    #   Must have a +call+ method that takes a class and a hash of attributes.
+    #   @since 0.2.0
+    #   @return [#call, nil]
+    Parameters = Struct.new(:attributes, :traits, :mold, keyword_init: true)
+
+    MOLD_MOLD = Molds::MoldMold.new.freeze
 
     # Define (and create) a forge using DSL.
     #
     # @see ForgeDSL
     # @thread_safety Thread-safe if DSL definition is thread-safe.
     #
-    # @param forged [Class] class to forge
+    # @param forged [Class, Any] class or object to forge
     # @param name [Symbol, nil] forge name
     # @yieldparam f [ForgeDSL]
     # @yieldreturn [void]
@@ -38,25 +47,26 @@ module ObjectForge
     # @return [Symbol, nil] forge name
     attr_reader :name
 
-    # @return [Class] class to forge
+    # @return [Class, Any] class or object to forge
     attr_reader :forged
 
     # @return [Parameters, ForgeDSL] forge parameters
     attr_reader :parameters
 
-    # @param forged [Class] class to forge
+    # @param forged [Class, Any] class or object to forge
     # @param parameters [Parameters, ForgeDSL] forge parameters
     # @param name [Symbol, nil] forge name
     def initialize(forged, parameters, name: nil)
       @name = name
       @forged = forged
       @parameters = parameters
+      @mold = parameters.mold || MOLD_MOLD.call(forged: forged)
     end
 
     # Forge a new instance.
     #
-    # @overload forge(*traits, **overrides)
-    # @overload forge(traits, overrides)
+    # @overload forge(*traits, **overrides, &)
+    # @overload forge(traits, overrides, &)
     #
     # Positional arguments are taken as trait names, keyword arguments as attribute overrides,
     # unless there are exactly two positional arguments: an array and a hash.
@@ -64,19 +74,21 @@ module ObjectForge
     # All traits and overrides are applied in argument order,
     # with overrides always applied after traits.
     #
+    # If a block is given, forged instance is yielded to it after being built.
+    #
     # @thread_safety Forging is thread-safe if {#parameters},
-    #    +traits+ and +overrides+ are thread-safe.
+    #   +traits+ and +overrides+ are thread-safe.
     #
     # @param traits [Array<Symbol>] traits to apply
     # @param overrides [Hash{Symbol => Any}] attribute overrides
+    # @yieldparam object [Any] forged instance
+    # @yieldreturn [void]
     # @return [Any] built instance
     def forge(*traits, **overrides)
-      # @type var traits: Array[(Array[Symbol] | Hash[Symbol, untyped])]
-      traits, overrides = check_traits_and_overrides(traits, overrides)
-      attributes = @parameters.attributes.merge(*@parameters.traits.values_at(*traits), overrides)
-      attributes = Crucible.new(attributes).resolve!
-
-      forged.new(attributes)
+      resolved_attributes = resolve_attributes(traits, overrides)
+      instance = @mold.call(forged: @forged, attributes: resolved_attributes)
+      yield instance if block_given?
+      instance
     end
 
     alias build forge
@@ -84,19 +96,9 @@ module ObjectForge
 
     private
 
-    def check_traits_and_overrides(traits, overrides)
-      unless traits.size == 2 && overrides.empty?
-        # @type var traits: Array[Symbol]
-        # @type var overrides: Hash[Symbol, untyped]
-        return [traits, overrides]
-      end
-
-      case traits
-      in [Array => real_traits, Hash => real_overrides]
-        [real_traits, real_overrides]
-      else
-        [traits, overrides]
-      end
+    def resolve_attributes(traits, overrides)
+      attributes = @parameters.attributes.merge(*@parameters.traits.values_at(*traits), overrides)
+      Crucible.new(attributes).resolve!
     end
   end
 end

data/lib/object_forge/forge_dsl.rb

@@ -3,6 +3,8 @@
 require_relative "sequence"
 require_relative "un_basic_object"
 
+require_relative "molds/wrapped_mold"
+
 module ObjectForge
   # DSL for defining a forge.
   #
@@ -14,7 +16,6 @@ module ObjectForge
   #   especially in attribute definitions.
   #   The instance itself is frozen after initialization,
   #   so it should be safe to share.
-  #
   # @since 0.1.0
   class ForgeDSL < UnBasicObject
     # @return [Hash{Symbol => Proc}] attribute definitions
@@ -26,6 +27,9 @@ module ObjectForge
     # @return [Hash{Symbol => Hash{Symbol => Proc}}] trait definitions
     attr_reader :traits
 
+    # @return [#call, nil] forge mold
+    attr_reader :mold
+
     # Define forge's parameters through DSL.
     #
     # If the block has a parameter, an object will be yielded,
@@ -71,9 +75,34 @@ module ObjectForge
       @attributes.freeze
       @sequences.freeze
       @traits.freeze
+      @mold.freeze
       self
     end
 
+    # Set the forge mold.
+    #
+    # Mold is an object that knows how to take a hash of attributes
+    # and create an object from them.
+    # It can also be a class with +#call+, in which case a new mold will be instantiated
+    # automatically for each build. If a single instance is enough,
+    # please call +.new+ yourself once.
+    #
+    # @since 0.2.0
+    #
+    # @param mold [Class, #call, nil]
+    # @return [Class, #call, nil]
+    #
+    # @raise [DSLError] if +mold+ does not respond to or implement +#call+
+    def mold=(mold)
+      if nil == mold || mold.respond_to?(:call) # rubocop:disable Style/YodaCondition
+        @mold = mold
+      elsif ::Class === mold && mold.public_method_defined?(:call)
+        @mold = Molds::WrappedMold.new(mold)
+      else
+        raise DSLError, "mold must respond to or implement #call"
+      end
+    end
+
     # Define an attribute, possibly transient.
     #
     # DSL does not know or care what attributes the forged class has,

data/lib/object_forge/forgeyard.rb

@@ -2,6 +2,8 @@
 
 require "concurrent/map"
 
+require_relative "forge"
+
 module ObjectForge
   # A registry for forges, making them accessible by name.
   #
@@ -20,7 +22,7 @@ module ObjectForge
     # @see Forge.define
     #
     # @param name [Symbol] name to register forge under
-    # @param forged [Class] class to forge
+    # @param forged [Class, Any] class or object to forge
     # @yieldparam f [ForgeDSL]
     # @yieldreturn [void]
     # @return [Forge] forge
@@ -50,11 +52,13 @@ module ObjectForge
     # @param name [Symbol] name of the forge
     # @param traits [Array<Symbol>] traits to apply
     # @param overrides [Hash{Symbol => Any}] attribute overrides
+    # @yieldparam object [Any] forged instance
+    # @yieldreturn [void]
     # @return [Any] built instance
     #
     # @raise [KeyError] if forge with the specified name is not registered
-    def forge(name, *traits, **overrides)
-      @forges.fetch(name)[traits, overrides]
+    def forge(name, ...)
+      @forges.fetch(name).[](...)
     end
 
     alias build forge

data/lib/object_forge/molds/hash_mold.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ObjectForge
+  module Molds
+    # Mold for constructing Hashes.
+    #
+    # @thread_safety Thread-safe on its own,
+    #   but using unshareable default value or block is not thread-safe.
+    #
+    # @since 0.2.0
+    class HashMold
+      # Default value to be assigned to each produced hash.
+      # @return [Any, nil]
+      attr_reader :default
+      # Default proc to be assigned to each produced hash.
+      # @return [Proc, nil]
+      attr_reader :default_proc
+
+      # Initialize new HashMold with default value or default proc
+      # to be assigned to each produced hash.
+      #
+      # The same exact objects are used for each hash.
+      # It is not advised to use mutable objects as default values.
+      # Be aware that using a default proc with assignment
+      # is inherently not safe, see this Ruby issue:
+      # https://bugs.ruby-lang.org/issues/19237.
+      #
+      # @see Hash.new
+      #
+      # @param default_value [Any]
+      # @yieldparam hash [Hash]
+      # @yieldparam key [Any]
+      # @yieldreturn [Any]
+      def initialize(default_value = nil, &default_proc)
+        @default = default_value
+        @default_proc = default_proc
+      end
+
+      # Build a new hash using +forged.[]+.
+      #
+      # @see Hash.[]
+      #
+      # @param forged [Class] Hash or a subclass of Hash
+      # @param attributes [Hash{Symbol => Any}]
+      # @return [Hash]
+      def call(forged:, attributes:, **_)
+        hash = forged[attributes]
+        hash.default = @default if @default
+        hash.default_proc = @default_proc if @default_proc
+        hash
+      end
+    end
+  end
+end

data/lib/object_forge/molds/keywords_mold.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ObjectForge
+  module Molds
+    # Basic mold which calls +forged.new(**attributes)+.
+    #
+    # Can be used instead of {SingleArgumentMold},
+    # but performance is about 1.5 times worse.
+    #
+    # @thread_safety Thread-safe.
+    # @since 0.2.0
+    class KeywordsMold
+      # Instantiate +forged+ with a hash of attributes.
+      #
+      # @param forged [Class, #new]
+      # @param attributes [Hash{Symbol => Any}]
+      # @return [Any]
+      def call(forged:, attributes:, **_)
+        forged.new(**attributes)
+      end
+    end
+  end
+end

data/lib/object_forge/molds/mold_mold.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ObjectForge
+  module Molds
+    # Special "mold" that returns appropriate mold for the given forged object.
+    # Probably not the best fit though.
+    #
+    # Currently provides specific recognition for:
+    # - subclasses of +Struct+ ({StructMold}),
+    # - subclasses of +Data+ ({KeywordsMold}),
+    # - +Hash+ and subclasses ({HashMold}).
+    # Other objects just get {SingleArgumentMold}.
+    #
+    # @thread_safety Thread-safe.
+    # @since 0.2.0
+    class MoldMold
+      # Get maybe appropriate mold for the given forged object.
+      #
+      # @param forged [Class, Any]
+      # @return [#call] an instance of a mold
+      def call(forged:, **_)
+        # rubocop:disable Style/YodaCondition
+        if ::Class === forged
+          if ::Struct > forged
+            StructMold.new
+          elsif defined?(::Data) && ::Data > forged
+            KeywordsMold.new
+          elsif ::Hash >= forged
+            HashMold.new
+          else
+            SingleArgumentMold.new
+          end
+        else
+          SingleArgumentMold.new
+        end
+        # rubocop:enable Style/YodaCondition
+      end
+    end
+  end
+end

data/lib/object_forge/molds/single_argument_mold.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ObjectForge
+  module Molds
+    # Basic mold which calls +forged.new(attributes)+.
+    #
+    # @thread_safety Thread-safe.
+    # @since 0.2.0
+    class SingleArgumentMold
+      # Instantiate +forged+ with a hash of attributes.
+      #
+      # @param forged [Class, #new]
+      # @param attributes [Hash{Symbol => Any}]
+      # @return [Any]
+      def call(forged:, attributes:, **_)
+        forged.new(attributes)
+      end
+    end
+  end
+end

data/lib/object_forge/molds/struct_mold.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ObjectForge
+  module Molds
+    # Mold for building Structs.
+    #
+    # Supports all variations of +keyword_init+.
+    #
+    # @thread_safety Thread-safe.
+    # @since 0.2.0
+    class StructMold
+      # Does Struct automatically use keyword initialization
+      # when +keyword_init+ is not specified / +nil+?
+      #
+      # @return [Boolean]
+      RUBY_FEATURE_AUTO_KEYWORDS = (::Struct.new(:a, :b).new(a: 1, b: 2).a == 1)
+
+      # Whether to work around argument hashes with extra keys.
+      #
+      # @return [Boolean]
+      attr_reader :lax
+      alias lax? lax
+
+      # @param lax [Boolean]
+      #   whether to work around argument hashes with extra keys
+      #   (when keyword_init is false, workaround always happens for technical reasons)
+      #   - if +true+, arguments can contain extra keys, but building is slower;
+      #   - if +false+, building may raise an error if extra keys are present;
+      def initialize(lax: true)
+        @lax = lax
+      end
+
+      # Instantiate +forged+ struct with a hash of attributes.
+      #
+      # @param forged [Class] a subclass of Struct
+      # @param attributes [Hash{Symbol => Any}]
+      # @return [Struct]
+      def call(forged:, attributes:, **_)
+        if forged.keyword_init?
+          lax ? forged.new(attributes.slice(*forged.members)) : forged.new(attributes)
+        elsif forged.keyword_init? == false
+          forged.new(*attributes.values_at(*forged.members))
+        else
+          build_struct_with_unspecified_keyword_init(forged, attributes)
+        end
+      end
+
+      private
+
+      if RUBY_FEATURE_AUTO_KEYWORDS
+        # Build struct by using keywords to specify member values.
+        def build_struct_with_unspecified_keyword_init(forged, attributes)
+          if lax
+            forged.new(**attributes.slice(*forged.members))
+          else
+            forged.new(**attributes)
+          end
+        end
+      else
+        # :nocov:
+        # Build struct by using positional arguments to specify member values.
+        def build_struct_with_unspecified_keyword_init(forged, attributes)
+          forged.new(*attributes.values_at(*forged.members))
+        end
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/object_forge/molds/wrapped_mold.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ObjectForge
+  module Molds
+    # Mold that wraps a mold class.
+    #
+    # Wrapping a mold class is useful when its +#call+ is stateful,
+    # making it unsafe to use multiple times or in shared environments.
+    #
+    # @thread_safety Thread-safe if {wrapped_mold} does not use global state.
+    # @since 0.2.0
+    class WrappedMold
+      # @return [Class] wrapped mold class
+      attr_reader :wrapped_mold
+
+      # @param wrapped_mold [Class] class with +#call+ method
+      def initialize(wrapped_mold)
+        @wrapped_mold = wrapped_mold
+      end
+
+      # @overload call(...)
+      # Instantiate {wrapped_mold} and call it.
+      #
+      # @return [Any] result of +wrapped_mold.new.call(...)+
+      def call(...)
+        wrapped_mold.new.call(...)
+      end
+    end
+  end
+end

data/lib/object_forge/molds.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ObjectForge
+  # This module provides a collection of predefined molds to be used in common cases.
+  #
+  # Molds are +#call+able objects responsible for actually building objects produced by factories
+  # (or doing other, interesting things with them (truly, only the code review is the limit!)).
+  # They are supposed to be immutable, shareable, and persistent:
+  # initialize once, use for the whole runtime.
+  #
+  # A simple mold can easily be just a +Proc+.
+  # All molds must have the following +#call+ signature: +call(forged:, attributes:, **)+.
+  # The extra keywords are for future extensions.
+  #
+  # @example A very basic FactoryBot replacement
+  #   creator = ->(forged:, attributes:, **) do
+  #     instance = forged.new
+  #     attributes.each_pair { instance.public_send(:"#{_1}=", _2) }
+  #     instance.save!
+  #   end
+  #   creator.call(forged: User, attributes: { name: "John", age: 30 })
+  #     # => <User name="John" age=30>
+  # @example Using a mold to serialize collection of objects (contrivedly)
+  #   dumpy = ->(forged:, attributes:, **) do
+  #     Enumerator.new(attributes.size) do |y|
+  #       attributes.each_pair { y << forged.dump(_1 => _2) }
+  #     end
+  #   end
+  #   dumpy.call(forged: JSON, attributes: {a:1, b:2}).to_a
+  #     # => ["{\"a\":1}", "{\"b\":2}"]
+  #   dumpy.call(forged: YAML, attributes: {a:1, b:2}).to_a
+  #     # => ["---\n:a: 1\n", "---\n:b: 2\n"]
+  # @example Abstract factory pattern (kind of)
+  #   class FurnitureFactory
+  #     def call(forged:, attributes:, **)
+  #       concrete_factory = concrete_factory(forged)
+  #       attributes[:pieces].map do |piece|
+  #         concrete_factory.public_send(piece, attributes.dig(:color, piece))
+  #       end
+  #     end
+  #     private def concrete_factory(style)
+  #       case style
+  #       when :hitech
+  #         HiTechFactory.new
+  #       when :retro
+  #         RetroFactory.new
+  #       end
+  #     end
+  #   end
+  #   FurnitureFactory.new.call(forged: :hitech, attributes: {
+  #     pieces: [:chair, :table], color: { chair: :black, table: :white }
+  #   })
+  #     # => [<#HiTech::Chair color=:black>, <#HiTech::Table color=:white>]
+  # @example Abusing molds
+  #   printer = ->(forged:, attributes:, **) { PP.pp(attributes, forged) }
+  #   printer.call(forged: $stderr, attributes: {a:1, b:2})
+  #     # outputs "{:a=>1, :b=>2}" to $stderr
+  #
+  # @since 0.2.0
+  module Molds
+    Dir["#{__dir__}/molds/*.rb"].each { require_relative _1 }
+  end
+end

data/lib/object_forge/sequence.rb

@@ -32,7 +32,7 @@ module ObjectForge
       end
 
       @initial = initial
-      @container = Concurrent::MVar.new(initial)
+      @container = Concurrent::MVar.new(initial) # steep:ignore UnknownConstant
     end
 
     # Get the next value in the sequence, starting with the initial value.

data/lib/object_forge/un_basic_object.rb

@@ -4,7 +4,6 @@ module ObjectForge
   # BasicObject with a few common methods copied from Object.
   #
   # @api private
-  #
   # @since 0.1.0
   class UnBasicObject < ::BasicObject
     # @!group Instance methods copied from Object

data/lib/object_forge/version.rb

@@ -2,5 +2,5 @@
 
 module ObjectForge
   # Current version
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/object_forge.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-Dir["#{__dir__}/object_forge/**/*.rb"].each { require _1 }
+require_relative "object_forge/forgeyard"
+require_relative "object_forge/sequence"
+require_relative "object_forge/version"
 
 # A simple all-purpose factory library with minimal assumptions.
 #
@@ -76,7 +78,7 @@ module ObjectForge
   # @since 0.1.0
   #
   # @param name [Symbol] forge name
-  # @param forged [Class] class to forge
+  # @param forged [Class, Any] class or object to forge
   # @yieldparam f [ForgeDSL]
   # @yieldreturn [void]
   # @return [Forge] forge
@@ -84,7 +86,7 @@ module ObjectForge
     DEFAULT_YARD.define(...)
   end
 
-  # @overload forge(name, *traits, **overrides)
+  # @overload forge(name, *traits, **overrides, &)
   # Build an instance using a forge from {DEFAULT_YARD}.
   #
   # @!macro default_forgeyard
@@ -94,6 +96,8 @@ module ObjectForge
   # @param name [Symbol] name of the forge
   # @param traits [Array<Symbol>] traits to apply
   # @param overrides [Hash{Symbol => Any}] attribute overrides
+  # @yieldparam object [Any] forged instance
+  # @yieldreturn [void]
   # @return [Any] built instance
   def self.forge(...)
     DEFAULT_YARD.forge(...)

data/sig/object_forge/molds.rbs

@@ -0,0 +1,72 @@
+module ObjectForge
+  interface _Mold
+    def call
+      : (forged: untyped, attributes: Hash[Symbol, untyped], **untyped) -> untyped
+  end
+
+  module Molds
+    class MoldMold
+      def call
+        : (forged: untyped, **untyped) -> ObjectForge::_Mold
+    end
+
+    class SingleArgumentMold
+      include ObjectForge::_Mold
+    end
+
+    class KeywordsMold
+      include ObjectForge::_Mold
+    end
+
+    class WrappedMold
+      interface _MoldClass[T]
+        def new: () -> T
+      end
+
+      include ObjectForge::_Mold
+
+      attr_reader wrapped_mold: _MoldClass[ObjectForge::mold]
+
+      def initialize: (_MoldClass[ObjectForge::mold] wrapped_mold) -> void
+    end
+
+    class StructMold
+      interface _StructSubclass[T]
+        def new
+          : (*untyped) -> T
+          | (**untyped) -> T
+          | (Hash[Symbol, untyped]) -> T
+        def members: -> Array[Symbol]
+        def keyword_init?: -> bool?
+      end
+
+      RUBY_FEATURE_AUTO_KEYWORDS: bool
+      attr_reader lax: bool
+
+      def initialize: (?lax: bool) -> void
+
+      def call
+        : [T < Struct] (forged: _StructSubclass[T], attributes: Hash[Symbol, untyped], **untyped) -> T
+      
+      private
+      
+      def build_struct_with_unspecified_keyword_init
+        : [T < Struct] (_StructSubclass[T] forged, Hash[Symbol, untyped] attributes) -> T
+    end
+
+    class HashMold
+      interface _HashSubclass[T]
+        def []: (Hash[untyped, untyped]) -> T
+      end
+
+      attr_reader default: untyped?
+      attr_reader default_proc: Proc?
+
+      def initialize
+        : (?untyped? default_value) ?{ (Hash[untyped, untyped] hash, untyped key) -> untyped} -> void
+      
+      def call
+        : [T < Hash] (forged: _HashSubclass[T], attributes: Hash[Symbol, untyped], **untyped) -> T
+    end
+  end
+end

data/sig/object_forge.rbs

@@ -1,47 +1,53 @@
 module ObjectForge
-  class Error < StandardError
-  end
-  class DSLError < Error
-  end
+  type mold = ObjectForge::_RespondTo & ObjectForge::_Mold
+  type sequenceable = ObjectForge::_RespondTo & ObjectForge::_Sequenceable
 
-  interface _Sequenceable
-    def succ: -> self
+  interface _RespondTo
     def respond_to?: (Symbol name, ?bool include_private) -> bool
     def class: -> Class
   end
+  interface _Sequenceable
+    def succ: -> self
+  end
   interface _Forgable
     def new: (Hash[Symbol, untyped]) -> self
   end
   interface _ForgeParameters
     def attributes: () -> Hash[Symbol, untyped]
     def traits: () -> Hash[Symbol, Hash[Symbol, untyped]]
+    def mold: () -> ObjectForge::mold?
+  end
+
+  class Error < StandardError
+  end
+  class DSLError < Error
   end
 
   VERSION: String
   DEFAULT_YARD: ObjectForge::Forgeyard
 
   def self.sequence
-    : (?(ObjectForge::_Sequenceable | ObjectForge::Sequence) initial) -> ObjectForge::Sequence
+    : (?(ObjectForge::sequenceable | ObjectForge::Sequence) initial) -> ObjectForge::Sequence
 
   def self.define
     : (Symbol name, ObjectForge::_Forgable forged) { (ObjectForge::ForgeDSL) -> void } -> ObjectForge::Forge
     | (Symbol name, ObjectForge::_Forgable forged) { [self: ObjectForge::ForgeDSL] -> void } -> ObjectForge::Forge
 
   def self.forge
-    : (Symbol name, *Symbol traits, **untyped overrides) -> ObjectForge::_Forgable
+    : (Symbol name, *Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
 end
 
 class ObjectForge::Sequence
   def self.new
-    : (?(ObjectForge::_Sequenceable | ObjectForge::Sequence) initial) -> ObjectForge::Sequence
+    : (?(ObjectForge::sequenceable | ObjectForge::Sequence) initial) -> ObjectForge::Sequence
   
-  attr_reader initial: ObjectForge::_Sequenceable
+  attr_reader initial: ObjectForge::sequenceable
   
-  def initialize: (ObjectForge::_Sequenceable initial) -> void
+  def initialize: (ObjectForge::sequenceable initial) -> void
 
-  def next: -> ObjectForge::_Sequenceable
+  def next: -> ObjectForge::sequenceable
 
-  def reset: -> ObjectForge::_Sequenceable
+  def reset: -> ObjectForge::sequenceable
   alias rewind reset
 end
   
@@ -59,7 +65,7 @@ class ObjectForge::Forgeyard
     : (Symbol name, ObjectForge::Forge forge) -> ObjectForge::Forge
 
   def forge
-    : (Symbol name, *Symbol traits, **untyped overrides) -> ObjectForge::_Forgable
+    : (Symbol name, *Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
   alias build forge
   alias [] forge
 end
@@ -68,10 +74,12 @@ class ObjectForge::Forge
   class Parameters
     include ObjectForge::_ForgeParameters
 
-    def intitialize
+    def initialize
       : (attributes: Hash[Symbol, untyped], traits: Hash[Symbol, Hash[Symbol, untyped]]) -> void
   end
 
+  MOLD_MOLD: ObjectForge::Molds::MoldMold
+
   attr_reader forged: ObjectForge::_Forgable
   attr_reader name: Symbol
 
@@ -83,20 +91,19 @@ class ObjectForge::Forge
     : (ObjectForge::_Forgable forged, ObjectForge::_ForgeParameters parameters, ?name: Symbol?) -> void
   
   def forge
-    : (*Symbol traits, **untyped overrides) -> ObjectForge::_Forgable
-    | (Array[Symbol] traits, Hash[Symbol, untyped] overrides) -> ObjectForge::_Forgable
+    : (*Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
   alias build forge
   alias [] forge
 
   private
 
-  def check_traits_and_overrides
-    : (Array[Symbol] traits, Hash[Symbol, untyped] overrides) -> [Array[Symbol], Hash[Symbol, untyped]]
-   | (Array[(Array[Symbol] | Hash[Symbol, untyped])], Hash[Symbol, untyped]) -> [Array[Symbol], Hash[Symbol, untyped]]
+  def resolve_attributes
+    : (Array[Symbol] traits, Hash[Symbol, untyped] overrides) -> Hash[Symbol, untyped]
 end
 
 class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
   include ObjectForge::_ForgeParameters
+
   attr_reader sequences: Hash[Symbol, ObjectForge::Sequence]
 
   @attributes: Hash[Symbol, Proc]
@@ -109,13 +116,15 @@ class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
 
   def freeze: -> self
 
+  def mold=
+    : (ObjectForge::mold) -> void
+
   def attribute
-    : (Symbol name) { -> untyped } -> Symbol
-    | (Symbol name) { (ObjectForge::_Sequenceable) -> untyped } -> Symbol
+    : (Symbol name) { [self: ObjectForge::Crucible] -> untyped } -> Symbol
   alias [] attribute
 
   def sequence
-    : (Symbol name, ?(ObjectForge::_Sequenceable | ObjectForge::Sequence) initial) { (ObjectForge::_Sequenceable) -> untyped } -> Symbol
+    : (Symbol name, ?(ObjectForge::sequenceable | ObjectForge::Sequence) initial) { (ObjectForge::sequenceable) [self: ObjectForge::Crucible] -> untyped } -> Symbol
 
   def trait
     : (Symbol name) { (self) -> void } -> Symbol
@@ -125,7 +134,7 @@ class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
   private
 
   def method_missing
-    : (Symbol name) { -> untyped } -> Symbol
+    : (Symbol name) { [self: ObjectForge::Crucible] -> untyped } -> Symbol
     # After freezing:
     | (Symbol name) { -> untyped } -> void
 
@@ -182,5 +191,5 @@ class ObjectForge::UnBasicObject < BasicObject
 
   def block_given?: -> bool
 
-  def raise: (_Exception exception, ?String message) -> void
+  def raise: (_Exception exception, ?String message, ?Array[String] backtrace, ?cause: _Exception) -> void
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: object_forge
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Alexandr Bulancov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-30 00:00:00.000000000 Z
+date: 2025-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -30,6 +30,7 @@ description: |
   It has no connection to any framework and, indeed, has nothing to do with a database.
   To use, just define some factories and call them wherever you need,
   be it in tests, console, or application code.
+  If needed, almost any part of the process can be easily replaced with a custom solution.
 email:
 executables: []
 extensions: []
@@ -40,19 +41,27 @@ files:
 - lib/object_forge/forge.rb
 - lib/object_forge/forge_dsl.rb
 - lib/object_forge/forgeyard.rb
+- lib/object_forge/molds.rb
+- lib/object_forge/molds/hash_mold.rb
+- lib/object_forge/molds/keywords_mold.rb
+- lib/object_forge/molds/mold_mold.rb
+- lib/object_forge/molds/single_argument_mold.rb
+- lib/object_forge/molds/struct_mold.rb
+- lib/object_forge/molds/wrapped_mold.rb
 - lib/object_forge/sequence.rb
 - lib/object_forge/un_basic_object.rb
 - lib/object_forge/version.rb
 - sig/object_forge.rbs
+- sig/object_forge/molds.rbs
 homepage: https://github.com/trinistr/object_forge
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/trinistr/object_forge
   bug_tracker_uri: https://github.com/trinistr/object_forge/issues
-  documentation_uri: https://rubydoc.info/gems/object_forge/0.1.0
-  source_code_uri: https://github.com/trinistr/object_forge/tree/v0.1.0
-  changelog_uri: https://github.com/trinistr/object_forge/blob/v0.1.0/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/object_forge/0.2.0
+  source_code_uri: https://github.com/trinistr/object_forge/tree/v0.2.0
+  changelog_uri: https://github.com/trinistr/object_forge/blob/v0.2.0/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options:
@@ -71,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: A simple factory for objects with minimal assumptions.