hecks 3.4.2 → 3.6.0

data/lib/hecks/runtime/value/field_checks.rb

@@ -1,6 +1,7 @@
 require_relative "../errors"
 require_relative "../refusal_wording"
 require_relative "../../rendering"
+require_relative "shape_checks"
 
 module Hecks
   module Runtime
@@ -8,32 +9,48 @@ module Hecks
       # Boundary checks that refuse a mistyped, unknown, missing or malformed field before an
       # invariant reads it; extended into `Value` alongside `Coercion`, which calls them.
       module FieldChecks
+        include ShapeChecks
+
+        # C3.3/C3.4 — value bounds enforced at every boundary: an Integer must fit
+        # signed 64 bits, a Float must be finite.
+        INT64_RANGE = (-(2**63))..((2**63) - 1)
+
+        # Checked before invariants, because an invariant reading a mistyped field
+        # is exactly the thing that would otherwise explode.
+        NUMERIC = { "Integer" => Integer, "Float" => Numeric }.freeze
+
+        # A scalar field (String, or a boolean) must not arrive as a composite
+        # (Array/Hash) standing in for a leaf value. A String field additionally
+        # must not arrive as any other scalar, except inside `judge_bootstrapping?`.
+        COMPOSITE_SHAPES = [Array, ::Hash].freeze
+        NON_NUMERIC_SCALARS = %w[String TrueClass FalseClass].freeze
+
+        private
+
+        # The refusal every wrong-typed or missing field shares: `type_name`'s `field_name` was
+        # offered `offered` where `expected` was declared.
+        def numeric_field_mismatch!(type_name, field_name, expected, offered)
+          raise TypeMismatch,
+                RefusalWording.render_site("TypeMismatch", "numeric_field",
+                                           type: type_name, field: field_name, expected: expected, offered: offered)
+        end
+
         # C3.8 boundary check — refuses a mistyped argument before it breaks a predicate.
-        private def check_bare_primitive(owner, attribute, value)
+        def check_bare_primitive(owner, attribute, value)
           type = attribute.type.to_s
-          expected = NUMERIC[type]
-          mistyped = if expected
-                       !value.is_a?(expected)
-                     elsif NON_NUMERIC_SCALARS.include?(type)
-                       COMPOSITE_SHAPES.any? { |shape| value.is_a?(shape) }
-                     else
-                       false
-                     end
-          if mistyped
-            raise TypeMismatch,
-                  RefusalWording.render_site("TypeMismatch", "numeric_field",
-                                             type: owner.hecks_name, field: attribute.name,
-                                             expected: type, offered: Rendering.describe(value))
-          end
+          numeric_field_mismatch!(owner.hecks_name, attribute.name, type, Rendering.describe(value)) if mistyped?(type, value)
 
           check_numeric_bounds(owner.hecks_name, attribute.name, value)
         end
 
-        # C3.3/C3.4 — value bounds enforced at every boundary: an Integer must fit
-        # signed 64 bits, a Float must be finite.
-        INT64_RANGE = (-(2**63))..((2**63) - 1)
+        def mistyped?(type, value)
+          expected = NUMERIC[type]
+          return !value.is_a?(expected) if expected
+
+          NON_NUMERIC_SCALARS.include?(type) && COMPOSITE_SHAPES.any? { |shape| value.is_a?(shape) }
+        end
 
-        private def check_numeric_bounds(type_name, field_name, given)
+        def check_numeric_bounds(type_name, field_name, given)
           if given.is_a?(Integer) && !INT64_RANGE.cover?(given)
             raise TypeMismatch,
                   RefusalWording.render_site("TypeMismatch", "integer_range",
@@ -48,7 +65,7 @@ module Hecks
 
         # A value object refuses an undeclared key the same way a command's own
         # payload does, checked before any other field-content check.
-        private def check_unknown_fields(value_object, fields)
+        def check_unknown_fields(value_object, fields)
           known   = value_object.attributes.map { |attribute| attribute.name.to_sym }
           unknown = (fields.keys.map(&:to_sym) - known).sort
           return if unknown.empty?
@@ -62,110 +79,50 @@ module Hecks
 
         # C3.7 — every non-optional, non-list field must arrive (or construction
         # refuses); a `default:` has already been filled in by `apply_defaults`.
-        private def check_required_fields(value_object, fields)
+        def check_required_fields(value_object, fields)
           value_object.attributes.each do |attribute|
             next if attribute.optional? || attribute.list?
             next unless fields[attribute.name].nil?
 
-            raise TypeMismatch,
-                  RefusalWording.render_site("TypeMismatch", "numeric_field",
-                                             type: value_object.hecks_name, field: attribute.name,
-                                             expected: attribute.type, offered: "nil")
+            numeric_field_mismatch!(value_object.hecks_name, attribute.name, attribute.type, "nil")
           end
         end
 
-        # Checked before invariants, because an invariant reading a mistyped field
-        # is exactly the thing that would otherwise explode.
-        NUMERIC = { "Integer" => Integer, "Float" => Numeric }.freeze
-        private def check_numeric_fields(value_object, fields)
+        def check_numeric_fields(value_object, fields)
           value_object.attributes.each do |attribute|
             expected = NUMERIC[attribute.type.to_s]
-            next unless expected
+            given    = fields[attribute.name]
+            next unless expected && !given.nil?
 
-            given = fields[attribute.name]
-            next if given.nil?
-
-            offered_items(attribute, given).each do |item|
-              unless item.is_a?(expected)
-                raise TypeMismatch,
-                      RefusalWording.render_site("TypeMismatch", "numeric_field",
-                                                 type: value_object.hecks_name, field: attribute.name,
-                                                 expected: attribute.type, offered: Rendering.describe(item))
-              end
-
-              # `is_a?(expected)` alone waves NaN/Infinity through — both are real
-              # Floats. `-0.0` is deliberately left unchecked: finite and legitimate.
-              check_numeric_bounds(value_object.hecks_name, attribute.name, item)
-            end
+            offered_items(attribute, given).each { |item| check_numeric_item!(value_object, attribute, expected, item) }
+          end
+        end
+
+        def check_numeric_item!(value_object, attribute, expected, item)
+          unless item.is_a?(expected)
+            numeric_field_mismatch!(value_object.hecks_name, attribute.name, attribute.type, Rendering.describe(item))
           end
+
+          # `is_a?(expected)` alone waves NaN/Infinity through — both are real
+          # Floats. `-0.0` is deliberately left unchecked: finite and legitimate.
+          check_numeric_bounds(value_object.hecks_name, attribute.name, item)
         end
 
         # A `list_of` field holds an Array whatever its element type, so a lone scalar
         # offered for it is refused; nil stays legitimate, as it is for any optional field.
-        private def check_list_shapes(value_object, fields)
+        def check_list_shapes(value_object, fields)
           value_object.attributes.each do |attribute|
             given = fields[attribute.name]
             next unless attribute.list? && !given.nil? && !given.is_a?(Array)
 
-            raise TypeMismatch, RefusalWording.render_site(
-              "TypeMismatch", "numeric_field", type: value_object.hecks_name, field: attribute.name,
-              expected: "list_of(#{attribute.type})", offered: Rendering.describe(given)
-            )
+            numeric_field_mismatch!(value_object.hecks_name, attribute.name, "list_of(#{attribute.type})",
+                                    Rendering.describe(given))
           end
         end
 
         # The values a field's element-level checks apply to: each element of a list, or the
         # one value of a scalar field.
-        private def offered_items(attribute, given) = attribute.list? && given.is_a?(Array) ? given : [given]
-
-        # A scalar field (String, or a boolean) must not arrive as a composite
-        # (Array/Hash) standing in for a leaf value. A String field additionally
-        # must not arrive as any other scalar, except inside `judge_bootstrapping?`.
-        COMPOSITE_SHAPES = [Array, ::Hash].freeze
-        NON_NUMERIC_SCALARS = %w[String TrueClass FalseClass].freeze
-        private def check_scalar_shapes(value_object, fields)
-          value_object.attributes.each do |attribute|
-            type = attribute.type.to_s
-            next unless NON_NUMERIC_SCALARS.include?(type)
-
-            given = fields[attribute.name]
-            next if given.nil?
-
-            offered_items(attribute, given).each do |item|
-              composite = COMPOSITE_SHAPES.any? { |shape| item.is_a?(shape) }
-              non_string_scalar = type == "String" && !composite && !item.is_a?(String) && !judge_bootstrapping?
-              next unless composite || non_string_scalar
-
-              raise TypeMismatch,
-                    RefusalWording.render_site("TypeMismatch", "numeric_field",
-                                               type: value_object.hecks_name, field: attribute.name,
-                                               expected: attribute.type, offered: Rendering.describe(item))
-            end
-          end
-        end
-
-        # A field declared with a pattern must match it, refused as a TypeMismatch
-        # rather than surfacing later as a broken predicate. The pattern itself is
-        # already vetted by PatternSubset when the bluebook is declared. `^` and `$` match the
-        # whole value, as in Rust, so a newline cannot smuggle text past an anchored pattern.
-        private def check_patterns(value_object, fields)
-          value_object.attributes.each do |attribute|
-            pattern = attribute.pattern
-            next unless pattern
-
-            given = fields[attribute.name]
-            next if given.nil?
-
-            offered_items(attribute, given).each do |item|
-              next if item.is_a?(String) && Regexp.new(Hecks::Bluebook::PatternSubset.whole_string(pattern)).match?(item)
-
-              raise TypeMismatch,
-                    RefusalWording.render_site("TypeMismatch", "pattern_mismatch",
-                                               type: value_object.hecks_name, field: attribute.name,
-                                               pattern: pattern, offered: Rendering.describe(item))
-            end
-          end
-        end
+        def offered_items(attribute, given) = attribute.list? && given.is_a?(Array) ? given : [given]
       end
     end
   end

data/lib/hecks/runtime/value/flags.rb

@@ -0,0 +1,65 @@
+module Hecks
+  module Runtime
+    class Value
+      # The two thread-local flags that loosen validation for one caller on one thread: trusting
+      # stored state, and the self-hosted judge's bootstrap. Extended into `Value` beside
+      # `Coercion`.
+      module Flags
+        TRUSTED_LOAD_KEY = :hecks_trusting_stored_state
+
+        # Marks the block as loading trusted, already-validated stored state, so
+        # `validate!` skips its own checks for the block's duration.
+        #
+        # Thread-local, not a plain ivar, so two threads hydrating concurrently
+        # never see or clear each other's flag.
+        #
+        # @yield the code that should see `trusting_stored_state?` true
+        # @return [Object] the block's result
+        def trusting_stored_state
+          previous = Thread.current[TRUSTED_LOAD_KEY]
+          Thread.current[TRUSTED_LOAD_KEY] = true
+          yield
+        ensure
+          Thread.current[TRUSTED_LOAD_KEY] = previous
+        end
+
+        # Whether the current thread is inside a `trusting_stored_state` block.
+        #
+        # @return [Boolean] true if on this thread's own call stack
+        def trusting_stored_state? = Thread.current[TRUSTED_LOAD_KEY] == true
+
+        # `MetaValidator::Judge#send_to` walks a bluebook's own declarations through
+        # the self-hosted "Bluebook" meta-domain, and its generic append handling
+        # keys off a field's name ("position") rather than its declared type — so
+        # the language's own grammar can hand this a raw Integer for a String-typed
+        # meta field on every domain's first boot. This flag loosens
+        # `check_scalar_shapes`'s String check only for that one caller; composite
+        # shapes (Array/Hash) stay refused unconditionally, bootstrap or not, and no
+        # real domain's own declared value objects are affected.
+        BOOTSTRAP_KEY = :hecks_judge_bootstrapping
+
+        # Marks the block as `MetaValidator::Judge#send_to`'s self-hosted bootstrap
+        # dispatch, so `check_scalar_shapes` loosens its `String` check for the
+        # block's duration.
+        #
+        # Thread-local, not a plain ivar, so two threads bootstrapping concurrently
+        # never see or clear each other's flag.
+        #
+        # @yield the code that should see `judge_bootstrapping?` true
+        # @return [Object] the block's result
+        def judge_bootstrapping
+          previous = Thread.current[BOOTSTRAP_KEY]
+          Thread.current[BOOTSTRAP_KEY] = true
+          yield
+        ensure
+          Thread.current[BOOTSTRAP_KEY] = previous
+        end
+
+        # Whether the current thread is inside a `judge_bootstrapping` block.
+        #
+        # @return [Boolean] true if on this thread's own call stack
+        def judge_bootstrapping? = Thread.current[BOOTSTRAP_KEY] == true
+      end
+    end
+  end
+end

data/lib/hecks/runtime/value/identifiers.rb

@@ -0,0 +1,64 @@
+require_relative "../errors"
+require_relative "../refusal_wording"
+
+module Hecks
+  module Runtime
+    class Value
+      # Renders a value object as the bare scalar it holds, and builds one back from a derived
+      # identity string. Extended into `Value` beside `Coercion`.
+      module Identifiers
+        # Renders a value object into the bare scalar its one field holds — for a
+        # column or a message, where there is no path to consult.
+        #
+        # @param value [Object] the value to render; passed through unless a `Runtime::Value`
+        # @return [Object] `value` unchanged, or its one field's own value
+        # @raise [Runtime::TypeMismatch] if `value` has more than one field
+        def scalar(value)
+          return value unless value.is_a?(self)
+
+          fields = value.to_h
+          return fields.values.first if fields.size == 1
+
+          raise TypeMismatch, RefusalWording.render_site("TypeMismatch", "multi_field_scalar", type: value.type_name)
+        end
+
+        # Coerces a derived identity string back into `attribute`'s own declared type.
+        #
+        # @param aggregate [Bluebook::Aggregate, Bluebook::Entity] construct
+        #   `attribute` is declared on
+        # @param attribute [Bluebook::Attribute] the identity attribute to coerce for
+        # @param identifier [String, Object] the derived identity
+        # @return [Runtime::Value, String, Object] a built value object for a
+        #   single-field value-object type; `identifier` unchanged otherwise
+        # @raise [Runtime::TypeMismatch] if the type names a multi-field value object
+        def from_identifier(aggregate, attribute, identifier)
+          value_object = value_object_for(aggregate, attribute.type)
+          return identifier unless value_object
+
+          fields = value_object.attributes
+          if fields.size == 1
+            field = fields.first
+            return build(value_object, { field.name => coerce_identifier(field, identifier) })
+          end
+
+          raise TypeMismatch, RefusalWording.render_site("TypeMismatch", "composite_identity", type: value_object.hecks_name)
+        end
+
+        private
+
+        # Converts a derived numeric identity string back before `check_numeric_fields` runs.
+        def coerce_identifier(field, identifier)
+          return identifier unless identifier.is_a?(String) && FieldChecks::NUMERIC.key?(field.type.to_s)
+
+          case field.type.to_s
+          when "Integer" then Integer(identifier)
+          when "Float"   then Float(identifier)
+          else identifier
+          end
+        rescue ArgumentError
+          identifier
+        end
+      end
+    end
+  end
+end

data/lib/hecks/runtime/value/references.rb

@@ -0,0 +1,195 @@
+require_relative "../../naming"
+require_relative "../../rendering"
+require_relative "../errors"
+require_relative "../refusal_wording"
+
+module Hecks
+  module Runtime
+    class Value
+      # How a reference-typed attribute's offered value becomes the target's identity, and how a
+      # wrong-shaped one is refused. Extended into `Value` beside `Coercion`.
+      module References
+        # Coerces a reference-typed attribute's offered value into the target's own
+        # canonical identity string.
+        #
+        # @param attribute [Bluebook::Attribute] the reference-typed attribute
+        # @param value [Object] a bare scalar identity, a `Runtime::Value`, or a Hash
+        #   naming the target's own identity fields
+        # @return [String, Object] the joined identity String, or `value` unchanged
+        #   when it cannot be resolved
+        def reference_identity(attribute, value)
+          target = reference_target(attribute, value)
+          return value unless target
+
+          parts = identity_parts(value, target)
+          return Naming.identity(parts) unless parts.any? { |part| blank_identity_part?(part) }
+
+          sole_scalar_identity(value, target.identity_paths) || value
+        end
+
+        # Unwraps `value` to a bare scalar when `paths` names exactly one identity
+        # field and `value` is itself a single-attribute value object — the only
+        # case where unwrapping cannot be ambiguous.
+        #
+        # @param value [Object] the offered reference value to unwrap
+        # @param paths [Array<String>] the target's own declared identity paths
+        # @return [Object, nil] the unwrapped scalar, or nil if it does not apply
+        def sole_scalar_identity(value, paths)
+          return nil unless value.is_a?(self) && paths.one?
+          return nil unless value.value_object.sole_attribute
+
+          materialize_unwrapped(value)
+        end
+
+        # Whether `value` is itself the target's own single identity value object.
+        #
+        # @param value [Object] the offered reference value to check
+        # @param target [Bluebook::Aggregate] the reference's own resolved target
+        # @return [String, nil] the target's identity head name, or nil
+        def direct_identity_head(value, target)
+          return nil unless value.is_a?(self) && target.identity_heads.one?
+
+          head = target.identity_heads.first
+          target.attribute(head)&.type.to_s == value.type_name ? head.to_s : nil
+        end
+
+        # One identity path's own value out of the materialized hash, stripping a
+        # leading segment already covered by `direct_identity_head`.
+        #
+        # @param materialized [Hash, Object] the offered reference value as a Hash
+        # @param path [String, Symbol] one dotted identity path to dig
+        # @param direct_head [String, nil] leading segment to strip, if present
+        # @return [Object, nil] the value found by walking `path`, or nil if missing
+        def identity_part(materialized, path, direct_head)
+          segments = path.to_s.split(".")
+          segments.shift if direct_head && segments.first == direct_head
+          segments.reduce(materialized) do |held, segment|
+            next nil unless held.is_a?(Hash)
+
+            # `key?` decides which spelling answers — a genuinely-held `false`
+            # must not fall through to the other spelling and read as `nil`.
+            sym = segment.to_sym
+            held.key?(sym) ? held[sym] : held[segment]
+          end
+        end
+
+        # Coerces a `has_many` reference-typed attribute's offered value.
+        #
+        # @param attribute [Bluebook::Attribute] the `has_many` reference attribute
+        # @param value [Object] the offered value; must be an Array
+        # @return [Array] `value`, deep-frozen and duped
+        # @raise [Runtime::TypeMismatch] if `value` is not an Array
+        def reference_list(attribute, value)
+          unless value.is_a?(Array)
+            raise TypeMismatch,
+                  "#{attribute.name} is a has_many relationship — pass a list of identities"
+          end
+
+          Freezer.deep(value.dup)
+        end
+
+        # A reference is an ID; refused at the payload gate if it arrives as a
+        # Hash or `Runtime::Value` instead. `nil` stays legitimate for an optional
+        # reference — a required reference's own `nil` is refused elsewhere (C3.7).
+        #
+        # @param command [Class] the command `attribute` is declared on, named in a refusal
+        # @param attribute [Bluebook::Attribute] the attribute to check; a no-op unless
+        #   reference-typed
+        # @param value [Object] the offered value
+        # @return [void]
+        # @raise [Runtime::TypeMismatch] if `value` (or an element, for `has_many`) is a
+        #   Hash or `Runtime::Value` rather than a plain identity
+        def refuse_object_reference(command, attribute, value)
+          return unless attribute.reference?
+
+          offence = object_reference_offence(attribute, value)
+          return unless offence
+
+          raise TypeMismatch,
+                RefusalWording.render_site("TypeMismatch", "reference_wrong_shape",
+                                           command: command.hecks_name, attribute: attribute.name,
+                                           offered: reference_shape_description(offence.first),
+                                           known_by: known_by(attribute))
+        end
+
+        # A list argument is an Array whatever its element type, so a lone scalar offered for
+        # it is refused; nil stays legitimate, as for any optional argument. The single-element
+        # form belongs to the `append`/`remove` effects, which take one element and are
+        # coerced against the aggregate's own list, never through this gate.
+        #
+        # @param command [#hecks_name] what `attribute` is declared on, named in a refusal
+        # @param attribute [Bluebook::Attribute] the attribute to check; a no-op unless list-typed
+        #   (a `has_many` reference list has its own refusal)
+        # @param value [Object] the offered value
+        # @return [void]
+        # @raise [Runtime::TypeMismatch] if `value` is neither nil nor an Array
+        def refuse_scalar_list(command, attribute, value)
+          return unless attribute.list? && !attribute.reference? && !value.nil? && !value.is_a?(Array)
+
+          numeric_field_mismatch!(command.hecks_name, attribute.name, "list_of(#{attribute.type})", Rendering.describe(value))
+        end
+
+        # "an object" for the Hash/Value shape; `Rendering.describe` otherwise —
+        # the same rendering every other TypeMismatch in this file uses.
+        #
+        # @param value [Object] the wrongly-shaped offered value to describe
+        # @return [String] `"an object"` for a Hash or `Runtime::Value`; otherwise
+        #   `Rendering.describe(value)`
+        def reference_shape_description(value)
+          return "an object" if value.is_a?(Hash) || value.is_a?(self)
+
+          Rendering.describe(value)
+        end
+
+        # "(Account is known by number)" — what to send instead. No article, since
+        # "an Account" vs "a Customer" would make a pinned refusal hinge on spelling.
+        #
+        # @param attribute [Bluebook::Attribute] the reference-typed attribute to
+        #   describe the target's identity heads for
+        # @return [String] `" (Target is known by head1, head2)"`, or `""` if the
+        #   target or its identity heads cannot be resolved
+        def known_by(attribute)
+          heads = Array(attribute.type.resolve&.identity_heads)
+          return "" if heads.empty?
+
+          " (#{attribute.type.target_name} is known by #{heads.join(", ")})"
+        end
+
+        private
+
+        # The target aggregate whose identity an offered value can name, when it has one.
+        def reference_target(attribute, value)
+          return nil unless value.is_a?(self) || value.is_a?(Hash)
+
+          target = attribute.type.resolve
+          target if target && !target.identity_paths.empty?
+        end
+
+        def identity_parts(value, target)
+          materialized = materialize(value)
+          direct_head  = direct_identity_head(value, target)
+          target.identity_paths.map { |path| identity_part(materialized, path, direct_head) }
+        end
+
+        def blank_identity_part?(part)
+          part.nil? || (part.respond_to?(:empty?) && part.empty?)
+        end
+
+        # What a reference argument offers that is not a plain identity: `[offered]`, or nil when
+        # nothing is wrong. The one-element list tells an offered nil from nothing offered.
+        def object_reference_offence(attribute, value)
+          return list_reference_offence(value) if attribute.list?
+          return nil if value.nil? && attribute.optional?
+          return nil if value.is_a?(String)
+
+          [value]
+        end
+
+        def list_reference_offence(value)
+          offered = Array(value).find { |item| item.is_a?(Hash) || item.is_a?(self) }
+          offered && [offered]
+        end
+      end
+    end
+  end
+end

data/lib/hecks/runtime/value/shape_checks.rb

@@ -0,0 +1,61 @@
+require_relative "../errors"
+require_relative "../refusal_wording"
+require_relative "../../rendering"
+
+module Hecks
+  module Runtime
+    class Value
+      # Checks on what a scalar or patterned field may hold. Mixed into {FieldChecks}.
+      module ShapeChecks
+        private
+
+        def check_scalar_shapes(value_object, fields)
+          value_object.attributes.each do |attribute|
+            scalar_items(attribute, fields[attribute.name]).each do |item|
+              next unless misshapen_scalar?(attribute.type.to_s, item)
+
+              numeric_field_mismatch!(value_object.hecks_name, attribute.name, attribute.type, Rendering.describe(item))
+            end
+          end
+        end
+
+        # The offered values of a String or boolean field; none for any other field or a nil.
+        def scalar_items(attribute, given)
+          return [] unless FieldChecks::NON_NUMERIC_SCALARS.include?(attribute.type.to_s) && !given.nil?
+
+          offered_items(attribute, given)
+        end
+
+        # A composite standing in for a leaf, or a non-String standing in for a String.
+        def misshapen_scalar?(type, item)
+          composite = FieldChecks::COMPOSITE_SHAPES.any? { |shape| item.is_a?(shape) }
+          composite || (type == "String" && !item.is_a?(String) && !judge_bootstrapping?)
+        end
+
+        # A field declared with a pattern must match it, refused as a TypeMismatch
+        # rather than surfacing later as a broken predicate. The pattern itself is
+        # already vetted by PatternSubset when the bluebook is declared. `^` and `$` match the
+        # whole value, as in Rust, so a newline cannot smuggle text past an anchored pattern.
+        def check_patterns(value_object, fields)
+          value_object.attributes.each do |attribute|
+            pattern = attribute.pattern
+            given   = fields[attribute.name]
+            next unless pattern && !given.nil?
+
+            offered_items(attribute, given).each { |item| check_pattern_item!(value_object, attribute, item) }
+          end
+        end
+
+        def check_pattern_item!(value_object, attribute, item)
+          pattern = attribute.pattern
+          return if item.is_a?(String) && Regexp.new(Hecks::Bluebook::PatternSubset.whole_string(pattern)).match?(item)
+
+          raise TypeMismatch,
+                RefusalWording.render_site("TypeMismatch", "pattern_mismatch",
+                                           type: value_object.hecks_name, field: attribute.name,
+                                           pattern: pattern, offered: Rendering.describe(item))
+        end
+      end
+    end
+  end
+end