object_forge 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05dce89141257f37f8b8af6a7f0cdfb1d7ee785a37ad119d0c13ff28c58d9245
-  data.tar.gz: e171f2f3d504d0edadfdb5f2ba2f87d9d9edd1a0f175a0be366b12dc528182a0
+  metadata.gz: 83440b5319d1e909379d16b67830ad1f67f575358473dd4ba5914cb549c417b9
+  data.tar.gz: 279a5756a157f96252081cb60ce0541bdffdf1e21a25fe72db19b622c7d717e8
 SHA512:
-  metadata.gz: c8a330629ce325a8bf78930a3025d5c1d75305e80c970cb5217e9d4ae6f93659d3fc9d3fdd89884920b5843c8c1bfb787bdfc6be8ce220db29124a2d73a749da
-  data.tar.gz: a0515b9f4111c0e3bcd1b9bbb4f5cb3011bb12bba62750a2ca0f49b702f55a459be7877fb540cf16c6a40503a5c2294e962352408345e67bbb7179bc79f2539b
+  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,19 +47,20 @@ 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.
@@ -67,7 +77,7 @@ module ObjectForge
     # 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
@@ -76,7 +86,7 @@ module ObjectForge
     # @return [Any] built instance
     def forge(*traits, **overrides)
       resolved_attributes = resolve_attributes(traits, overrides)
-      instance = build_instance(resolved_attributes)
+      instance = @mold.call(forged: @forged, attributes: resolved_attributes)
       yield instance if block_given?
       instance
     end
@@ -90,9 +100,5 @@ module ObjectForge
       attributes = @parameters.attributes.merge(*@parameters.traits.values_at(*traits), overrides)
       Crucible.new(attributes).resolve!
     end
-
-    def build_instance(attributes)
-      forged.new(attributes)
-    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
@@ -55,8 +57,8 @@ module ObjectForge
     # @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

@@ -1,19 +1,23 @@
 # frozen_string_literal: true
 
-# module ObjectForge
-#   module Molds
-#     # Mold which calls +forged.new(**attributes)+.
-#     #
-#     # @since 0.1.1
-#     class KeywordsMold
-#       # Instantiate +forged+ with a hash of attributes.
-#       #
-#       # @param forged [Class]
-#       # @param attributes [Hash{Symbol => Any}]
-#       # @return [Any]
-#       def call(forged:, attributes:, **)
-#         forged.new(**attributes)
-#       end
-#     end
-#   end
-# end
+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/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.1"
+  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

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,11 +1,12 @@
 module ObjectForge
+  type mold = ObjectForge::_RespondTo & ObjectForge::_Mold
   type sequenceable = ObjectForge::_RespondTo & ObjectForge::_Sequenceable
 
   interface _RespondTo
     def respond_to?: (Symbol name, ?bool include_private) -> bool
     def class: -> Class
   end
-interface _Sequenceable
+  interface _Sequenceable
     def succ: -> self
   end
   interface _Forgable
@@ -14,6 +15,7 @@ interface _Sequenceable
   interface _ForgeParameters
     def attributes: () -> Hash[Symbol, untyped]
     def traits: () -> Hash[Symbol, Hash[Symbol, untyped]]
+    def mold: () -> ObjectForge::mold?
   end
 
   class Error < StandardError
@@ -76,6 +78,8 @@ class ObjectForge::Forge
       : (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
 
@@ -95,9 +99,6 @@ class ObjectForge::Forge
 
   def resolve_attributes
     : (Array[Symbol] traits, Hash[Symbol, untyped] overrides) -> Hash[Symbol, untyped]
-
-  def build_instance
-    : (Hash[Symbol, untyped] attributes) -> ObjectForge::_Forgable
 end
 
 class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
@@ -115,6 +116,9 @@ class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
 
   def freeze: -> self
 
+  def mold=
+    : (ObjectForge::mold) -> void
+
   def attribute
     : (Symbol name) { [self: ObjectForge::Crucible] -> untyped } -> Symbol
   alias [] attribute

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: object_forge
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Alexandr Bulancov
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -30,6 +31,7 @@ description: |
   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: []
 extra_rdoc_files: []
@@ -39,21 +41,29 @@ 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.1
-  source_code_uri: https://github.com/trinistr/object_forge/tree/v0.1.1
-  changelog_uri: https://github.com/trinistr/object_forge/blob/v0.1.1/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:
 - "--tag"
 - thread_safety:Thread safety
@@ -70,7 +80,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: A simple factory for objects with minimal assumptions.
 test_files: []