cmdx 1.20.0 → 2.0.0

data/lib/cmdx/coercions/date_time.rb

@@ -1,45 +1,41 @@
 # frozen_string_literal: true
 
 module CMDx
-  module Coercions
-    # Converts various input types to DateTime format
-    #
-    # Handles conversion from date strings, Date objects, Time objects, and other
-    # values that can be converted to DateTime using Ruby's DateTime.parse method
-    # or custom strptime formats.
+  class Coercions
+    # Coerces to `DateTime`. Pass `strptime:` to parse via a specific format;
+    # otherwise `DateTime.parse` is used for strings, and `#to_datetime` for
+    # any other responding object.
     module DateTime
 
       extend self
 
-      # Converts a value to a DateTime
-      #
-      # @param value [Object] The value to convert to DateTime
-      # @param options [Hash] Optional configuration parameters
-      # @option options [String] :strptime Custom date format string for parsing
-      #
-      # @return [DateTime] The converted DateTime value
-      #
-      # @raise [CoercionError] If the value cannot be converted to DateTime
-      #
-      # @example Convert date strings to DateTime
-      #   DateTime.call("2023-12-25")               # => #<DateTime: 2023-12-25T00:00:00+00:00>
-      #   DateTime.call("Dec 25, 2023")             # => #<DateTime: 2023-12-25T00:00:00+00:00>
-      # @example Convert with custom strptime format
-      #   DateTime.call("25/12/2023", strptime: "%d/%m/%Y")
-      #   # => #<DateTime: 2023-12-25T00:00:00+00:00>
-      # @example Convert existing date objects
-      #   DateTime.call(Date.new(2023, 12, 25))     # => #<DateTime: 2023-12-25T00:00:00+00:00>
-      #   DateTime.call(Time.new(2023, 12, 25))     # => #<DateTime: 2023-12-25T00:00:00+00:00>
-      #
-      # @rbs (untyped value, ?Hash[Symbol, untyped] options) -> DateTime
+      # @param value [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :strptime format string for `DateTime.strptime`
+      # @return [DateTime, Coercions::Failure]
       def call(value, options = EMPTY_HASH)
-        return value.to_datetime if value.respond_to?(:to_datetime)
-        return ::DateTime.strptime(value, options[:strptime]) if options[:strptime]
+        if value.is_a?(::DateTime)
+          value
+        elsif value.is_a?(::String)
+          if (strptime = options[:strptime])
+            ::DateTime.strptime(value, strptime)
+          else
+            ::DateTime.parse(value)
+          end
+        elsif value.respond_to?(:to_datetime)
+          value.to_datetime
+        else
+          coercion_failure
+        end
+      rescue ArgumentError, TypeError, ::Date::Error
+        coercion_failure
+      end
+
+      private
 
-        ::DateTime.parse(value)
-      rescue TypeError, ::Date::Error
-        type = Locale.t("cmdx.types.date_time")
-        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
+      def coercion_failure
+        type = I18nProxy.t("cmdx.types.date_time")
+        Failure.new(I18nProxy.t("cmdx.coercions.into_a", type:))
       end
 
     end

data/lib/cmdx/coercions/float.rb

@@ -1,42 +1,21 @@
 # frozen_string_literal: true
 
 module CMDx
-  module Coercions
-    # Converts various input types to Float format
-    #
-    # Handles conversion from numeric strings, integers, and other numeric types
-    # that can be converted to floats using Ruby's Float() method.
+  class Coercions
+    # Coerces to Float via `Kernel#Float` (strict parsing; no silent zero).
     module Float
 
       extend self
 
-      # Converts a value to a Float
-      #
-      # @param value [Object] The value to convert to a float
-      # @param options [Hash] Optional configuration parameters (currently unused)
-      # @option options [Object] :unused Currently no options are used
-      #
-      # @return [Float] The converted float value
-      #
-      # @raise [CoercionError] If the value cannot be converted to a float
-      #
-      # @example Convert numeric strings to float
-      #   Float.call("123")        # => 123.0
-      #   Float.call("123.456")    # => 123.456
-      #   Float.call("-42.5")      # => -42.5
-      #   Float.call("1.23e4")     # => 12300.0
-      # @example Convert numeric types to float
-      #   Float.call(42)           # => 42.0
-      #   Float.call(BigDecimal("123.456")) # => 123.456
-      #   Float.call(Rational(3, 4))       # => 0.75
-      #   Float.call(Complex(5.0, 0))      # => 5.0
-      #
-      # @rbs (untyped value, ?Hash[Symbol, untyped] options) -> Float
+      # @param value [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [Object] reserved for future per-coercion configuration (currently ignored)
+      # @return [Float, Coercions::Failure]
       def call(value, options = EMPTY_HASH)
         Float(value)
       rescue ArgumentError, RangeError, TypeError
-        type = Locale.t("cmdx.types.float")
-        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
+        type = I18nProxy.t("cmdx.types.float")
+        Failure.new(I18nProxy.t("cmdx.coercions.into_a", type:))
       end
 
     end

data/lib/cmdx/coercions/hash.rb

@@ -1,67 +1,41 @@
 # frozen_string_literal: true
 
 module CMDx
-  module Coercions
-    # Coerces various input types into Hash objects
-    #
-    # Supports conversion from:
-    # - Nil values (converted to empty Hash)
-    # - Hash objects (returned as-is)
-    # - Array objects (converted using Hash[*array])
-    # - JSON strings starting with "{" (parsed into Hash)
-    # - JSON strings that are "null" (parsed into empty Hash)
-    # - Other types raise CoercionError
+  class Coercions
+    # Coerces to Hash. `nil` becomes `{}`; strings are JSON-decoded (and
+    # must decode to a Hash); `#to_hash`/`#to_h` are used as fallbacks.
     module Hash
 
       extend self
 
-      # Coerces a value into a Hash
-      #
-      # @param value [Object] The value to coerce
-      # @param options [Hash] Additional options (currently unused)
-      # @option options [Symbol] :strict Whether to enforce strict conversion
-      #
-      # @return [Hash] The coerced hash value
-      #
-      # @raise [CoercionError] When the value cannot be coerced to a Hash
-      #
-      # @example Coerce from existing Hash
-      #   Hash.call({a: 1, b: 2}) # => {a: 1, b: 2}
-      # @example Coerce from Array
-      #   Hash.call([:a, 1, :b, 2]) # => {a: 1, b: 2}
-      # @example Coerce from JSON string
-      #   Hash.call('{"key": "value"}') # => {"key" => "value"}
-      #
-      # @rbs (untyped value, ?Hash[Symbol, untyped] options) -> Hash[untyped, untyped]
+      # @param value [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [Object] reserved for future per-coercion configuration (currently ignored)
+      # @return [Hash, Coercions::Failure]
       def call(value, options = EMPTY_HASH)
         if value.nil?
           {}
         elsif value.is_a?(::Hash)
           value
-        elsif value.is_a?(::Array)
-          ::Hash[*value]
-        elsif value.is_a?(::String) && (
-          value.start_with?("{") ||
-          value.strip == "null"
-        )
-          JSON.parse(value) || {}
+        elsif value.is_a?(::String)
+          result = JSON.parse(value)
+          result.is_a?(::Hash) ? result : coercion_failure
+        elsif value.respond_to?(:to_hash)
+          value.to_hash
         elsif value.respond_to?(:to_h)
           value.to_h
         else
-          raise_coercion_error!
+          coercion_failure
         end
       rescue ArgumentError, TypeError, JSON::ParserError
-        raise_coercion_error!
+        coercion_failure
       end
 
       private
 
-      # Raises a CoercionError with localized message
-      #
-      # @raise [CoercionError] Always raised with localized error message
-      def raise_coercion_error!
-        type = Locale.t("cmdx.types.hash")
-        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
+      def coercion_failure
+        type = I18nProxy.t("cmdx.types.hash")
+        Failure.new(I18nProxy.t("cmdx.coercions.into_a", type:))
       end
 
     end

data/lib/cmdx/coercions/integer.rb

@@ -1,45 +1,21 @@
 # frozen_string_literal: true
 
 module CMDx
-  module Coercions
-    # Converts various input types to Integer format
-    #
-    # Handles conversion from strings, numbers, and other values to integers
-    # using Ruby's Integer() method. Raises CoercionError for values that
-    # cannot be converted to integers.
+  class Coercions
+    # Coerces to Integer via `Kernel#Integer` (strict; rejects floats-as-strings).
     module Integer
 
       extend self
 
-      # Converts a value to an Integer
-      #
-      # @param value [Object] The value to convert to an integer
-      # @param options [Hash] Optional configuration parameters (currently unused)
-      # @option options [Object] :unused Currently no options are used
-      #
-      # @return [Integer] The converted integer value
-      #
-      # @raise [CoercionError] If the value cannot be converted to an integer
-      #
-      # @example Convert numeric strings to integers
-      #   Integer.call("42")      # => 42
-      #   Integer.call("-123")    # => -123
-      #   Integer.call("0")       # => 0
-      # @example Convert numeric types to integers
-      #   Integer.call(42.0)      # => 42
-      #   Integer.call(3.14)      # => 3
-      #   Integer.call(0.0)       # => 0
-      # @example Handle edge cases
-      #   Integer.call("")        # => raises CoercionError
-      #   Integer.call(nil)       # => raises CoercionError
-      #   Integer.call("abc")     # => raises CoercionError
-      #
-      # @rbs (untyped value, ?Hash[Symbol, untyped] options) -> Integer
+      # @param value [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [Object] reserved for future per-coercion configuration (currently ignored)
+      # @return [Integer, Coercions::Failure]
       def call(value, options = EMPTY_HASH)
         Integer(value)
       rescue ArgumentError, FloatDomainError, RangeError, TypeError
-        type = Locale.t("cmdx.types.integer")
-        raise CoercionError, Locale.t("cmdx.coercions.into_an", type:)
+        type = I18nProxy.t("cmdx.types.integer")
+        Failure.new(I18nProxy.t("cmdx.coercions.into_an", type:))
       end
 
     end

data/lib/cmdx/coercions/rational.rb

@@ -1,45 +1,24 @@
 # frozen_string_literal: true
 
 module CMDx
-  module Coercions
-    # Converts various input types to Rational format
-    #
-    # Handles conversion from strings, numbers, and other values to rational
-    # numbers using Ruby's Rational() method. Raises CoercionError for values
-    # that cannot be converted to rational numbers.
+  class Coercions
+    # Coerces to `Rational`. Supply `denominator:` to build a rational from
+    # a numerator and a custom denominator.
     module Rational
 
       extend self
 
-      # Converts a value to a Rational
-      #
-      # @param value [Object] The value to convert to a rational number
-      # @param options [Hash] Optional configuration parameters (currently unused)
-      # @option options [Object] :unused Currently no options are used
-      #
-      # @return [Rational] The converted rational number
-      #
-      # @raise [CoercionError] If the value cannot be converted to a rational number
-      #
-      # @example Convert numeric strings to rational numbers
-      #   Rational.call("3/4")     # => (3/4)
-      #   Rational.call("2.5")     # => (5/2)
-      #   Rational.call("0")       # => (0/1)
-      # @example Convert numeric types to rational numbers
-      #   Rational.call(3.14)      # => (157/50)
-      #   Rational.call(2)         # => (2/1)
-      #   Rational.call(0.5)       # => (1/2)
-      # @example Handle edge cases
-      #   Rational.call("")        # => (0/1)
-      #   Rational.call(nil)       # => (0/1)
-      #   Rational.call(0)         # => (0/1)
-      #
-      # @rbs (untyped value, ?Hash[Symbol, untyped] options) -> Rational
+      # @param value [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [Numeric] :denominator (1)
+      # @return [Rational, Coercions::Failure]
       def call(value, options = EMPTY_HASH)
-        Rational(value)
+        return value if value.is_a?(::Rational)
+
+        Rational(value, options[:denominator] || 1)
       rescue ArgumentError, FloatDomainError, RangeError, TypeError, ZeroDivisionError
-        type = Locale.t("cmdx.types.rational")
-        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
+        type = I18nProxy.t("cmdx.types.rational")
+        Failure.new(I18nProxy.t("cmdx.coercions.into_a", type:))
       end
 
     end

data/lib/cmdx/coercions/string.rb

@@ -1,34 +1,16 @@
 # frozen_string_literal: true
 
 module CMDx
-  module Coercions
-    # Coerces values to String type using Ruby's built-in String() method.
-    #
-    # This coercion handles various input types by converting them to their
-    # string representation. It's a simple wrapper around Ruby's String()
-    # method for consistency with the CMDx coercion interface.
+  class Coercions
+    # Coerces to String via `Kernel#String`. Never fails for normal objects.
     module String
 
       extend self
 
-      # Coerces a value to String type.
-      #
-      # @param value [Object] The value to coerce to a string
-      # @param options [Hash] Optional configuration parameters (unused in this coercion)
-      # @option options [Object] :* Any configuration option (unused)
-      #
-      # @return [String] The coerced string value
-      #
-      # @raise [TypeError] If the value cannot be converted to a string
-      #
-      # @example Basic string coercion
-      #   String.call("hello")           # => "hello"
-      #   String.call(42)                # => "42"
-      #   String.call([1, 2, 3])         # => "[1, 2, 3]"
-      #   String.call(nil)               # => ""
-      #   String.call(true)              # => "true"
-      #
-      # @rbs (untyped value, ?Hash[Symbol, untyped] options) -> String
+      # @param value [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [Object] reserved for future per-coercion configuration (currently ignored)
+      # @return [String]
       def call(value, options = EMPTY_HASH)
         String(value)
       end

data/lib/cmdx/coercions/symbol.rb

@@ -1,38 +1,24 @@
 # frozen_string_literal: true
 
 module CMDx
-  module Coercions
-    # Coerces values to Symbol type using Ruby's to_sym method.
-    #
-    # This coercion handles various input types by converting them to symbols.
-    # It provides error handling for values that cannot be converted to symbols
-    # and raises appropriate CMDx coercion errors with localized messages.
+  class Coercions
+    # Coerces to Symbol via `#to_s.to_sym`. Fails only when `value` has no
+    # `#to_s` (i.e. `BasicObject` instances).
     module Symbol
 
       extend self
 
-      # Coerces a value to Symbol type.
-      #
-      # @param value [Object] The value to coerce to a symbol
-      # @param options [Hash] Optional configuration parameters (unused in this coercion)
-      # @option options [Object] :* Any configuration option (unused)
-      #
-      # @return [Symbol] The coerced symbol value
-      #
-      # @raise [CoercionError] If the value cannot be converted to a symbol
-      #
-      # @example Basic symbol coercion
-      #   Symbol.call("hello")           # => :hello
-      #   Symbol.call("user_id")         # => :user_id
-      #   Symbol.call("")                # => :""
-      #   Symbol.call(:existing)         # => :existing
-      #
-      # @rbs (untyped value, ?Hash[Symbol, untyped] options) -> Symbol
+      # @param value [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [Object] reserved for future per-coercion configuration (currently ignored)
+      # @return [Symbol, Coercions::Failure]
       def call(value, options = EMPTY_HASH)
-        value.to_sym
+        return value if value.is_a?(::Symbol)
+
+        value.to_s.to_sym
       rescue NoMethodError
-        type = Locale.t("cmdx.types.symbol")
-        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
+        type = I18nProxy.t("cmdx.types.symbol")
+        Failure.new(I18nProxy.t("cmdx.coercions.into_a", type:))
       end
 
     end

data/lib/cmdx/coercions/time.rb

@@ -1,47 +1,43 @@
 # frozen_string_literal: true
 
 module CMDx
-  module Coercions
-    # Converts various input types to Time format
-    #
-    # Handles conversion from strings, dates, and other time-like objects to Time
-    # using Ruby's built-in time parsing methods. Supports custom strptime formats
-    # and raises CoercionError for values that cannot be converted to Time.
+  class Coercions
+    # Coerces to `Time`. Strings use `Time.parse` (or `strptime` when
+    # supplied); Numerics are treated as epoch seconds; objects responding
+    # to `#to_time` are unwrapped.
     module Time
 
       extend self
 
-      # Converts a value to a Time object
-      #
-      # @param value [Object] The value to convert to a Time object
-      # @param options [Hash] Optional configuration parameters
-      # @option options [String] :strptime Custom strptime format string for parsing
-      #
-      # @return [Time] The converted Time object
-      #
-      # @raise [CoercionError] If the value cannot be converted to a Time object
-      #
-      # @example Convert time-like objects
-      #   Time.call(Time.now)                    # => Time object (unchanged)
-      #   Time.call(DateTime.now)                # => Time object (converted)
-      #   Time.call(Date.today)                  # => Time object (converted)
-      # @example Convert strings with default parsing
-      #   Time.call("2023-12-25 10:30:00")      # => Time object
-      #   Time.call("2023-12-25")               # => Time object
-      #   Time.call("10:30:00")                 # => Time object
-      # @example Convert strings with custom format
-      #   Time.call("25/12/2023", strptime: "%d/%m/%Y")  # => Time object
-      #   Time.call("12-25-2023", strptime: "%m-%d-%Y")  # => Time object
-      #
-      # @rbs (untyped value, ?Hash[Symbol, untyped] options) -> Time
+      # @param value [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :strptime format string for `Time.strptime`
+      # @return [Time, Coercions::Failure]
       def call(value, options = EMPTY_HASH)
-        return value.to_time if value.respond_to?(:to_time)
-        return ::Time.strptime(value, options[:strptime]) if options[:strptime]
-
-        ::Time.parse(value)
+        if value.is_a?(::Time)
+          value
+        elsif value.is_a?(::String)
+          if (strptime = options[:strptime])
+            ::Time.strptime(value, strptime)
+          else
+            ::Time.parse(value)
+          end
+        elsif value.is_a?(::Numeric)
+          ::Time.at(value)
+        elsif value.respond_to?(:to_time)
+          value.to_time
+        else
+          coercion_failure
+        end
       rescue ArgumentError, TypeError
-        type = Locale.t("cmdx.types.time")
-        raise CoercionError, Locale.t("cmdx.coercions.into_a", type:)
+        coercion_failure
+      end
+
+      private
+
+      def coercion_failure
+        type = I18nProxy.t("cmdx.types.time")
+        Failure.new(I18nProxy.t("cmdx.coercions.into_a", type:))
       end
 
     end

data/lib/cmdx/coercions.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module CMDx
+  # Registry of named type coercions applied to input/output values. Ships
+  # with built-ins for `:array`, `:big_decimal`, `:boolean`, `:complex`,
+  # `:date`, `:date_time`, `:float`, `:hash`, `:integer`, `:rational`,
+  # `:string`, `:symbol`, `:time`. Coercion handlers return the coerced
+  # value on success, or a {Failure} carrying an i18n message on failure.
+  class Coercions
+
+    # Sentinel returned by a coercion when the value can't be converted.
+    # Runtime records the message as a validation error against the attribute.
+    Failure = Data.define(:message)
+
+    attr_reader :registry
+
+    def initialize
+      @registry = {
+        array: Coercions::Array,
+        big_decimal: Coercions::BigDecimal,
+        boolean: Coercions::Boolean,
+        complex: Coercions::Complex,
+        date: Coercions::Date,
+        date_time: Coercions::DateTime,
+        float: Coercions::Float,
+        hash: Coercions::Hash,
+        integer: Coercions::Integer,
+        rational: Coercions::Rational,
+        string: Coercions::String,
+        symbol: Coercions::Symbol,
+        time: Coercions::Time
+      }
+    end
+
+    # @param source [Coercions] registry to duplicate
+    # @return [void]
+    def initialize_copy(source)
+      @registry = source.registry.dup
+    end
+
+    # Registers a named coercion, overwriting any existing entry with the
+    # same name.
+    #
+    # @param name [Symbol]
+    # @param callable [#call, nil] pass either this or a block
+    # @param block [#call, nil] coercion implementation when `callable` is omitted
+    # @yield (see built-in coercion signatures — `call(value, options = {})`)
+    # @return [Coercions] self for chaining
+    # @raise [ArgumentError] when both `callable` and a block are given, or
+    #   when the resolved coercion isn't callable
+    def register(name, callable = nil, &block)
+      coercion = callable || block
+
+      if callable && block
+        raise ArgumentError, "provide either a callable or a block, not both"
+      elsif !coercion.respond_to?(:call)
+        raise ArgumentError, "coercion must respond to #call"
+      end
+
+      registry[name.to_sym] = coercion
+      self
+    end
+
+    # @param name [Symbol]
+    # @return [Coercions] self for chaining
+    def deregister(name)
+      registry.delete(name.to_sym)
+      self
+    end
+
+    # @param name [Symbol]
+    # @return [#call] the registered coercion
+    # @raise [ArgumentError] when `name` isn't registered
+    def lookup(name)
+      registry[name] || begin
+        raise ArgumentError, "unknown coercion: #{name}"
+      end
+    end
+
+    # Normalizes the `:coerce` declaration on an input/output into a list of
+    # `[handler, opts]` pairs. Accepts a Symbol, Array, Hash, or any
+    # callable.
+    #
+    # @param options [Hash{Symbol => Object}] declaration options
+    # @option options [Object] :coerce coercion rule(s): Symbol, Array, Hash, or `#call`-able
+    # @return [Array<Array(Object, Hash)>] pairs of handler + per-handler options
+    # @raise [ArgumentError] when `:coerce` is an unsupported format
+    def extract(options)
+      return EMPTY_ARRAY if options.empty?
+
+      raw = options[:coerce]
+      return EMPTY_ARRAY if raw.nil? || raw == EMPTY_ARRAY
+
+      case raw
+      when ::Symbol
+        [[raw, EMPTY_HASH]]
+      when ::Array
+        raw.map { |t| normalize_entry(t) }
+      when ::Hash
+        raw.map { |k, v| [k, v == true ? EMPTY_HASH : v] }
+      else
+        return [[raw, EMPTY_HASH]] if raw.respond_to?(:call)
+
+        raise ArgumentError, "unsupported type format: #{raw.inspect}"
+      end
+    end
+
+    # @return [Boolean]
+    def empty?
+      registry.empty?
+    end
+
+    # @return [Integer]
+    def size
+      registry.size
+    end
+
+    # Applies each coercion rule to `value`. Returns the first successful
+    # coercion. When every rule fails and more than one was declared (and
+    # none were inline callables), the aggregated "into_any" message is
+    # recorded; otherwise the last individual failure is used.
+    #
+    # @param task [Task] used for inline `Symbol`/`Proc` handlers and error recording
+    # @param name [Symbol] attribute name for error reporting
+    # @param value [Object] raw input before coercion rules run
+    # @param rules [Array<Array(Object, Hash)>] from {#extract}
+    # @return [Object, Failure] coerced value, or `Failure` when every rule failed
+    def coerce(task, name, value, rules)
+      return value if rules.empty?
+
+      last_failure = nil
+      any_inline = false
+
+      rules.each do |handler, opts|
+        result =
+          if handler.is_a?(::Symbol) && registry.key?(handler)
+            lookup(handler).call(value, **opts)
+          else
+            any_inline = true
+            Coercions::Coerce.call(task, value, handler)
+          end
+
+        return result unless result.is_a?(Failure)
+
+        last_failure = result
+      end
+
+      if rules.size > 1 && !any_inline
+        type_names   = rules.map { |h, _| I18nProxy.t("cmdx.types.#{h}") }.join(", ")
+        last_failure = Failure.new(I18nProxy.t("cmdx.coercions.into_any", types: type_names))
+      end
+
+      task.errors.add(name, last_failure.message)
+      last_failure
+    end
+
+    private
+
+    # @param entry [Object] Array entry from a `:coerce` list
+    # @return [Array(Object, Hash)] handler + options pair
+    # @raise [ArgumentError] when `entry` is unsupported
+    def normalize_entry(entry)
+      case entry
+      when ::Symbol, ::Proc
+        [entry, EMPTY_HASH]
+      else
+        return [entry, EMPTY_HASH] if entry.respond_to?(:call)
+
+        raise ArgumentError, "unsupported coerce entry: #{entry.inspect}"
+      end
+    end
+
+  end
+end