object_forge 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9481504e1456ec667e1c0182ecef5456cb2c9094b62ba6e09da62f0c1c79a00e
-  data.tar.gz: d2c2fdcfd6807211ea82987c998f4d2d8c6e0b1bbc334178330f97dfd8d7df7b
+  metadata.gz: 94a44e43942c8ff51412a23c866e1f87984d9c2207b044492ea77d07150199d5
+  data.tar.gz: 2ca03af3ee44ce7005dd8e242266f7fb8409c54ebf560028ebbf8b6727ceaf0e
 SHA512:
-  metadata.gz: 85b341cae5396f0eee11f00e6084bfbdc4561070c4657d3e7265570b48f195789c4a8763220d81f38f2dd4c31573a36064aecf346f9e6ffac8e07dbcbcf86720
-  data.tar.gz: dc7faa45a80ce51ac2b4f57f7a88134b8c6a44ad3889f06b896962aa6de711c7fee36b70b7952ba80e19b95d036e838c169abebc375712a76b29e21e7ff54815
+  metadata.gz: 58221f62b2aef297f053030da5b766518dec5547285c57b8f0330e0e83c15d1a5ed6fba651790900e36d7674c4206a3e70e19d45900645ce633b545a1717509b
+  data.tar.gz: 39109437f0647115364b504d0d0bca8af66fc76f2c573870c3939c0aca2798c709a52ce920365290a767b30adae5a193271e32a17fd99e3de9eb6edc07b3f2ab

data/lib/object_forge/crucible.rb

@@ -88,19 +88,10 @@ module ObjectForge
     # @return [Any]
     #
     # @raise [CircularAttributeDependencyError] if a dependency cycle is detected
-    def method_missing(name) # rubocop:disable Metrics/MethodLength
+    def method_missing(name)
       if @attributes.key?(name)
-        if @resolving_attributes.include?(name)
-          raise_circular_dependency_error!(name)
-        elsif !@resolved_attributes.include?(name) && (::Proc === @attributes[name])
-          begin
-            @resolving_attributes << name
-            @attributes[name] = instance_exec(&@attributes[name])
-            @resolved_attributes << name
-          ensure
-            @resolving_attributes.pop
-          end
-        end
+        raise_circular_dependency_error!(name) if @resolving_attributes.include?(name)
+        resolve_attribute!(name) unless @resolved_attributes.include?(name)
         @attributes[name]
       else
         super
@@ -119,5 +110,15 @@ module ObjectForge
       raise CircularAttributeDependencyError,
             "attribute depends on itself: #{loop.join(" -> ")} -> #{name}"
     end
+
+    def resolve_attribute!(name)
+      return unless (attribute_proc = @attributes[name]) && (::Proc === attribute_proc)
+
+      @resolving_attributes << name
+      @attributes[name] = instance_exec(&attribute_proc) # steep:ignore BlockTypeMismatch
+      @resolved_attributes << name
+    ensure
+      @resolving_attributes.pop
+    end
   end
 end

data/lib/object_forge/forge.rb

@@ -189,7 +189,8 @@ module ObjectForge
               "unknown traits for forge#{" #{name}" if name}: #{unknown_traits.join(", ")}"
       end
 
-      attributes = @parameters.attributes.merge(*@parameters.traits.values_at(*traits), overrides)
+      trait_attributes = @parameters.traits.values_at(*traits) # : Array[Hash[Symbol, ObjectForge::attribute]]
+      attributes = @parameters.attributes.merge(*trait_attributes, overrides)
       @crucible.call(attributes)
     end
   end

data/lib/object_forge/forge_dsl.rb

@@ -103,8 +103,9 @@ module ObjectForge
     # @raise [TypeError] if +name+ is not a Symbol
     def option(name, value)
       unless ::Symbol === name
-        raise ::TypeError, "option name must be a Symbol, #{name.class} given"
+        raise ::TypeError, "option name must be a Symbol, #{name.class} given (in #{name.inspect})"
       end
+      raise DSLError, "option definition does not take a block (in #{name.inspect})" if block_given?
 
       @options[name] = value
 
@@ -197,7 +198,7 @@ module ObjectForge
       seq = @sequences[name] ||= Sequence.new(initial)
 
       if block_given?
-        attribute(name) { instance_exec(seq.next, &) }
+        attribute(name) { instance_exec(seq.next, &) } # steep:ignore BlockTypeMismatch
       else
         attribute(name) { seq.next }
       end
@@ -287,10 +288,13 @@ module ObjectForge
     # @raise [DSLError] if a reserved +name+ is used
     def method_missing(name, value = nil, **nil, &)
       return super(name) if frozen?
+
       if valid_option_method?(name)
-        return option(name[...-1].to_sym, value) # steep:ignore NoMethod
+        # Intentionally passing block to `option` to trigger DSLError if it is present.
+        return option(name[...-1].to_sym, value, &) # steep:ignore NoMethod, UnexpectedBlockGiven
       end
-      return attribute(name, &) if respond_to_missing?(name, false)
+      # Block can be missing, but `attribute` will raise if it is.
+      return attribute(name, &) if respond_to_missing?(name, false) # steep:ignore BlockTypeMismatch
 
       raise DSLError, "#{name.inspect} is a reserved name (in #{name.inspect})"
     end

data/lib/object_forge/version.rb

@@ -2,5 +2,5 @@
 
 module ObjectForge
   # Current version
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/sig/object_forge/molds.rbs

@@ -3,15 +3,7 @@ module ObjectForge
     def self.wrap_mold
       : ((ObjectForge::mold | Class | nil) mold) -> ObjectForge::mold?
     def self.mold_for
-      : (ObjectForge::_Forgable forge_target) -> ObjectForge::mold
-
-    class SingleArgumentMold
-      include ObjectForge::_Mold
-    end
-
-    class KeywordsMold
-      include ObjectForge::_Mold
-    end
+      : (ObjectForge::forge_target) -> ObjectForge::mold
 
     class WrappedMold
       interface _MoldClass[T]
@@ -25,43 +17,53 @@ module ObjectForge
       def initialize: (_MoldClass[ObjectForge::mold] wrapped_mold) -> void
     end
 
+    class SingleArgumentMold
+      include ObjectForge::_Mold
+    end
+
+    class KeywordsMold
+      include ObjectForge::_Mold
+    end
+
     class StructMold
       interface _StructSubclass[T]
         def new
           : (*untyped) -> T
           | (**untyped) -> T
-          | (Hash[Symbol, untyped]) -> T
+          | (Hash[Symbol, ObjectForge::attribute]) -> T
         def members: -> Array[Symbol]
         def keyword_init?: -> bool?
       end
 
       RUBY_FEATURE_AUTO_KEYWORDS: bool
+
       attr_reader lax: bool
+      alias lax? lax
 
       def initialize: (?lax: bool) -> void
 
       def call
-        : [T < Struct] (forge_target: _StructSubclass[T], attributes: Hash[Symbol, untyped], **untyped) -> T
+        : [T < Struct] (forge_target: _StructSubclass[T], attributes: Hash[Symbol, ObjectForge::attribute], **untyped) -> T
       
       private
       
       def build_struct_with_unspecified_keyword_init
-        : [T < Struct] (_StructSubclass[T] forge_target, Hash[Symbol, untyped] attributes) -> T
+        : [T < Struct] (_StructSubclass[T] forge_target, Hash[Symbol, ObjectForge::attribute] attributes) -> T
     end
 
     class HashMold
       interface _HashSubclass[T]
-        def []: (Hash[untyped, untyped]) -> T
+        def []: (Hash[Symbol, ObjectForge::attribute]) -> T
       end
 
-      attr_reader default: untyped?
+      attr_reader default: ObjectForge::attribute
       attr_reader default_proc: Proc?
 
       def initialize
-        : (?untyped? default_value) ?{ (Hash[untyped, untyped] hash, untyped key) -> untyped} -> void
+        : [T < Hash] (?ObjectForge::attribute default_value) ?{ (T hash, untyped key) -> ObjectForge::attribute} -> void
       
       def call
-        : [T < Hash] (forge_target: _HashSubclass[T], attributes: Hash[Symbol, untyped], **untyped) -> T
+        : [T < Hash] (forge_target: _HashSubclass[T], attributes: Hash[Symbol, ObjectForge::attribute], **untyped) -> T
     end
   end
 end

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,25 +13,22 @@ 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 attributes: () -> Hash[Symbol, ObjectForge::attribute]
+    def traits: () -> Hash[Symbol, Hash[Symbol, ObjectForge::attribute]]
     def options: () -> Hash[Symbol, untyped]
   end
   interface _Mold
     def call
-      : (forge_target: 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, untyped]) -> Hash[Symbol, untyped]
+      : (Hash[Symbol, ObjectForge::attribute]) -> Hash[Symbol, ObjectForge::attribute]
   end
   interface _Hook
     def call
-      : (ObjectForge::_Forgable) -> void
+      : (ObjectForge::forge_result) -> void
   end
 
   class Error < StandardError
@@ -36,30 +37,30 @@ module ObjectForge
   end
   class CircularAttributeDependencyError < Error
   end
-  class ObjectInterfaceError < Error
+  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 forge_target) { (ObjectForge::ForgeDSL) -> void } -> ObjectForge::Forge
-    | (Symbol name, ObjectForge::_Forgable forge_target) { [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
   
@@ -78,8 +79,8 @@ class ObjectForge::Forgeyard
     : () -> void
 
   def define
-    : (Symbol name, ObjectForge::_Forgable forge_target) { (ObjectForge::ForgeDSL) -> void } -> ObjectForge::Forge
-    | (Symbol name, ObjectForge::_Forgable forge_target) { [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
@@ -88,32 +89,40 @@ 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 forge_target: ObjectForge::_Forgable
+  attr_reader forge_target: ObjectForge::forge_target
   alias target forge_target
-  attr_reader name: Symbol
+
+  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 forge_target, ?name: Symbol?) { (ObjectForge::ForgeDSL) -> void } -> ObjectForge::Forge
-    | (ObjectForge::_Forgable forge_target, ?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 forge_target, 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
 
@@ -123,13 +132,13 @@ class ObjectForge::Forge
     : (Hash[Symbol, untyped]) -> ObjectForge::_Crucible
 
   def determine_mold
-    : (ObjectForge::_Forgable forge_target, Hash[Symbol, untyped]) -> 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
@@ -152,11 +161,12 @@ class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
     : (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
@@ -166,7 +176,10 @@ 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
 
@@ -183,20 +196,20 @@ class ObjectForge::Crucible < ObjectForge::UnBasicObject
   def self.resolve
     : (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
 
-  @attributes: 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?
@@ -204,6 +217,9 @@ class ObjectForge::Crucible < ObjectForge::UnBasicObject
   
   def raise_circular_dependency_error!
     : (Symbol name) -> void
+  
+  def resolve_attribute!
+    : (Symbol name) -> void
 end
 
 class ObjectForge::UnBasicObject < BasicObject
@@ -226,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.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Alexander Bulancov
@@ -62,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.4.0
-  source_code_uri: https://github.com/trinistr/object_forge/tree/v0.4.0
-  changelog_uri: https://github.com/trinistr/object_forge/blob/v0.4.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"