Change #[] forging method to #call

`[]` clashes with accessing forges by name, which I want to include. `call` can be used as `.()` which isn't much longer and also plays nicer with parameters.

Author: trinistr

README.md

@@ -103,7 +103,7 @@ end
 
 A forge builds objects, using attributes hash:
 ```ruby
-ObjectForge[:point]
+ObjectForge.call(:point)
   # => #<Point:0x00007f6109dcad40 @id="a", @x=0.17176955469852973, @y=0.3423901951181103>
 # Positional arguments define used traits:
 ObjectForge.build(:point, :z)
@@ -112,17 +112,17 @@ ObjectForge.build(:point, :z)
 ObjectForge.forge(:point, x: 10)
   # => #<Point:0x00007f6109aabf88 @id="c", @x=10, @y=-0.3458802496120402>
 # Traits and overrides are combined in the given order:
-ObjectForge[:point, :z, :invalid, id: "NaN"]
+ObjectForge.call(:point, :z, :invalid, id: "NaN")
   # => #<Point:0x00007f6109b82e48 @id="NaN", @x=0.0, @y=NaN>
 # A Proc override behaves the same as an attribute definition:
-ObjectForge[:point, :z, x: -> { rand(100..200) + delta }]
+ObjectForge.call(:point, :z, x: -> { rand(100..200) + delta })
   # => #<Point:0x00007f6109932418 @id="Z_d", @x=135.0, @y=0.0>
 # A block can be passed to do something with the created object:
-ObjectForge[:point, :z] { puts "#{_1.id}: #{_1.x},#{_1.y}" }
+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 `#[]`, `#forge`, or `#build` methods, they are aliases.
+> Forging can be done through any of `#call`, `#forge`, or `#build` methods, they are aliases.
 
 ### Separate forgeyards and forges
 
@@ -140,13 +140,13 @@ end
 
 Now, this forgeyard can be used just like the default one:
 ```ruby
-forgeyard[:point, :z, id: "0"]
+forgeyard.forge(:point, :z, id: "0")
   # => #<Point:0x00007f6109b719e0 @id="0", @x=0, @y=0>
 ```
 
 Note how the forge isn't registered in the default forgeyard:
 ```ruby
-ObjectForge[:point]
+ObjectForge.forge(:point)
   # ArgumentError: unknown forge: point
 ```
 
@@ -159,7 +159,7 @@ forge = ObjectForge::Forge.define(Point) do |f|
   f.radius { 0.5 }
   f.trait :z do f.radius { 0 } end
 end
-forge[:z, id: "0"]
+forge.(:z, id: "0")
   # => #<Point:0x00007f6109b719e0 @id="0", @x=0, @y=0>
 ```
 
@@ -169,7 +169,7 @@ forge.build
   # => #<Point:0x00007f610deae578 @id="a", @x=0.3317733939650964, @y=-0.1363936629550252>
 forge.forge(:z)
   # => #<Point:0x00007f61099f6520 @id="b", @x=0, @y=0>
-forge[radius: 500]
+forge.(radius: 500)
   # => #<Point:0x00007f6109960048 @id="c", @x=-141, @y=109>
 ```
 
@@ -237,7 +237,7 @@ General:
 
 Forge definition:
 - Class specification for a forge is non-optional, there is no assumption about the class name.
-- If DSL block declares a block argument, `self` context is not changed, so DSL methods can't be called with an implicit receiver.
+- If the DSL block declares a block argument, `self` context is not changed, and DSL methods can't be called with an implicit receiver.
 
 Attributes:
 - For now, transient attributes have no difference to regular ones, they just aren't set in the final object.
@@ -249,7 +249,7 @@ Traits:
 - There are no default traits.
 
 Sequences:
-- There is no way to define shared sequences, unless you pass the same object yourself to multiple `sequence` calls.
+- There is no explicit way to define shared sequences, unless you pass the same object yourself to multiple `sequence` calls.
 - Sequences work with values implementing `#succ`, not `#next`, expressly prohibiting `Enumerator`. This may be relaxed in the future.
 
 ## Current and planned features (roadmap)

lib/object_forge.rb

@@ -38,7 +38,7 @@
 #   # => #<struct Frobinator frob="Frobinator", inator=#<Proc:...>>
 #   ObjectForge.build(:frobber, frob: -> { "Frob" + inator }, inator: "orn")
 #   # => #<struct Frobinator frob="Froborn", inator="orn">
-#   ObjectForge[:frobber, :static, inator: "Value"]
+#   ObjectForge.call(:frobber, :static, inator: "Value")
 #   # => #<struct Frobinator frob="Static", inator="Value">
 module ObjectForge
   # Base error class for ObjectForge.
@@ -104,9 +104,7 @@ def self.forge(...)
   end
 
   class << self
-    # @since 0.1.0
     alias build forge
-    # @since 0.1.0
-    alias [] forge
+    alias call forge
   end
 end

lib/object_forge/forge.rb

@@ -55,7 +55,8 @@ def self.define(forged, name: nil, &)
 
     # @param forged [Class, Any] class or object to forge
     # @param parameters [Parameters, ForgeDSL] forge parameters
-    # @param name [Symbol, nil] forge name
+    # @param name [Symbol, nil] forge name;
+    #   only used for identification purposes
     def initialize(forged, parameters, name: nil)
       @name = name
       @forged = forged
@@ -92,7 +93,7 @@ def forge(*traits, **overrides)
     end
 
     alias build forge
-    alias [] forge
+    alias call forge
 
     private
 

lib/object_forge/forgeyard.rb

@@ -58,10 +58,10 @@ def register(name, forge)
     #
     # @raise [KeyError] if forge with the specified name is not registered
     def forge(name, ...)
-      @forges.fetch(name).[](...)
+      @forges.fetch(name).call(...)
     end
 
     alias build forge
-    alias [] forge
+    alias call forge
   end
 end

sig/object_forge.rbs

@@ -35,6 +35,10 @@ module ObjectForge
 
   def self.forge
     : (Symbol name, *Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
+  def self.build
+    : (Symbol name, *Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
+  def self.call
+    : (Symbol name, *Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
 end
 
 class ObjectForge::Sequence
@@ -67,7 +71,7 @@ class ObjectForge::Forgeyard
   def forge
     : (Symbol name, *Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
   alias build forge
-  alias [] forge
+  alias call forge
 end
 
 class ObjectForge::Forge
@@ -93,7 +97,7 @@ class ObjectForge::Forge
   def forge
     : (*Symbol traits, **untyped overrides) ?{ (untyped) -> void } -> ObjectForge::_Forgable
   alias build forge
-  alias [] forge
+  alias call forge
 
   private
 

spec/object_forge/forge_spec.rb

@@ -85,6 +85,6 @@ def initialize(attributes)
     end
 
     include_examples "has an alias", :build, :forge
-    include_examples "has an alias", :[], :forge
+    include_examples "has an alias", :call, :forge
   end
 end

spec/object_forge/forgeyard_spec.rb

@@ -4,11 +4,11 @@ module ObjectForge
   RSpec.describe Forgeyard do
     subject(:forgeyard) { described_class.new }
 
-    let(:forge) { instance_double(Forge, "Forge", "[]": instance) }
+    let(:forge) { instance_double(Forge, "Forge", call: instance) }
     let(:instance) { Object.new }
 
     describe "#define" do
-      let(:definition) { forgeyard.define(:foo, Object) { |f| f.attribute(:[]) { nil } } }
+      let(:definition) { forgeyard.define(:foo, Object) { |f| f.attribute(:call) { nil } } }
 
       before { allow(Forge).to receive(:define).and_return(forge) }
 
@@ -69,32 +69,32 @@ module ObjectForge
       context "with a single argument" do
         it "builds an instance through named forge with default parameters" do
           expect(forgeyard.forge(:test)).to be instance
-          expect(forge).to have_received(:[]).with(no_args)
+          expect(forge).to have_received(:call).with(no_args)
         end
       end
 
       context "with multiple arguments" do
         it "builds an instance through named forge with specified parameters" do
           expect(forgeyard.forge(:test, :trait, attribute: 2)).to be instance
-          expect(forge).to have_received(:[]).with(:trait, attribute: 2)
+          expect(forge).to have_received(:call).with(:trait, attribute: 2)
         end
       end
 
       context "with a block" do
         let(:forge) { Forge.new(forged_class, Forge::Parameters.new(attributes: { foo: 1, bar: 2 }, traits: {})) }
         let(:forged_class) { Struct.new(:foo, :bar, keyword_init: true) }
 
-        before { allow(forge).to receive(:[]).and_call_original }
+        before { allow(forge).to receive(:call).and_call_original }
 
         it "allows tapping into the object" do
-          expect(forgeyard[:test] { _1.foo = 33 }).to eq forged_class.new(foo: 33, bar: 2)
-          expect(forge).to have_received(:[]).with(no_args)
+          expect(forgeyard.(:test) { _1.foo = 33 }).to eq forged_class.new(foo: 33, bar: 2)
+          expect(forge).to have_received(:call).with(no_args)
         end
 
         it "runs the block after forging the object with resolved attributes" do
-          expect(forgeyard[:test, foo: :foo, bar: -> { foo }] { _1.foo = 33 })
+          expect(forgeyard.(:test, foo: :foo, bar: -> { foo }) { _1.foo = 33 })
             .to eq forged_class.new(foo: 33, bar: :foo)
-          expect(forge).to have_received(:[]).with(foo: :foo, bar: Proc)
+          expect(forge).to have_received(:call).with(foo: :foo, bar: Proc)
         end
       end
 
@@ -106,6 +106,6 @@ module ObjectForge
     end
 
     include_examples "has an alias", :build, :forge
-    include_examples "has an alias", :[], :forge
+    include_examples "has an alias", :call, :forge
   end
 end

spec/object_forge_spec.rb

@@ -48,6 +48,6 @@
 
   describe described_class.singleton_class do
     include_examples "has an alias", :build, :forge
-    include_examples "has an alias", :[], :forge
+    include_examples "has an alias", :call, :forge
   end
 end