Add HashCoercer built-in coercer

Author: tomdalling

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## Unreleased
 ### Added
 - `RangeOf` built-in validator, for validating `Range` objects
+- `HashCoercer` built-in coercer for homogeneous `Hash` objects
 ### Changed
 - The exceptions `ValueSemantics::MissingAttributes` and
   `ValueSemantics::InvalidValue` are now raised from inside

README.eceval.md

@@ -354,6 +354,34 @@ For example, the default value could be a string,
 which would then be coerced into an `Pathname` object.
 
 
+## Built-in Coercers
+
+ValueSemantics provides a few built-in coercer objects via the DSL.
+
+```ruby
+class Config
+  include ValueSemantics.for_attributes {
+    # ArrayCoercer: takes an element coercer
+    paths coerce: ArrayCoercer(Pathname.method(:new))
+
+    # HashCoercer: takes a key and value coercer
+    env coerce: HashCoercer(
+      keys: :to_sym.to_proc,
+      values: :to_i.to_proc,
+    )
+  }
+end
+
+config = Config.new(
+  paths: ['/a', '/b'],
+  env: { 'AAAA' => '1', 'BBBB' => '2' },
+)
+
+config.paths #=>
+config.env #=>
+```
+
+
 ## Nesting
 
 It is fairly common to nest value objects inside each other. This

README.md

@@ -358,6 +358,34 @@ For example, the default value could be a string,
 which would then be coerced into an `Pathname` object.
 
 
+## Built-in Coercers
+
+ValueSemantics provides a few built-in coercer objects via the DSL.
+
+```ruby
+class Config
+  include ValueSemantics.for_attributes {
+    # ArrayCoercer: takes an element coercer
+    paths coerce: ArrayCoercer(Pathname.method(:new))
+
+    # HashCoercer: takes a key and value coercer
+    env coerce: HashCoercer(
+      keys: :to_sym.to_proc,
+      values: :to_i.to_proc,
+    )
+  }
+end
+
+config = Config.new(
+  paths: ['/a', '/b'],
+  env: { 'AAAA' => '1', 'BBBB' => '2' },
+)
+
+config.paths #=> [#<Pathname:/a>, #<Pathname:/b>]
+config.env #=> {:AAAA=>1, :BBBB=>2}
+```
+
+
 ## Nesting
 
 It is fairly common to nest value objects inside each other. This

lib/value_semantics.rb

@@ -8,6 +8,7 @@
   dsl
   either
   hash_of
+  hash_coercer
   instance_methods
   range_of
   recipe

lib/value_semantics/dsl.rb

@@ -60,6 +60,11 @@ def ArrayCoercer(element_coercer)
       ArrayCoercer.new(element_coercer)
     end
 
+    IDENTITY_COERCER = :itself.to_proc
+    def HashCoercer(keys: IDENTITY_COERCER, values: IDENTITY_COERCER)
+      HashCoercer.new(key_coercer: keys, value_coercer: values)
+    end
+
     #
     # Defines one attribute.
     #

lib/value_semantics/hash_coercer.rb

@@ -0,0 +1,30 @@
+module ValueSemantics
+  class HashCoercer
+    attr_reader :key_coercer, :value_coercer
+
+    def initialize(key_coercer:, value_coercer:)
+      @key_coercer, @value_coercer = key_coercer, value_coercer
+      freeze
+    end
+
+    def call(obj)
+      hash = coerce_to_hash(obj)
+      return obj unless hash
+
+      {}.tap do |result|
+        hash.each do |key, value|
+          r_key = key_coercer.(key)
+          r_value = value_coercer.(value)
+          result[r_key] = r_value
+        end
+      end
+    end
+
+    private
+
+      def coerce_to_hash(obj)
+        return nil unless obj.respond_to?(:to_h)
+        obj.to_h
+      end
+  end
+end

spec/dsl_spec.rb

@@ -43,15 +43,17 @@
     expect(validator).to be === %w(1 2 3)
   end
 
-  it 'has a built-in HashOf matcher' do
-    validator = subject.HashOf(Symbol => Integer)
-    expect(validator).to be === {a: 2, b:2}
-  end
-
-  it 'raises ArgumentError if the HashOf argument is wrong' do
-    expect { subject.HashOf({a: 1, b: 2}) }.to raise_error(ArgumentError,
-      "HashOf() takes a hash with one key and one value",
-    )
+  context 'built-in HashOf matcher' do
+    it 'matches hashes' do
+      validator = subject.HashOf(Symbol => Integer)
+      expect(validator).to be === {a: 2, b:2}
+    end
+
+    it 'raises ArgumentError if the argument is wrong' do
+      expect { subject.HashOf({a: 1, b: 2}) }.to raise_error(ArgumentError,
+        "HashOf() takes a hash with one key and one value",
+      )
+    end
   end
 
   it 'has a built-in RangeOf matcher' do
@@ -69,6 +71,21 @@
     expect(subject.__attributes.first.name).to eq(:else)
   end
 
+  context 'built-in HashCoercer coercer' do
+    it 'allows anything for keys/values by default' do
+      coercer = subject.HashCoercer()
+      expect(coercer.({whatever: 42})).to eq({whatever: 42})
+    end
+
+    it 'can take coercers for keys and values' do
+      coercer = subject.HashCoercer(
+        keys: ->(x) { x.to_sym },
+        values: ->(x) { x.to_i },
+      )
+      expect(coercer.({'x' => '1'})).to eq({x: 1})
+    end
+  end
+
   it "produces a frozen recipe with DSL.run" do
     recipe = described_class.run { whatever }
 

spec/hash_coercer_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe ValueSemantics::HashCoercer do
+  subject do
+    described_class.new(
+      key_coercer: ->(x) { x.to_sym },
+      value_coercer: ->(x) { x.to_i },
+    )
+  end
+
+  it { is_expected.to be_frozen }
+
+  it 'coerces hash-like objects to hashes' do
+    hashlike = double(to_h: {a: 1})
+    expect(subject.(hashlike)).to eq({a: 1})
+  end
+
+  it 'returns non-hash-like objects, unchanged' do
+    expect(subject.(5)).to eq(5)
+  end
+
+  it 'allows empty hashes' do
+    expect(subject.({})).to eq({})
+  end
+
+  it 'coerces hash keys' do
+    expect(subject.({'a' => 1})).to eq({a: 1})
+  end
+
+  it 'coerces hash values' do
+    expect(subject.({a: '1'})).to eq({a: 1})
+  end
+end