object_forge 0.3.0 → 0.4.1

data/sig/object_forge.rbs

@@ -1,6 +1,10 @@
 module ObjectForge
-  type mold = Object & ObjectForge::_Mold
-  type sequenceable = ObjectForge::_RespondTo & ObjectForge::_Sequenceable
+  type forge_target = untyped
+  type forge_result = untyped
+  type attribute = untyped
+
+  type mold = ::Object & _Mold
+  type sequenceable = _RespondTo & _Sequenceable
 
   interface _RespondTo
     def respond_to?: (Symbol name, ?bool include_private) -> bool
@@ -9,47 +13,54 @@ module ObjectForge
   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 settings: () -> Hash[Symbol, untyped]
+    def attributes: () -> Hash[Symbol, ObjectForge::attribute]
+    def traits: () -> Hash[Symbol, Hash[Symbol, ObjectForge::attribute]]
+    def options: () -> Hash[Symbol, untyped]
   end
   interface _Mold
     def call
-      : (forged: untyped, attributes: Hash[Symbol, untyped], **untyped) -> untyped
+      : (forge_target: ObjectForge::forge_target, attributes: Hash[Symbol, ObjectForge::attribute], **untyped) -> ObjectForge::forge_result
+  end
+  interface _Crucible
+    def call
+      : (Hash[Symbol, ObjectForge::attribute]) -> Hash[Symbol, ObjectForge::attribute]
+  end
+  interface _Hook
+    def call
+      : (ObjectForge::forge_result) -> void
   end
 
   class Error < StandardError
   end
   class DSLError < Error
   end
-  class MoldError < Error
+  class CircularAttributeDependencyError < Error
+  end
+  class ObjectInterfaceError < ::TypeError
   end
 
-  VERSION: String
+  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
+    : (Symbol name, ObjectForge::forge_target) { (ObjectForge::ForgeDSL) -> void } -> ObjectForge::Forge
+    | (Symbol name, ObjectForge::forge_target) { [self: ObjectForge::ForgeDSL] -> void } -> ObjectForge::Forge
 
   def self.forge
-    : (Symbol name, *Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
+    : (Symbol name, *Symbol traits, **ObjectForge::attribute overrides) ?{ (ObjectForge::forge_result) -> void } -> ObjectForge::forge_result
   def self.build
-    : (Symbol name, *Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
+    : (Symbol name, *Symbol traits, **ObjectForge::attribute overrides) ?{ (ObjectForge::forge_result) -> void } -> ObjectForge::forge_result
   def self.call
-    : (Symbol name, *Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
+    : (Symbol name, *Symbol traits, **ObjectForge::attribute overrides) ?{ (ObjectForge::forge_result) -> void } -> ObjectForge::forge_result
 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
   
@@ -68,8 +79,8 @@ class ObjectForge::Forgeyard
     : () -> void
 
   def define
-    : (Symbol name, ObjectForge::_Forgable forged) { (ObjectForge::ForgeDSL) -> void } -> ObjectForge::Forge
-    | (Symbol name, ObjectForge::_Forgable forged) { [self: ObjectForge::ForgeDSL] -> void } -> ObjectForge::Forge
+    : (Symbol name, ObjectForge::forge_target) { (ObjectForge::ForgeDSL) -> void } -> ObjectForge::Forge
+    | (Symbol name, ObjectForge::forge_target) { [self: ObjectForge::ForgeDSL] -> void } -> ObjectForge::Forge
 
   def register
     : (Symbol name, ObjectForge::Forge forge) -> ObjectForge::Forge
@@ -78,41 +89,56 @@ class ObjectForge::Forgeyard
     : (Symbol name) -> ObjectForge::Forge
 
   def forge
-    : (Symbol name, *Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
+    : (Symbol name, *Symbol traits, **ObjectForge::attribute overrides) ?{ (ObjectForge::forge_result) -> void } -> ObjectForge::forge_result
   alias build forge
   alias call forge
 end
 
 class ObjectForge::Forge
-  class Parameters
+  class Parameters < Struct[Hash[Symbol, untyped]]
     include ObjectForge::_ForgeParameters
 
+    # Struct allows skipping arguments, but in reality they are all required.
     def initialize
-      : (attributes: Hash[Symbol, untyped], traits: Hash[Symbol, Hash[Symbol, untyped]]) -> void
+      : (attributes: Hash[Symbol, ObjectForge::attribute], traits: Hash[Symbol, Hash[Symbol, ObjectForge::attribute]], options: Hash[Symbol, untyped]) -> void
   end
 
-  attr_reader forged: ObjectForge::_Forgable
-  attr_reader name: Symbol
+  attr_reader forge_target: ObjectForge::forge_target
+  alias target forge_target
+
+  attr_reader name: Symbol?
+
+  attr_reader parameters: ObjectForge::_ForgeParameters
+
+  @crucible: ObjectForge::_Crucible
+  @mold: ObjectForge::_Mold
+  @after_forge_hook: ObjectForge::_Hook?
 
   def self.define
-    : (ObjectForge::_Forgable forged, ?name: Symbol?) { (ObjectForge::ForgeDSL) -> void } -> ObjectForge::Forge
-    | (ObjectForge::_Forgable forged, ?name: Symbol?) { [self: ObjectForge::ForgeDSL] -> void } -> ObjectForge::Forge
+    : (ObjectForge::forge_target, ?name: Symbol?) { (ObjectForge::ForgeDSL) -> void } -> ObjectForge::Forge
+    | (ObjectForge::forge_target, ?name: Symbol?) { [self: ObjectForge::ForgeDSL] -> void } -> ObjectForge::Forge
   
   def initialize
-    : (ObjectForge::_Forgable forged, ObjectForge::_ForgeParameters parameters, ?name: Symbol?) -> void
+    : (ObjectForge::forge_target, ObjectForge::_ForgeParameters parameters, ?name: Symbol?) -> void
   
   def forge
-    : (*Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
+    : (*Symbol traits, **ObjectForge::attribute overrides) ?{ (ObjectForge::forge_result) -> void } -> ObjectForge::forge_result
   alias build forge
   alias call forge
 
   private
+  
+  def determine_crucible
+    : (Hash[Symbol, untyped]) -> ObjectForge::_Crucible
 
   def determine_mold
-    : (ObjectForge::_Forgable forged, ObjectForge::mold mold) -> ObjectForge::mold
+    : (ObjectForge::forge_target, Hash[Symbol, untyped]) -> ObjectForge::mold
+
+  def determine_after_forge_hook
+    : (Hash[Symbol, untyped] options) -> ObjectForge::_Hook?
 
   def resolve_attributes
-    : (Array[Symbol] traits, Hash[Symbol, untyped] overrides) -> Hash[Symbol, untyped]
+    : (Array[Symbol] traits, Hash[Symbol, ObjectForge::attribute] overrides) -> Hash[Symbol, ObjectForge::attribute]
 end
 
 class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
@@ -123,7 +149,7 @@ class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
   @attributes: Hash[Symbol, Proc]
   @sequences: Hash[Symbol, ObjectForge::Sequence]
   @traits: Hash[Symbol, Hash[Symbol, Proc]]
-  @settings: Hash[Symbol, untyped]
+  @options: Hash[Symbol, untyped]
 
   def initialize
     : () { (ObjectForge::ForgeDSL) -> void } -> void
@@ -131,15 +157,16 @@ class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
 
   def freeze: -> self
 
-  def setting
+  def option
     : (Symbol name, untyped value) -> Symbol
 
   def attribute
-    : (Symbol name) { [self: ObjectForge::Crucible] -> untyped } -> Symbol
+    : (Symbol name) { [self: ObjectForge::Crucible] -> ObjectForge::attribute } -> Symbol
   alias [] attribute
 
   def sequence
     : (Symbol name, ?(ObjectForge::sequenceable | ObjectForge::Sequence) initial) { (ObjectForge::sequenceable) [self: ObjectForge::Crucible] -> untyped } -> Symbol
+    | (Symbol name, ?(ObjectForge::sequenceable | ObjectForge::Sequence) initial) -> Symbol
 
   def trait
     : (Symbol name) { (self) -> void } -> Symbol
@@ -149,35 +176,50 @@ class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
   private
 
   def method_missing
+    # Attribute shortcut:
     : (Symbol name) { [self: ObjectForge::Crucible] -> untyped } -> Symbol
+    # Option shortcut:
+    | (Symbol name, untyped value) -> Symbol
     # After freezing:
     | (Symbol name) { -> untyped } -> void
 
   def respond_to_missing?
     : (Symbol name, bool include_all) -> bool
   
-  def valid_setting_method?
+  def valid_option_method?
     : (Symbol name) -> bool
 end
 
 class ObjectForge::Crucible < ObjectForge::UnBasicObject
-  @attributes: Hash[Symbol, untyped]
+  def self.call
+    : (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+  def self.resolve
+    : (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+
+  @attributes: Hash[Symbol, ObjectForge::attribute]
   @resolved_attributes: Set[Symbol]
+  @resolving_attributes: Array[Symbol]
 
   def initialize
-    : (Hash[Symbol, untyped] attributes) -> void
+    : (Hash[Symbol, ObjectForge::attribute] attributes) -> void
 
   def resolve!
-    : -> Hash[Symbol, untyped]
+    : -> Hash[Symbol, ObjectForge::attribute]
 
   private
 
   def method_missing
-    : (Symbol name) -> untyped
+    : (Symbol name) -> ObjectForge::attribute
   alias [] method_missing
 
   def respond_to_missing?
     : (Symbol name, bool include_all) -> bool
+  
+  def raise_circular_dependency_error!
+    : (Symbol name) -> void
+  
+  def resolve_attribute!
+    : (Symbol name) -> void
 end
 
 class ObjectForge::UnBasicObject < BasicObject
@@ -200,9 +242,9 @@ class ObjectForge::UnBasicObject < BasicObject
 
   def to_s: -> String
 
-  def pretty_print: (untyped) -> void
+  def pretty_print: (PP) -> void
 
-  def pretty_print_cycle: (untyped) -> void
+  def pretty_print_cycle: (PP) -> void
   
   private
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: object_forge
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Alexander Bulancov
@@ -24,12 +24,16 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.2'
 description: |
-  ObjectForge provides a familiar way to build objects in any context
-  with minimal assumptions about usage environment.
-  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.
+  ObjectForge is a small factory library for Ruby objects with minimal assumptions
+  about framework, persistence, or runtime environment.
+
+  It is designed for cases where factory-style object construction is useful,
+  but Rails-oriented or database-oriented tooling is a poor fit. ObjectForge
+  works well with plain Ruby objects, hashes, structs, and custom build flows.
+
+  The library focuses on explicit configuration, independent registries and factories,
+  and replaceable components. It aims to provide a familiar workflow without
+  coupling object generation to a framework or persistence layer.
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -58,9 +62,9 @@ licenses:
 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.3.0
-  source_code_uri: https://github.com/trinistr/object_forge/tree/v0.3.0
-  changelog_uri: https://github.com/trinistr/object_forge/blob/v0.3.0/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/object_forge/0.4.1
+  source_code_uri: https://github.com/trinistr/object_forge/tree/v0.4.1
+  changelog_uri: https://github.com/trinistr/object_forge/blob/v0.4.1/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options:
 - "--tag"
@@ -82,5 +86,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: A simple factory for objects with minimal assumptions.
+summary: A small, flexible factory library for plain Ruby objects, hashes, structs
+  and custom build flows.
 test_files: []