object_forge 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94a44e43942c8ff51412a23c866e1f87984d9c2207b044492ea77d07150199d5
-  data.tar.gz: 2ca03af3ee44ce7005dd8e242266f7fb8409c54ebf560028ebbf8b6727ceaf0e
+  metadata.gz: a0800625b2fdd91bc43b347e97fbbdbcad8f7a4953e2a1543bd29b602039ba2c
+  data.tar.gz: 3cfea11020226e4052b25127af3763df2fa5db8b80d5261aa0b7c8b3e2b20547
 SHA512:
-  metadata.gz: 58221f62b2aef297f053030da5b766518dec5547285c57b8f0330e0e83c15d1a5ed6fba651790900e36d7674c4206a3e70e19d45900645ce633b545a1717509b
-  data.tar.gz: 39109437f0647115364b504d0d0bca8af66fc76f2c573870c3939c0aca2798c709a52ce920365290a767b30adae5a193271e32a17fd99e3de9eb6edc07b3f2ab
+  metadata.gz: 72c01d3be5fe72716a08fa6fb826fc16b4464a9a7086168e0efe708159e867da6d162107a96f6a5f1f9f1712a409c565e5f4da576232f9a2f93e24d979211bdd
+  data.tar.gz: bc2e52673353fb0ffc63944abdc864b2668d671921c2184dec62d5f45a2709c0a6e62ec7ebe937b4a9a9c8fa44f9a93bce05501512006d3988344a5492e3e9c1

data/README.md

@@ -4,15 +4,17 @@
 [![CI](https://github.com/trinistr/object_forge/actions/workflows/CI.yaml/badge.svg)](https://github.com/trinistr/object_forge/actions/workflows/CI.yaml)
 
 > [!TIP]
+>
 > You may be viewing documentation for an older (or newer) version of the gem than intended. Look at [Changelog](https://github.com/trinistr/object_forge/blob/main/CHANGELOG.md) to see all versions, including unreleased changes.
 
-***
+---
 
 **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.
+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, arrays, structs, and custom build flows.
 
 The library focuses on:
+
 - explicit configuration over hidden conventions
 - support for independent registries and standalone factories
 - replaceable components based on simple interfaces
@@ -25,12 +27,13 @@ If you need factory-style object generation without coupling it to Rails, Active
 - [Motivation](#motivation)
 - [Installation](#installation)
 - [Usage](#usage)
-  - [Quick start](#quick-start)
-  - [Basics](#basics)
-  - [Independent forgeyards and forges](#independent-forgeyards-and-forges)
-  - [Molds: configuring object construction](#molds-configuring-object-construction)
-  - [After-build customization](#after-build-customization)
-  - [Performance tips](#performance-tips)
+    - [Quick start](#quick-start)
+    - [Basics](#basics)
+    - [Independent forgeyards and forges](#independent-forgeyards-and-forges)
+    - [Association-like nested objects](#association-like-nested-objects)
+    - [Defining final attribute list](#defining-final-attribute-list)
+    - [Molds: configuring object construction](#molds-configuring-object-construction)
+    - [After-build customization](#after-build-customization)
 - [Differences and limitations (compared to FactoryBot)](#differences-and-limitations-compared-to-factorybot)
 - [Current and planned features (roadmap)](#current-and-planned-features-roadmap)
 - [Development](#development)
@@ -44,12 +47,14 @@ Ruby already has well-known factory libraries, especially FactoryBot and Fabrica
 **ObjectForge** aims at a different problem space: building objects with a factory-style workflow while making as few assumptions as possible about framework, storage, object lifecycle, or application structure.
 
 **ObjectForge** is particularly useful when:
+
 - the objects being built are plain Ruby objects rather than database-backed records
 - object generation is needed outside of tests, such as in services, scripts, or fixtures
 - multiple independent sets of factories need to coexist in the same project
 - construction behavior should be explicit and configurable rather than hidden behind framework conventions
 
 The project is intentionally small in scope. Rather than trying to model every style of factory workflow, it focuses on a compact, understandable core:
+
 - a DSL for defining attributes, sequences, and traits
 - forges (factories) and forgeyards (registries)
 - several object molds (constructors)
@@ -60,25 +65,30 @@ The goal is to have a simple, composable tool that you can easily reach for when
 ## Installation
 
 Install with `gem`:
+
 ```sh
 gem install object_forge
 ```
 
 Or, if using Bundler, add to your Gemfile:
+
 ```ruby
 gem "object_forge"
 ```
+
 and run `bundle install`.
 
 ## Usage
 
 > [!Note]
+>
 > - Latest documentation from `main` branch is automatically deployed to [GitHub Pages](https://trinistr.github.io/object_forge).
 > - Documentation for published versions is available on [RubyDoc](https://rubydoc.info/gems/object_forge).
 
 ### Quick start
 
 Create your domain logic class:
+
 ```ruby
 class Rectangle
   def initialize(length:, width:)
@@ -93,8 +103,10 @@ end
 ```
 
 Define a forge:
+
 ```ruby
 require "object_forge"
+
 ObjectForge.define(:rectangle, Rectangle) do |f|
   f.mold = ObjectForge::Molds::KeywordsMold.new
 
@@ -108,6 +120,7 @@ end
 ```
 
 Forge some objects!
+
 ```ruby
 ObjectForge.forge(:rectangle) # => [63x27]
 ObjectForge.forge(:rectangle, :square) # => [56x56]
@@ -120,6 +133,7 @@ ObjectForge.forge(:rectangle, :square, length: 123) # => [123x123]
 In the simplest cases, **ObjectForge** can be used much like other factory libraries, with definitions living in a global object (`ObjectForge::DEFAULT_YARD`). In this case, methods are called directly on `ObjectForge` module.
 
 Forges are defined using a DSL:
+
 ```ruby
 # Example class:
 Point = Struct.new(:id, :x, :y)
@@ -134,8 +148,8 @@ ObjectForge.define(:point, Point) do |f|
   f[:y] { rand(-delta..delta) }
   # There is also the familiar shortcut using `method_missing`:
   f.delta { 0.5 * amplitude }
-  # Notice how transient attributes don't require any special syntax:
-  f.amplitude { 1 }
+  # Depending on the class, transient attributes may need to be explicitly marked:
+  f.transient(:amplitude) { 1 }
   # `#sequence` defines a sequenced attribute (starting with 1 by default):
   f.sequence(:id, "a")
   # Traits allow to group and reuse related values:
@@ -154,6 +168,7 @@ end
 ```
 
 A forge builds objects, using attributes hash:
+
 ```ruby
 ObjectForge.call(:point)
   # => #<struct Point id="a", x=0.17176955469852973, y=0.3423901951181103>
@@ -173,36 +188,53 @@ ObjectForge.call(:point, :z, x: -> { rand(100..200) + delta })
 ObjectForge.call(:point, :z) { puts "#{_1.id}: #{_1.x},#{_1.y}" }
   # outputs "Z_e: 0.0,0.0"
 ```
+
 > [!TIP]
+>
 > Forging can be done through any of `#call`, `#forge`, or `#build` methods, they are aliases.
 
 ### Independent forgeyards and forges
 
 It is possible and *encouraged* to create multiple forgeyards, each with its own set of forges:
+
 ```ruby
 forgeyard = ObjectForge::Forgeyard.new
+
 forgeyard.define(:dot, Point) do |f|
   f.sequence(:id, "a")
-  f.x { rand(-radius..radius) }
-  f.y { rand(-radius..radius) }
-  f.radius { 0.5 }
-  f.trait :z do f.radius { 0 } end
+  f.x { rand(-variance..variance) }
+  f.y { rand(-variance..variance) }
+
+  f.variance { 0.5 }
+
+  f.trait :z do f.variance { 0 } end
 end
 ```
 
 Now, this forgeyard can be used just like the default one:
+
 ```ruby
 forgeyard.forge(:dot, :z, id: "0")
   # => #<struct Point id="0", x=0, y=0>
 ```
 
+And the forge can be referenced on its own:
+
+```ruby
+dot_forge = forgeyard[:dot]
+dot_forge.forge
+  # => #<struct Point id="a", x=0.3958959145276243, y=-0.04519596671967796>
+```
+
 Note how the forge isn't registered in the default forgeyard:
+
 ```ruby
 ObjectForge.forge(:dot)
   # KeyError: key not found
 ```
 
 If you find it more convenient not to use a forgeyard (for example, if you only need a single forge for your service), you can create individual forges:
+
 ```ruby
 forge = ObjectForge::Forge.define(Point) do |f|
   f.sequence(:id, "a")
@@ -214,6 +246,7 @@ end
 ```
 
 **Forge** has the same building interface as a **Forgeyard**, but it doesn't have the name argument:
+
 ```ruby
 forge.build
   # => #<struct Point id="a", x=0.3317733939650964, y=-0.1363936629550252>
@@ -223,21 +256,122 @@ forge.(radius: 500)
   # => #<struct Point id="c", x=-141, y=109>
 ```
 
+> [!TIP]
+>
+> Calling a **Forge** directly, instead of through **Forgeyard**, is faster due to not needing argument forwarding.
+
+### Association-like nested objects
+
+Nested objects can naturally be constructed in attribute definitions. However, forges defined through forgeyards provide a more convenient way to refer to their forgeyard in attribute definitions. It is fairly simple to build object graphs by putting related forges in the same `yard`:
+
+```ruby
+geometric_yard = ObjectForge::Forgeyard.new
+geometric_yard.define(:point, Point) do |f|
+  # ... reusing the Point forge from the forgeyard example above.
+end
+
+Ellipse = Data.define(:center, :major_semiaxis, :minor_semiaxis)
+geometric_yard.define(:circle, Ellipse) do |f|
+  # Current forge's forgeyard is available as `yard` pseudo-attribute:
+  f.center { yard.forge(:point) }
+  f.transient(:radius) { 1.0 }
+
+  f.major_semiaxis { radius }
+  f.minor_semiaxis { radius }
+end
+
+geometric_yard.forge(:circle, radius: 4.0)
+  # => #<data Ellipse center=#<struct Point id="a", x=0.3487797161039954, y=-0.11378243307810132>, major_semiaxis=4.0, minor_semiaxis=4.0>
+```
+
+There is an alternative way to refer to `yard`'s forges if no attribute has the same name — just mention it by name directly:
+
+```ruby
+Line = Data.define(:a, :b)
+geometric_yard.define(:segment, Line) do |f|
+  # There is no "point" attribute, so `point` refers to the forge:
+  f.a { point.forge(:z) }
+  f.b { point.forge }
+end
+
+geometric_yard.forge(:segment)
+  # => #<data Line a=#<struct Point id="b", x=0, y=0>, b=#<struct Point id="c", x=0.2701288765117644, y=0.008413574136415414>>
+```
+
+> [!IMPORTANT]
+>
+> Referring to a related forge by name is not special syntax the same way **FactoryBot**'s _associations_ are; it just returns the forge object, which then needs to be called to construct an instance.
+
+As objects are not initialized before attributes are resolved and set, it can be tricky to create circular references. If you find yourself needing to do this, an [after-forge hook](#after-build-customization) can be used to modify objects after building them.
+
+### Defining final attribute list
+
+Depending on what you are forging and the [mold](#molds-configuring-object-construction) used, you may need to limit the attributes that are passed to the forged instance. This can be done by using either `transient` attributes or the `attribute_list` option in the forge definition. Both options are equivalent in the end, so the choice is yours.
+
+#### Transient attributes
+
+Transient attributes can be defined using the `transient` method or `transient: true` argument. This automatically sets up attribute list to exclude the attribute, but otherwise doesn't change the behavior.
+
+```ruby
+# Note that this forge is forging a Hash, not a Struct.
+ObjectForge.define(:point, Hash) do |f|
+  # Transient "radius" is excluded from final attribute list:
+  f.transient(:radius) { 0.5 }
+  # Sequences can be transient too:
+  f.sequence(:s, transient: true) { |s| s * 30 }
+
+  f.x { s + rand(-radius..radius) }
+  f.y { s + rand(-radius..radius) }
+end
+
+ObjectForge.forge(:point)
+  # => {x: 30.092699961573118, y: 29.71344463733288}
+```
+
+#### Attribute list
+
+`transient` attributes are really just a convenient shortcut to specifying `attribute_list` option. Manually setting the list can be handy if uniform attribute definitions are desired, it is semantically meaningful to allowlist attributes rather than deny individually, or transient attributes don't appear in the definition. `attribute_list` can also be useful to define attribute ordering.
+
+```ruby
+ObjectForge.define(:point, Hash) do |f|
+  f.attribute_list = %i[x y z]
+  # Parameters:
+  f.unit { :m } # Meters by default
+  f.conversion { { mm: 10.0**0, m: 10.0**3, km: 10.0**6 } } # Conversion multipliers table
+  # Final attribute calculations:  
+  f.x { position[0] * conversion[unit] }
+  f.z { position[1] * conversion[unit] }
+  f.y { altitude * conversion[unit] }
+end
+
+# Note how `y` comes out as the second attribute, not the third:
+ObjectForge.forge(:point, position: [10, 13.4], altitude: 5)
+  # => {x: 10000.0, y: 5000.0, z: 13400.0}
+ObjectForge.forge(:point, position: [10, 13.4], altitude: 5, unit: :mm)
+  # => {x: 10.0, y: 5.0, z: 13.4}
+```
+
+> [!NOTE]
+>
+> `attribute_list` and `transient` attributes can be used in the same definition. However, transient attributes **can't** appear in attribute list; this will raise an error.
+
 ### Molds: configuring object construction
 
 If you use core Ruby data containers, such as `Struct`, `Data` or even `Hash`, they will "just work". However, if a custom class is used, forging will probably fail, unless your class happens to take a hash of attributes in `#initialize`. It would be against the goal of **ObjectForge** to place requirements on your classes, and indeed there is a solution.
 
 Whenever you need to change how your objects are built, you specify a *mold*. Molds are just `call`able objects (including `Proc`s!) with specific arguments. They are set in forge definition:
+
 ```ruby
 forge = ObjectForge::Forge.define(Point) do |f|
   f.mold = ->(forge_target:, attributes:, **) do
     forge_target.new(attributes[:id], attributes[:x].round(3), attributes[:y].round(3))
   end
-  #... rest of the definition from the previous example
+  #... rest of the definition from the Basics example
 end
 ```
 
 Now the specified **mold** will be called to build your objects:
+
 ```ruby
 forge.forge
   # => #<struct Point id="a", x=0.331, y=-0.136>
@@ -245,25 +379,33 @@ forge.forge
 
 Of course, you can abuse this to your heart's content. Look at the documentation for `ObjectForge::Molds` for inspiration.
 
+> [!NOTE]
+>
+> If you don't specify a mold, **ObjectForge** will infer one for core data containers including **Hash**, **Array**, **Struct**, and **Data** subclasses.
+
 **ObjectForge** comes pre-equipped with a selection of molds for common cases:
-- `ObjectForge::Molds::SingleArgumentMold` (*the default*) calls `new(attributes)`, suitable for **ActiveModel**-style objects and **Dry::Struct**, as an example
-- `ObjectForge::Molds::KeywordsMold` calls `new(**attributes)`, suitable for **Data** and similar classes
-- `ObjectForge::Molds::HashMold` allows building **Hash** (including subclasses), providing a way to easily use build hashes
-- `ObjectForge::Molds::StructMold` handles all possible cases of `keyword_init` for **Struct**s
 
-> [!NOTE]
-> If you don't specify a mold, **ObjectForge** will infer one for core data containers, including **Hash**, **Struct**, and **Data** subclasses.
+- `ObjectForge::Molds::SingleArgumentMold` (*the default*) calls `new(attributes)`, suitable for **ActiveModel**-style objects and **Dry::Struct**, as an example.
+- `ObjectForge::Molds::KeywordsMold` calls `new(**attributes)`, suitable for **Data** and similar classes.
+- `ObjectForge::Molds::StructMold` handles all possible cases of `keyword_init` for **Struct**s.
+- `ObjectForge::Molds::HashMold` allows building **Hash** (including subclasses), including setting `default` and `default_proc` values.
+- `ObjectForge::Molds::ArrayMold` allows building **Array** (including subclasses), based on attribute ordering.
+
+You can also set a Class with a `#call` method as a mold. It will be instantiated on every call, providing a clean mold object.
 
 > [!TIP]
-> It is recommended to use molds instances directly. Using classes causes memory churn and lowered performance. Not only that, but having a stateful mold is a code smell and probably represents a significant design issue.
+>
+> It is recommended to use mold instances. Using classes causes memory churn and lowers performance. Not only that, but having a stateful mold is a code smell.
 
 ### After-build customization
 
 If there is a need to modify the object or perform additional actions after it is forged, there are two mechanisms you can employ:
+
 - after-forge hook
 - customization block
 
 After-forge hook is a `call`able object specified as part of forge definition. It runs every time forging happens:
+
 ```ruby
 forge = ObjectForge::Forge.define(Rectangle) do |f|
   # can also be specified as `after_build`
@@ -276,6 +418,7 @@ forge.forge
 ```
 
 Customization block is an optional block argument to `#forge` and is only executed in that specific invocation:
+
 ```ruby
 forge.forge { |rect| RectangleRepository.save(rect); puts "persisted!" }
   # Used 621 sq. units
@@ -283,38 +426,34 @@ forge.forge { |rect| RectangleRepository.save(rect); puts "persisted!" }
   # => [23x27]
 ```
 
-If both hook and block are used, the hook runs before the block. 
-
-### Performance tips
-
-**ObjectForge** is pretty fast for what it is. However, if you are worried, there are certain things that can be done to make it faster.
-- The easiest thing is to enable [**YJIT**](https://docs.ruby-lang.org/en/master/yjit/yjit_md.html). It will probably speed up your whole application, but be aware that it is not always suitable and may even degrade performance on some workloads. It *is* considered production-ready though.
-- Calling a **Forge** directly, instead of through **Forgeyard**, is faster due to not needing argument forwarding. This is consistent (but check on your system anyway!).
-- Using `self[:name]` instead of plain `name` inside attribute definitions does not engage dynamic method dispatch, which *should* be faster. However, micro-benchmarking does not show conclusive results.
+> [!NOTE]
+>
+> If both hook and block are used, the hook runs before the block. 
 
 ## Differences and limitations (compared to FactoryBot)
 
 If you are used to FactoryBot, be aware that there are quite a few differences in specifics.
 
 General:
+
 - The user (you) is responsible for loading forge definitions, there are no search paths. If **ObjectForge** is used in tests, it should be enough to add something like `Dir["spec/forges/**/*.rb].each { require _1 }` to your `spec_helper.rb` (or `rails_helper.rb`).
 - `Forgeyard.define` *is* the forge definition block, there is no separate `factory` block.
+- There is no concept of associations, or magic association methods. Forgeyards provide similar functionality, but it is more explicit.
 
 Forge definition:
+
 - Class specification for a forge is non-optional, there is no assumption about the class name.
 - If the DSL block declares a block argument, `self` context is not changed, and DSL methods can't be called with an implicit receiver.
 - There is no forge inheritance or nesting.
 
-Attributes:
-- Currently, there is no concept of transient attributes. Attribute selection needs to be handled by the mold.
-- *There are no associations*. If nested objects are required, they should be created and set in the block for the attribute.
-
 Traits:
+
 - Traits can't be defined inside of other traits.
 - Traits can't be called from other traits. This may change in the future.
 - There are no default traits.
 
 Sequences:
+
 - There is no explicit way to define shared sequences, but a freestanding `Sequence` can be created manually and passed into `sequence` calls.
 - Sequences work with values implementing `#succ`, not `#next`, expressly prohibiting `Enumerator`. This may be relaxed in the future.
 
@@ -330,11 +469,13 @@ kanban
     [Thread-safe behavior]
     [Tapping into built objects for post-processing]
     [Custom builders / molds]
-    [Built-in Hash, Struct, Data builders / molds]
+    [Built-in Hash, Array, Struct, Data builders / molds]
     [Ability to replace resolver]
     [After-build hook]
-  [⚗️ To do]
     [Transient attributes / attribute filtering]
+    [Reference to forgeyard in forge / crucible resolution]
+  [⚗️ To do]
+    [Equality comparisons]
   [❔ Maybe, maybe not]
     [Calling traits from traits]
     [Default traits]
@@ -369,4 +510,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/trinis
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE.txt](https://github.com/trinistr/object_forge/blob/main/LICENSE.txt).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE.txt](https://github.com/trinistr/object_forge/blob/main/LICENSE.txt).

data/lib/object_forge/crucible.rb

@@ -14,6 +14,8 @@ module ObjectForge
   #   and using {.call} is thread-safe.
   # @since 0.1.0
   class Crucible < UnBasicObject
+    EMPTY_YARD = {}.freeze # steep:ignore UnannotatedEmptyCollection
+
     class << self
       # Resolve all attributes by calling their +Proc+s,
       # using a new instance as evaluation context.
@@ -23,9 +25,10 @@ module ObjectForge
       # @thread_safety This method is thread-safe.
       #
       # @param attributes [Hash{Symbol => Proc, Any}] initial attributes
+      # @param yard [Hash{Symbol => Any}, nil] additional context for the crucible
       # @return [Hash{Symbol => Any}] resolved attributes
-      def call(attributes)
-        new(attributes).resolve!
+      def call(attributes, yard: EMPTY_YARD)
+        new(attributes, yard:).resolve!
       end
 
       alias resolve call
@@ -33,10 +36,15 @@ module ObjectForge
 
     %i[rand].each { |m| private define_method(m, ::Kernel.instance_method(m)) }
 
+    # @return [Hash{Symbol => Any}, Forgeyard] additional context for the crucible
+    attr_reader :yard
+
     # @param attributes [Hash{Symbol => Proc, Any}] initial attributes
-    def initialize(attributes)
+    # @param yard [Hash{Symbol => Any}, nil] additional context for the crucible
+    def initialize(attributes, yard: EMPTY_YARD)
       super()
       @attributes = attributes
+      @yard = yard || EMPTY_YARD
       @resolved_attributes = ::Set.new
       @resolving_attributes = []
     end
@@ -93,6 +101,8 @@ module ObjectForge
         raise_circular_dependency_error!(name) if @resolving_attributes.include?(name)
         resolve_attribute!(name) unless @resolved_attributes.include?(name)
         @attributes[name]
+      elsif @yard.key?(name)
+        @yard[name]
       else
         super
       end
@@ -101,7 +111,7 @@ module ObjectForge
     alias [] method_missing
 
     def respond_to_missing?(name, _include_all)
-      @attributes.key?(name) || super
+      @attributes.key?(name) || @yard.key?(name) || super
     end
 
     def raise_circular_dependency_error!(name)

data/lib/object_forge/forge.rb

@@ -29,10 +29,12 @@ module ObjectForge
     # @!attribute [r] options
     #   A forge's options.
     #   Known options:
-    #   - +:mold+ — a +call+able object that knows how to build the instance,
-    #     taking a class and a hash of attributes.
     #   - +:crucible+ — a +call+able object that knows how to resolve attributes,
-    #     taking a hash of initial attributes.
+    #     taking a hash of initial attributes and possibly a yard (see {Crucible}).
+    #   - +:attribute_list+ — an array of attribute names to filter and sort by
+    #     before passing attributes to the mold.
+    #   - +:mold+ — a +call+able object that knows how to build the instance,
+    #     taking a class and a hash of attributes (see {Molds}).
     #   - +:after_forge+/+:after_build+ — a +call+able object that is passed
     #     the forged instance and can do anything with it.
     #   @since 0.3.0
@@ -46,16 +48,20 @@ module ObjectForge
     #
     # @param forge_target [Class, Any] class or object to forge
     # @param name [Symbol, nil] forge name
+    # @param yard [Forgeyard, nil] forgeyard this forge belongs to
     # @yieldparam dsl [ForgeDSL]
     # @yieldreturn [void]
     # @return [Forge] forge
-    def self.define(forge_target, name: nil, &)
-      new(forge_target, ForgeDSL.new(&), name:)
+    def self.define(forge_target, name: nil, yard: nil, &)
+      new(forge_target, ForgeDSL.new(&), name:, yard:)
     end
 
     # @return [Symbol, nil] forge name, only used for identification purposes
     attr_reader :name
 
+    # @return [Forgeyard, nil] forgeyard this forge belongs to
+    attr_reader :yard
+
     # @return [Class, Any] class or object to forge
     # @since 0.4.0
     attr_reader :forge_target
@@ -68,11 +74,13 @@ module ObjectForge
     #   will be passed to mold as +forge_target+ argument
     # @param parameters [Parameters, ForgeDSL] forge parameters
     # @param name [Symbol, nil] forge name
+    # @param yard [Forgeyard, nil] forgeyard this forge belongs to
     #
     # @raise [ObjectInterfaceError] if forge options do not have expected interface;
     #   see {Parameters#options} for details
-    def initialize(forge_target, parameters, name: nil)
+    def initialize(forge_target, parameters, name: nil, yard: nil)
       @name = name
+      @yard = yard
       @forge_target = forge_target
       @parameters = parameters
 
@@ -80,12 +88,12 @@ module ObjectForge
       @crucible = determine_crucible(options)
       @mold = determine_mold(forge_target, options)
       @after_forge_hook = determine_after_forge_hook(options)
+      validate_other_options(options)
     end
 
     # Forge a new instance, applying attributes to forge target.
     #
     # Positional arguments are taken as trait names, keyword arguments as attribute overrides.
-    #
     # All traits and overrides are applied in argument order,
     # with overrides always applied after traits.
     #
@@ -102,8 +110,8 @@ module ObjectForge
     #
     # @raise [ArgumentError] if a trait name is unknown
     def forge(*traits, **overrides)
-      resolved_attributes = resolve_attributes(traits, overrides)
-      instance = @mold.call(forge_target: @forge_target, attributes: resolved_attributes)
+      attributes = build_attribute_hash(traits, overrides)
+      instance = @mold.call(forge_target: @forge_target, attributes: attributes)
       @after_forge_hook&.call(instance)
       yield instance if block_given?
       instance
@@ -115,9 +123,10 @@ module ObjectForge
     private
 
     # Get a crucible object based on parameters.
-    #
     # It's either the object provided in options, or {Crucible}.
     #
+    # This method also determines whether the crucible accepts a +yard+ parameter.
+    #
     # @param options [Hash]
     # @option options [#call, nil] :crucible
     # @return [#call]
@@ -126,15 +135,30 @@ module ObjectForge
     #
     # @since 0.4.0
     def determine_crucible(options)
-      crucible = options[:crucible] || Crucible
+      @crucible_takes_yard = true and return Crucible unless options[:crucible]
 
+      crucible = options[:crucible]
       unless crucible.respond_to?(:call)
         raise ObjectInterfaceError, "crucible must respond to #call"
       end
 
+      @crucible_takes_yard = crucible_takes_yard_parameter?(crucible)
       crucible
     end
 
+    # Check if a crucible accepts a +yard+ keyword parameter.
+    #
+    # @param crucible [#call]
+    # @return [Boolean]
+    #
+    # @since 0.5.0
+    def crucible_takes_yard_parameter?(crucible)
+      parameters = (Proc === crucible) ? crucible.parameters : crucible.method(:call).parameters
+      parameters.any? do |type, name|
+        type == :keyrest || ((type == :keyreq || type == :key) && name == :yard)
+      end
+    end
+
     # Get appropriate mold based on parameters.
     #
     # If +mold+ is already set, it will be used directly, or,
@@ -176,6 +200,35 @@ module ObjectForge
       hook
     end
 
+    # Validate options that will only be used at runtime.
+    #
+    # @param options [Hash]
+    # @option options [Array<Symbol>, nil] :attribute_list
+    #
+    # @raise [TypeError]
+    #
+    # @since 0.5.0
+    def validate_other_options(options)
+      return if options[:attribute_list].nil?
+      unless Array === options[:attribute_list] && options[:attribute_list].all? { Symbol === _1 }
+        raise TypeError, "attribute_list must be an Array of Symbol"
+      end
+    end
+
+    # Build final attribute hash using default attributes, specified traits and overrides,
+    # sorted and filtered by attribute list.
+    #
+    # @param traits [Array<Symbol>]
+    # @param overrides [Hash{Symbol => Proc, Any}]
+    # @return [Hash{Symbol => Any}]
+    #
+    # @raise [ArgumentError]
+    #
+    # @since 0.5.0
+    def build_attribute_hash(traits, overrides)
+      apply_attribute_list(resolve_attributes(traits, overrides))
+    end
+
     # Resolve attributes using default attributes, specified traits and overrides.
     #
     # @param traits [Array<Symbol>]
@@ -191,7 +244,24 @@ module ObjectForge
 
       trait_attributes = @parameters.traits.values_at(*traits) # : Array[Hash[Symbol, ObjectForge::attribute]]
       attributes = @parameters.attributes.merge(*trait_attributes, overrides)
-      @crucible.call(attributes)
+
+      if @crucible_takes_yard
+        @crucible.call(attributes, yard: @yard) # steep:ignore UnexpectedKeywordArgument
+      else
+        @crucible.call(attributes)
+      end
+    end
+
+    # Filter and sort attributes based on the attribute list.
+    #
+    # @param attributes [Hash{Symbol => Any}]
+    # @return [Hash{Symbol => Any}]
+    #
+    # @since 0.5.0
+    def apply_attribute_list(attributes)
+      return attributes unless (attribute_list = @parameters.options[:attribute_list])
+
+      attributes.slice(*attribute_list)
     end
   end
 end

data/lib/object_forge/forge_dsl.rb

@@ -12,12 +12,11 @@ module ObjectForge
   #   but it's not a private API.
   #
   # @thread_safety DSL is not thread-safe.
-  #   Take care not to introduce side effects,
-  #   especially in attribute definitions.
-  #   The instance itself is frozen after initialization,
+  #   Take care not to introduce side effects, especially in attribute definitions.
+  #   The instance itself and its attributes are frozen after initialization,
   #   so it should be safe to share.
   # @since 0.1.0
-  class ForgeDSL < UnBasicObject
+  class ForgeDSL < UnBasicObject # rubocop:disable Metrics/ClassLength
     # @return [Hash{Symbol => Proc}] attribute definitions
     attr_reader :attributes
 
@@ -61,9 +60,11 @@ module ObjectForge
       @sequences = {}
       @traits = {}
       @options = {}
+      @transient_attributes = []
 
       dsl.arity.zero? ? instance_exec(&dsl) : yield(self)
 
+      shape_attribute_list!
       freeze
     end
 
@@ -79,6 +80,7 @@ module ObjectForge
       @sequences.freeze
       @traits.freeze
       @options.freeze
+      @options[:attribute_list].freeze
       self
     end
 
@@ -134,13 +136,20 @@ module ObjectForge
     #   f.attribute(:[]=) { "#{self[:[]]} are brackets" }
     #   f.attribute(:!) { "#{self[:[]=]}!" }
     #
+    # @example using transient attributes
+    #   f.attribute(:range) { (base - delta)..(base + delta) }
+    #   f.attribute(:base, transient: true) { 1 }
+    #   f.transient(:delta) { 0.05 }
+    #
     # @param name [Symbol] attribute name
+    # @param transient [Boolean] whether the attribute is transient
+    #   (automatically excluded from attribute list)
     # @yieldreturn [Any] attribute value
     # @return [Symbol] attribute name
     #
     # @raise [TypeError] if +name+ is not a Symbol
     # @raise [DSLError] if no block is given
-    def attribute(name, &definition)
+    def attribute(name, transient: false, &definition)
       unless ::Symbol === name
         raise ::TypeError,
               "attribute name must be a Symbol, #{name.class} given (in #{name.inspect})"
@@ -154,12 +163,20 @@ module ObjectForge
       else
         @attributes[name] = definition
       end
+      @transient_attributes << name if transient
 
       name
     end
 
     alias [] attribute
 
+    # Define a transient attribute.
+    #
+    # @see #attribute
+    def transient(name, &)
+      attribute(name, transient: true, &)
+    end
+
     # Define an attribute, using a sequence.
     #
     # +name+ is used for both attribute and sequence, for the whole forge.
@@ -183,13 +200,15 @@ module ObjectForge
     #
     # @param name [Symbol] attribute name
     # @param initial [Sequence, #succ] existing sequence, or initial value for a new sequence
+    # @param transient [Boolean] whether the attribute is transient
+    #   (automatically excluded from attribute list)
     # @yieldparam value [#succ] current value of the sequence to calculate attribute value
     # @yieldreturn [Any] attribute value
     # @return [Symbol] attribute name
     #
     # @raise [TypeError] if +name+ is not a Symbol
     # @raise [ObjectInterfaceError] if +initial+ does not respond to #succ and is not a {Sequence}
-    def sequence(name, initial = 1, **nil, &)
+    def sequence(name, initial = 1, transient: false, &)
       unless ::Symbol === name
         raise ::TypeError,
               "sequence name must be a Symbol, #{name.class} given (in #{name.inspect})"
@@ -198,9 +217,11 @@ module ObjectForge
       seq = @sequences[name] ||= Sequence.new(initial)
 
       if block_given?
-        attribute(name) { instance_exec(seq.next, &) } # steep:ignore BlockTypeMismatch
+        attribute(name, transient: transient) do
+          instance_exec(seq.next, &) # steep:ignore BlockTypeMismatch
+        end
       else
-        attribute(name) { seq.next }
+        attribute(name, transient: transient) { seq.next }
       end
 
       name
@@ -278,7 +299,7 @@ module ObjectForge
     # - all names ending in +?+, +!+
     # - all names starting with a non-word ASCII character
     #   (operators, +`+, +[]+, +[]=+)
-    # - +rand+
+    # - +rand+ and +yard+
     #
     # @param name [Symbol] attribute or option name
     # @param value [Any] value for option
@@ -302,11 +323,25 @@ module ObjectForge
     def respond_to_missing?(name, _include_all)
       return super if frozen?
 
-      !name.end_with?("?", "!") && !name.match?(/\A(?=\p{ASCII})\P{Word}/) && name != :rand
+      !name.end_with?("?", "!") && !name.match?(/\A(?=\p{ASCII})\P{Word}/) &&
+        !name.match?(/\A(?:rand|yard)\z/)
     end
 
     def valid_option_method?(name)
       name.match?(/\A\p{Word}.*=\z/)
     end
+
+    def shape_attribute_list!
+      return if @transient_attributes.empty?
+
+      if @options.key?(:attribute_list)
+        return if (conflicting_attrs = @transient_attributes & @options[:attribute_list]).empty?
+
+        list = conflicting_attrs.map(&:inspect).join(", ")
+        raise DSLError, "attribute_list must not include transient attributes (#{list})"
+      end
+
+      @options[:attribute_list] = @attributes.merge(*@traits.values).keys - @transient_attributes
+    end
   end
 end

data/lib/object_forge/forgeyard.rb

@@ -27,7 +27,7 @@ module ObjectForge
     # @yieldreturn [void]
     # @return [Forge] forge
     def define(name, forge_target, &)
-      register(name, Forge.define(forge_target, name: name, &))
+      register(name, Forge.define(forge_target, name: name, yard: self, &))
     end
 
     # Add a forge under a specified name.
@@ -55,6 +55,14 @@ module ObjectForge
       @forges.fetch(name)
     end
 
+    # Check if a forge is registered under a given name.
+    #
+    # @param name [Symbol] name of the forge
+    # @return [Boolean] whether a forge is registered under the given name
+    def key?(name)
+      !!@forges.get(name)
+    end
+
     # Build an instance using a forge.
     #
     # @see Forge#forge

data/lib/object_forge/molds/array_mold.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ObjectForge
+  module Molds
+    # Mold for constructing Arrays.
+    #
+    # @thread_safety Thread-safe.
+    # @since 0.5.0
+    class ArrayMold
+      # Build a new array from attributes' values.
+      #
+      # If +forge_target+ is +Array+, result is built directly by calling +attributes.values+.
+      # If it is a different class, its +.new+ method is called with the values array.
+      #
+      # @see Array.new
+      #
+      # @param forge_target [Class] Array or a subclass of Array
+      # @param attributes [Hash{Symbol => Any}]
+      # @return [Array]
+      def call(forge_target:, attributes:, **_)
+        return attributes.values if Array == forge_target # rubocop:disable Style/YodaCondition
+
+        forge_target.new(attributes.values)
+      end
+    end
+  end
+end

data/lib/object_forge/molds/hash_mold.rb

@@ -6,7 +6,6 @@ module ObjectForge
     #
     # @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.

data/lib/object_forge/molds.rb

@@ -122,7 +122,8 @@ module ObjectForge
     # Currently provides specific recognition for:
     # - subclasses of +Struct+ ({StructMold}),
     # - subclasses of +Data+ ({KeywordsMold}),
-    # - +Hash+ and subclasses ({HashMold}).
+    # - +Hash+ and subclasses ({HashMold}),
+    # - +Array+ and subclasses ({ArrayMold}).
     # Other objects just get {SingleArgumentMold}.
     #
     # @param forge_target [Class, Any]
@@ -131,19 +132,22 @@ module ObjectForge
     # @thread_safety Thread-safe.
     # @since 0.3.0
     def self.mold_for(forge_target)
-      if ::Class === forge_target
+      return SingleArgumentMold.new unless ::Class === forge_target
+
+      mold_class =
         if forge_target < ::Struct
-          StructMold.new
+          StructMold
         elsif defined?(::Data) && forge_target < ::Data
-          KeywordsMold.new
+          KeywordsMold
         elsif forge_target <= ::Hash
-          HashMold.new
+          HashMold
+        elsif forge_target <= ::Array
+          ArrayMold
         else
-          SingleArgumentMold.new
+          SingleArgumentMold
         end
-      else
-        SingleArgumentMold.new
-      end
+
+      mold_class.new
     end
 
     # Wrap mold if needed.
@@ -160,7 +164,7 @@ module ObjectForge
     # @thread_safety Thread-safe.
     # @since 0.3.0
     def self.wrap_mold(mold)
-      if mold.nil? || mold.respond_to?(:call)
+      if nil == mold || mold.respond_to?(:call) # rubocop:disable Style/YodaCondition
         mold # : ObjectForge::mold?
       elsif ::Class === mold && mold.public_method_defined?(:call)
         WrappedMold.new(mold)

data/lib/object_forge/version.rb

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

data/sig/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: pp

data/sig/object_forge/molds.rbs

@@ -28,8 +28,8 @@ module ObjectForge
     class StructMold
       interface _StructSubclass[T]
         def new
-          : (*untyped) -> T
-          | (**untyped) -> T
+          : (*ObjectForge::attribute) -> T
+          | (**ObjectForge::attribute) -> T
           | (Hash[Symbol, ObjectForge::attribute]) -> T
         def members: -> Array[Symbol]
         def keyword_init?: -> bool?
@@ -60,10 +60,21 @@ module ObjectForge
       attr_reader default_proc: Proc?
 
       def initialize
-        : [T < Hash] (?ObjectForge::attribute default_value) ?{ (T hash, untyped key) -> ObjectForge::attribute} -> void
+        : (?ObjectForge::attribute? default_value) ?{ (Hash[untyped, untyped] hash, untyped key) -> ObjectForge::attribute} -> void
       
       def call
-        : [T < Hash] (forge_target: _HashSubclass[T], attributes: Hash[Symbol, ObjectForge::attribute], **untyped) -> T
+        : (forge_target: singleton(Hash), attributes: Hash[Symbol, ObjectForge::attribute], **untyped) -> Hash[Symbol, ObjectForge::attribute]
+        | [T < Hash[Symbol, ObjectForge::attribute]] (forge_target: _HashSubclass[T], attributes: Hash[Symbol, ObjectForge::attribute], **untyped) -> T
+    end
+
+    class ArrayMold
+      interface _ArraySubclass[T]
+        def new: (Array[ObjectForge::attribute]) -> T
+      end
+
+      def call
+        : (forge_target: singleton(Array), attributes: Hash[Symbol, ObjectForge::attribute], **untyped) -> Array[ObjectForge::attribute]
+        | [T < Array[ObjectForge::attribute]] (forge_target: _ArraySubclass[T], attributes: Hash[Symbol, ObjectForge::attribute], **untyped) -> T
     end
   end
 end

data/sig/object_forge.rbs

@@ -3,11 +3,13 @@ module ObjectForge
   type forge_result = untyped
   type attribute = untyped
 
-  type mold = ::Object & _Mold
+  type mold = _RespondTo & _Mold
+  type crucible = _RespondTo & (_Crucible | _CrucibleWithYard)
   type sequenceable = _RespondTo & _Sequenceable
 
   interface _RespondTo
     def respond_to?: (Symbol name, ?bool include_private) -> bool
+    def method: (Symbol name) -> ::Method
     def class: -> Class
   end
   interface _Sequenceable
@@ -26,10 +28,21 @@ module ObjectForge
     def call
       : (Hash[Symbol, ObjectForge::attribute]) -> Hash[Symbol, ObjectForge::attribute]
   end
+  interface _CrucibleWithYard
+    def call
+      : (Hash[Symbol, ObjectForge::attribute], ?yard: ObjectForge::_Yard?) -> Hash[Symbol, ObjectForge::attribute]
+  end
   interface _Hook
     def call
       : (ObjectForge::forge_result) -> void
   end
+  interface _Yard
+    def []
+      : (Symbol name) -> untyped
+    
+    def key?
+      : (Symbol name) -> bool
+  end
 
   class Error < StandardError
   end
@@ -87,6 +100,9 @@ class ObjectForge::Forgeyard
   
   def []
     : (Symbol name) -> ObjectForge::Forge
+  
+  def key?
+    : (Symbol name) -> bool
 
   def forge
     : (Symbol name, *Symbol traits, **ObjectForge::attribute overrides) ?{ (ObjectForge::forge_result) -> void } -> ObjectForge::forge_result
@@ -103,23 +119,25 @@ class ObjectForge::Forge
       : (attributes: Hash[Symbol, ObjectForge::attribute], traits: Hash[Symbol, Hash[Symbol, ObjectForge::attribute]], options: Hash[Symbol, untyped]) -> void
   end
 
+  attr_reader name: Symbol?
+
+  attr_reader yard: ObjectForge::_Yard?
+
   attr_reader forge_target: ObjectForge::forge_target
   alias target forge_target
 
-  attr_reader name: Symbol?
-
   attr_reader parameters: ObjectForge::_ForgeParameters
 
-  @crucible: ObjectForge::_Crucible
+  @crucible: ObjectForge::crucible
   @mold: ObjectForge::_Mold
   @after_forge_hook: ObjectForge::_Hook?
 
   def self.define
-    : (ObjectForge::forge_target, ?name: Symbol?) { (ObjectForge::ForgeDSL) -> void } -> ObjectForge::Forge
-    | (ObjectForge::forge_target, ?name: Symbol?) { [self: ObjectForge::ForgeDSL] -> void } -> ObjectForge::Forge
+    : (ObjectForge::forge_target, ?name: Symbol?, ?yard: ObjectForge::_Yard?) { (ObjectForge::ForgeDSL) -> void } -> ObjectForge::Forge
+    | (ObjectForge::forge_target, ?name: Symbol?, ?yard: ObjectForge::_Yard?) { [self: ObjectForge::ForgeDSL] -> void } -> ObjectForge::Forge
   
   def initialize
-    : (ObjectForge::forge_target, ObjectForge::_ForgeParameters parameters, ?name: Symbol?) -> void
+    : (ObjectForge::forge_target, ObjectForge::_ForgeParameters parameters, ?name: Symbol?, ?yard: ObjectForge::_Yard?) -> void
   
   def forge
     : (*Symbol traits, **ObjectForge::attribute overrides) ?{ (ObjectForge::forge_result) -> void } -> ObjectForge::forge_result
@@ -129,16 +147,28 @@ class ObjectForge::Forge
   private
   
   def determine_crucible
-    : (Hash[Symbol, untyped]) -> ObjectForge::_Crucible
+    : (Hash[Symbol, untyped]) -> ObjectForge::crucible
+
+  def crucible_takes_yard_parameter?
+    : (ObjectForge::crucible) -> bool
 
   def determine_mold
     : (ObjectForge::forge_target, Hash[Symbol, untyped]) -> ObjectForge::mold
 
   def determine_after_forge_hook
     : (Hash[Symbol, untyped] options) -> ObjectForge::_Hook?
+  
+  def validate_other_options
+    : (Hash[Symbol, untyped] options) -> void
+
+  def build_attribute_hash
+    : (Array[Symbol] traits, Hash[Symbol, ObjectForge::attribute] overrides) -> Hash[Symbol, ObjectForge::attribute]
 
   def resolve_attributes
     : (Array[Symbol] traits, Hash[Symbol, ObjectForge::attribute] overrides) -> Hash[Symbol, ObjectForge::attribute]
+
+  def apply_attribute_list
+    : (Hash[Symbol, ObjectForge::attribute] attributes) -> Hash[Symbol, ObjectForge::attribute]
 end
 
 class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
@@ -150,6 +180,7 @@ class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
   @sequences: Hash[Symbol, ObjectForge::Sequence]
   @traits: Hash[Symbol, Hash[Symbol, Proc]]
   @options: Hash[Symbol, untyped]
+  @transient_attributes: Array[Symbol]
 
   def initialize
     : () { (ObjectForge::ForgeDSL) -> void } -> void
@@ -161,12 +192,15 @@ class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
     : (Symbol name, untyped value) -> Symbol
 
   def attribute
-    : (Symbol name) { [self: ObjectForge::Crucible] -> ObjectForge::attribute } -> Symbol
+    : (Symbol name, ?transient: bool) { [self: ObjectForge::Crucible] -> ObjectForge::attribute } -> Symbol
   alias [] attribute
 
+  def transient
+    : (Symbol name) { [self: ObjectForge::Crucible] -> ObjectForge::attribute } -> Symbol
+
   def sequence
-    : (Symbol name, ?(ObjectForge::sequenceable | ObjectForge::Sequence) initial) { (ObjectForge::sequenceable) [self: ObjectForge::Crucible] -> untyped } -> Symbol
-    | (Symbol name, ?(ObjectForge::sequenceable | ObjectForge::Sequence) initial) -> Symbol
+    : (Symbol name, ?(ObjectForge::sequenceable | ObjectForge::Sequence) initial, ?transient: bool) { (ObjectForge::sequenceable) [self: ObjectForge::Crucible] -> ObjectForge::attribute } -> Symbol
+    | (Symbol name, ?(ObjectForge::sequenceable | ObjectForge::Sequence) initial, ?transient: bool) -> Symbol
 
   def trait
     : (Symbol name) { (self) -> void } -> Symbol
@@ -177,31 +211,38 @@ class ObjectForge::ForgeDSL < ObjectForge::UnBasicObject
 
   def method_missing
     # Attribute shortcut:
-    : (Symbol name) { [self: ObjectForge::Crucible] -> untyped } -> Symbol
+    : (Symbol name) { [self: ObjectForge::Crucible] -> ObjectForge::attribute } -> Symbol
     # Option shortcut:
     | (Symbol name, untyped value) -> Symbol
     # After freezing:
-    | (Symbol name) { -> untyped } -> void
+    | (Symbol name) ?{ -> untyped } -> void
 
   def respond_to_missing?
     : (Symbol name, bool include_all) -> bool
   
   def valid_option_method?
     : (Symbol name) -> bool
+  
+  def shape_attribute_list!
+    : -> void
 end
 
 class ObjectForge::Crucible < ObjectForge::UnBasicObject
+  EMPTY_YARD: Hash[Symbol, untyped]
+
   def self.call
-    : (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+    : (Hash[Symbol, ObjectForge::attribute], ?yard: ObjectForge::_Yard?) -> Hash[Symbol, ObjectForge::attribute]
   def self.resolve
-    : (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+    : (Hash[Symbol, ObjectForge::attribute], ?yard: ObjectForge::_Yard?) -> Hash[Symbol, ObjectForge::attribute]
 
   @attributes: Hash[Symbol, ObjectForge::attribute]
   @resolved_attributes: Set[Symbol]
   @resolving_attributes: Array[Symbol]
 
+  attr_reader yard: ObjectForge::_Yard
+
   def initialize
-    : (Hash[Symbol, ObjectForge::attribute] attributes) -> void
+    : (Hash[Symbol, ObjectForge::attribute] attributes, ?yard: ObjectForge::_Yard?) -> void
 
   def resolve!
     : -> Hash[Symbol, ObjectForge::attribute]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: object_forge
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Alexander Bulancov
@@ -29,7 +29,7 @@ description: |
 
   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.
+  works well with plain Ruby objects, hashes, arrays, 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
@@ -46,6 +46,7 @@ files:
 - lib/object_forge/forge_dsl.rb
 - lib/object_forge/forgeyard.rb
 - lib/object_forge/molds.rb
+- lib/object_forge/molds/array_mold.rb
 - lib/object_forge/molds/hash_mold.rb
 - lib/object_forge/molds/keywords_mold.rb
 - lib/object_forge/molds/single_argument_mold.rb
@@ -54,6 +55,7 @@ files:
 - lib/object_forge/sequence.rb
 - lib/object_forge/un_basic_object.rb
 - lib/object_forge/version.rb
+- sig/manifest.yaml
 - sig/object_forge.rbs
 - sig/object_forge/molds.rbs
 homepage: https://github.com/trinistr/object_forge
@@ -62,9 +64,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.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
+  documentation_uri: https://rubydoc.info/gems/object_forge/0.5.0
+  source_code_uri: https://github.com/trinistr/object_forge/tree/v0.5.0
+  changelog_uri: https://github.com/trinistr/object_forge/blob/v0.5.0/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options:
 - "--tag"
@@ -86,6 +88,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: A small, flexible factory library for plain Ruby objects, hashes, structs
-  and custom build flows.
+summary: A small, flexible factory library for plain Ruby objects, hashes, arrays,
+  structs and custom build flows.
 test_files: []