Allow builder DSL to accept implicit arrays and hashes

lib/keyword_builder.rb

@@ -6,16 +6,20 @@ class KeywordBuilder
   class BuilderError < ArgumentError; end
 
   class << self
-    def create(clazz, constructor: :new)
+    def create(clazz, constructor: :new, &finalizer)
       keywords, wildcard = parse_constructor_parameters(clazz, constructor)
 
       Class.new(self) do
         define_singleton_method(:clazz) { clazz }
         define_singleton_method(:constructor) { constructor }
         define_singleton_method(:keywords) { keywords }
         define_singleton_method(:wildcard?) { wildcard }
+
+        finalizer ||= proc { |_attrs| }
+        define_singleton_method(:finalizer, &finalizer)
+
         keywords.each do |keyword|
-          define_method(keyword) { |*args, &block| _set_attribute(keyword, *args, &block) }
+          define_method(keyword) { |*args, **kwargs, &block| _set_attribute(keyword, *args, **kwargs, &block) }
         end
       end
     end
@@ -27,6 +31,7 @@ def valid_keyword?(param)
     def build!(**initial_attrs, &block)
       builder = self.new(initial_attrs)
       builder.instance_eval(&block) if block_given?
+      finalizer(builder.attrs)
       clazz.public_send(constructor, **builder.attrs)
     end
 
@@ -66,28 +71,35 @@ def initialize(initial_attrs)
     @attrs = initial_attrs.dup
   end
 
-  def _set_attribute(attr, *args, &block)
+  def _set_attribute(attr, *args, **kwargs, &block)
     if attrs.has_key?(attr)
       raise BuilderError.new("Invalid builder state: #{attr} already provided")
     end
 
-    value =
-      if block_given?
-        raise ArgumentError.new('Cannot provide both immediate and block value') unless args.blank?
+    if kwargs.empty?
+      value = args.dup
+
+      value << block if block_given?
+
+      if value.empty?
+        raise ArgumentError.new('Wrong number of arguments: expected at least one argument or block')
+      end
 
-        block
-      elsif args.size == 1
-        args[0]
-      else
-        raise ArgumentError.new('Wrong number of arguments: expected 1 or block')
+      value = value[0] if value.size == 1
+    else
+      unless args.empty? && block.nil?
+        raise ArgumentError.new('Invalid arguments: cannot provide both keyword and positional arguments')
       end
 
+      value = kwargs.dup
+    end
+
     attrs[attr] = value
   end
 
-  def method_missing(attr, *args, &block)
+  def method_missing(attr, *args, **kwargs, &block)
     if self.class.wildcard?
-      _set_attribute(attr, *args, &block)
+      _set_attribute(attr, *args, **kwargs, &block)
     else
       super
     end

lib/keyword_builder/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class KeywordBuilder
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

spec/unit/keyword_builder_spec.rb

@@ -34,6 +34,32 @@ def initialize(a:, b:, c:)
       expect(result).to have_attributes(a: 1, b: 2, c: 3)
     end
 
+    it 'constructs an array when builder is given more than one argument' do
+      result = builder.build!(a: 1, b: 2) do
+        c(1, 2, 3)
+      end
+
+      expect(result).to have_attributes(a: 1, b: 2, c: [1, 2, 3])
+    end
+
+    it 'constructs an array when builder is given arguments and a block' do
+      p = proc { 1 }
+
+      result = builder.build!(a: 1, b: 2) do
+        c(3, &p)
+      end
+
+      expect(result).to have_attributes(a: 1, b: 2, c: [3, p])
+    end
+
+    it 'constructs an hash when builder is given keyword arguments' do
+      result = builder.build!(a: 1, b: 2) do
+        c(x: 3, y: 4)
+      end
+
+      expect(result).to have_attributes(a: 1, b: 2, c: { x: 3, y: 4 })
+    end
+
     it 'rejects arguments colliding with builder' do
       expect {
         builder.build!(a: 1, b: 2, c: 3) { a 1 }
@@ -55,10 +81,16 @@ def initialize(a:, b:, c:)
       }.to raise_error(ArgumentError, /Wrong number of arguments/)
     end
 
-    it 'requires only one argument' do
+    it 'rejects mixed keyword and positional arguments' do
       expect {
-        builder.build!(a: 1, b: 2) { c(1, 2, 3) }
-      }.to raise_error(ArgumentError, /Wrong number of arguments/)
+        builder.build!(a: 1, b: 2) { c(3, x: 4) }
+      }.to raise_error(ArgumentError, /Invalid arguments/)
+    end
+
+    it 'rejects mixed keyword and block arguments' do
+      expect {
+        builder.build!(a: 1, b: 2) { c(x: 3) { 4 } }
+      }.to raise_error(ArgumentError, /Invalid arguments/)
     end
 
     it 'rejects unknown arguments' do
@@ -71,6 +103,19 @@ def initialize(a:, b:, c:)
       expect(builder).not_to be_wildcard
     end
 
+    context 'with finalizer' do
+      let(:builder) do
+        KeywordBuilder.create(Record) do |attrs|
+          attrs[:a] += 1
+        end
+      end
+
+      it 'invokes the finalizer on the builder' do
+        result = builder.build!(a: 1, b: 2, c: 3)
+        expect(result).to have_attributes(a: 2, b: 2, c: 3)
+      end
+    end
+
     context 'with wildcard arguments' do
       WildcardRecord = Struct.new(:a, :b) do
         def initialize(**rest)