lutaml-model 0.8.33 → 0.8.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 559deafaf5121c17a2703c362f355feb440380ba2f80fbb0ff9afa5440995841
-  data.tar.gz: 48ea3bfb26265e940cc54d88e49ce60b54887b7a52372e7e174284625185f88a
+  metadata.gz: 65361e31ef80bfd3600c0bc3ea4241c2b9a9e9d227b1772b9bd23f3324e92ad7
+  data.tar.gz: da258d5127e14511cd77bd1ca44e6ad1647aaaf445cc14a92102096f180a82a3
 SHA512:
-  metadata.gz: a28e6ef895329e27e3796266c197b700a391df1aa0b8c8cdf4ed89c3c0e4016d876c92053481a2b6f118817327213445e88e7f9ea9c4f3e7c2b5d3b8465052b1
-  data.tar.gz: e87f3702b6e783da4be97faeae5a7a0c572cd05995d4a7f15d73d9784d8ead92bddcb696c12c584b372ff603fb6a94dbfd1ef21eb63c33bfd4da69569ecd9349
+  metadata.gz: 2d5ece44cac496100e30c2d4f3c5ca3934f656bd81352ee9215e57c2a4b8563f0a7a8ae3c155909eaf132efcce992e1954731b89cd79808fcf8c948555b06abd
+  data.tar.gz: 9db5fc0ac630ad33336250d06a953357d8a2d60bb0f0cae037d5a2d9d6cc12da2fca2937aa5b73c5b490852381995937fad226049e51fd167906e900084fa837

data/.rubocop.yml

@@ -32,6 +32,11 @@ RSpec/EmptyExampleGroup:
   Exclude:
     - 'spec/lutaml/jsonld/transform_spec.rb'
 
+# emits_nothing_extra carries the expectations for these examples.
+RSpec/NoExpectationExample:
+  AllowedPatterns:
+    - '^emits_nothing_extra'
+
 RSpec/NamedSubject:
   inherit_mode:
     merge:

data/Gemfile

@@ -20,6 +20,10 @@ gem "bigdecimal"
 gem "canon" # , path: "../canon"
 gem "json-ld"
 gem "liquid", "~> 5"
+# lutaml-store depends on lutaml-model, so it can never be a gemspec dependency.
+# 0.2.4 relaxes rubyzip to >= 2.3, < 4 (lutaml/lutaml-store#5), co-resolving
+# with lutaml-model's rubyzip ~> 3.4 CVE floor.
+gem "lutaml-store", "~> 0.2.4"
 gem "multi_json"
 gem "nokogiri"
 gem "oj"

data/README.adoc

@@ -67,6 +67,7 @@ link:docs/migration-guides/0-1-0-migrate-from-shale.adoc[Migrating from Shale to
 * Reusable XML mapping classes for sharing mappings across models
 * RDF namespace classes and JSON-LD/Turtle format adapters for Linked Data serialization
 * Consolidation mapping: group sibling XML elements into structured model instances (see <<consolidation-mapping>>)
+* Opt-in caching of repeated serialization/deserialization, backed by the `lutaml-store` gem (see <<conversion-caching>>)
 * Document-level validation framework with composable rules, profiles, and remediation (see <<document-validation-framework>>)
 
 
@@ -16547,6 +16548,44 @@ raised to indicate that the input format is malformed and cannot be parsed.
 
 
 
+[[conversion-caching]]
+== Conversion caching
+
+Repeated serialization/deserialization of the same content can be cached.
+A model class opts in with `cache_conversions`; the application provides the
+storage backend by adding the
+link:https://github.com/lutaml/lutaml-store[lutaml-store] gem to its
+`Gemfile` (lutaml-model itself does not depend on it). Without both, nothing
+changes.
+
+[source,ruby]
+----
+require "lutaml/store"
+
+class Invoice < Lutaml::Model::Serializable
+  attribute :number, :string
+
+  cache_conversions
+
+  xml do
+    root "invoice"
+    map_element "number", to: :number
+  end
+end
+
+Invoice.from_xml(xml) # parsed once
+Invoice.from_xml(xml) # the same instance, served from the cache
+----
+
+When `Lutaml::Store` is loaded, a memory-backed `Lutaml::Store::BasicStore`
+is created automatically on first use. Assign
+`Lutaml::Model::Config.conversion_cache` to use a custom backend (e.g.
+`Lutaml::Store::CacheStore` with TTL/LRU, or any object responding to
+`get`/`set`), or set it to `false` to disable caching globally.
+
+See link:docs/conversion_caching.adoc[Conversion caching] for activation
+rules, backend configuration, cache-key semantics, and limitations.
+
 [[custom-adapters]]
 == Custom serialization adapters
 

data/docs/conversion_caching.adoc

@@ -0,0 +1,143 @@
+= LutaML Model — Conversion caching
+:doctype: book
+
+== Overview
+
+LutaML Model can cache the results of format conversions to avoid redundant
+processing when the same content is converted repeatedly:
+
+- *Deserialization* (`from_xml`, `from_json`, ...): repeated parsing of the
+  same input string returns the cached model instance instead of re-parsing.
+- *Serialization* (`to_xml`, `to_json`, ...): repeated serialization of an
+  unchanged instance returns the cached output string.
+
+Caching is opt-in twice over: a model class declares it, and the application
+provides a storage backend (the
+link:https://github.com/lutaml/lutaml-store[lutaml-store] gem, or any
+compatible object). Without both, nothing changes — classes that do not opt
+in are never cached, and `cache_conversions` without a backend is a no-op.
+
+== Quick start
+
+Add the backend gem to your application's `Gemfile` (lutaml-model itself does
+not depend on it):
+
+[source,ruby]
+----
+gem "lutaml-store"
+----
+
+Require it, and declare caching on the models that need it:
+
+[source,ruby]
+----
+require "lutaml/model"
+require "lutaml/store"
+
+class Invoice < Lutaml::Model::Serializable
+  attribute :number, :string
+  attribute :amount, :decimal
+
+  cache_conversions
+
+  xml do
+    root "invoice"
+    map_element "number", to: :number
+    map_element "amount", to: :amount
+  end
+end
+
+Invoice.from_xml(xml) # parsed once
+Invoice.from_xml(xml) # the same instance, served from the cache
+
+invoice = Invoice.new(number: "42", amount: 10)
+invoice.to_xml # serialized once
+invoice.to_xml # served from the cache
+----
+
+That is all: when `Lutaml::Store` is loaded, the first conversion call on an
+opted-in class lazily creates a default memory-backed
+`Lutaml::Store::BasicStore` and caching is active from then on.
+
+== Activation rules
+
+[cols="1,1,1", options="header"]
+|===
+| Class declares `cache_conversions` | Backend available | Result
+
+| no  | —                              | never cached
+| yes | no store loaded or assigned    | no-op (works as without caching)
+| yes | lutaml-store loaded            | cached via auto-created memory `BasicStore`
+| yes | store assigned via config      | cached via that store
+| any | `Config.conversion_cache = false` | caching disabled globally
+|===
+
+Subclasses inherit the declaration:
+
+[source,ruby]
+----
+class SignedInvoice < Invoice
+end
+
+SignedInvoice.conversion_caching_enabled? # => true
+----
+
+== Configuring the backend
+
+The default (memory `BasicStore`, unbounded) suits scripts and CLI runs. For
+long-running processes, assign a bounded or custom store:
+
+[source,ruby]
+----
+Lutaml::Model::Config.configure do |config|
+  # TTL + LRU eviction; suitable for to_* output strings.
+  config.conversion_cache = Lutaml::Store::CacheStore.new(
+    adapter: { type: :memory },
+    default_ttl: 600,
+    max_size: 1000,
+  )
+end
+
+# Disable caching entirely (even with lutaml-store loaded):
+Lutaml::Model::Config.conversion_cache = false
+
+# Return to auto-detection:
+Lutaml::Model::Config.conversion_cache = nil
+----
+
+Any object responding to `get(key)` and `set(key, value)` works as a backend.
+
+NOTE: `Lutaml::Store::CacheStore` JSON-marshals stored values, so it
+accelerates serialization output (strings survive the round-trip) while
+deserialized model instances are recomputed on every call — correct, just
+uncached. Use `BasicStore` to cache both directions.
+
+== Semantics and guarantees
+
+Correctness first:: Cache keys are content-derived — they digest the input
+string (deserialization) or the instance state (serialization), plus the
+class, format, register, resolved adapter, and any conversion options.
+Mutating an instance changes its key, so stale output is never served.
+Anything that cannot be keyed safely bypasses the cache and is computed
+normally rather than risking a wrong result.
+
+Shared instances:: Repeated deserialization of identical input returns the
+*same* object — across callers and threads. Treat cached results as
+read-only. If your code mutates parsed results, do not declare
+`cache_conversions` on that class.
+
+What bypasses the cache:: Non-`String` inputs (`Pathname`, `IO` — the content
+lives elsewhere); non-`Hash` options (e.g. the generator state objects Ruby's
+JSON/YAML protocols pass); instance graphs `Marshal` cannot digest — notably,
+instances parsed from XML retain native parser nodes for round-trip fidelity
+and therefore skip serialization caching (programmatically built instances
+cache fully); and any environment without native `Marshal`/`Digest` (Opal).
+
+Invalidation:: Entirely the store's concern — TTL, eviction, persistence, and
+clearing belong to the backend you configured. If you mutate a register's
+mappings at runtime, clear or replace the store afterwards; structural
+changes are not propagated automatically.
+
+Errors:: Backend exceptions propagate unchanged so operational problems stay
+visible; malformed input still raises
+`Lutaml::Model::InvalidFormatError` exactly as without caching.

data/lib/compat/opal/lutaml_model_boot.rb

@@ -78,6 +78,7 @@ require "lutaml/model/organization"
 require "lutaml/model/register"
 require "lutaml/model/registrable"
 require "lutaml/model/render_policy"
+require "lutaml/model/restriction_validation"
 require "lutaml/model/runtime_compatibility"
 require "lutaml/model/schema"
 require "lutaml/model/schema_location"
@@ -235,6 +236,7 @@ require "lutaml/model/error/collection_count_out_of_range_error"
 require "lutaml/model/error/collection_true_missing_error"
 require "lutaml/model/error/element_count_out_of_range_error"
 require "lutaml/model/error/format_adapter_not_specified_error"
+require "lutaml/model/error/fraction_digits_error"
 require "lutaml/model/error/import_model_with_root_error"
 require "lutaml/model/error/incorrect_mapping_argument_error"
 require "lutaml/model/error/incorrect_sequence_error"
@@ -244,12 +246,19 @@ require "lutaml/model/error/invalid_attribute_type_error"
 require "lutaml/model/error/invalid_choice_range_error"
 require "lutaml/model/error/invalid_format_error"
 require "lutaml/model/error/invalid_value_error"
+require "lutaml/model/error/length_error"
 require "lutaml/model/error/liquid_class_not_found_error"
 require "lutaml/model/error/liquid_drop_already_registered_error"
 require "lutaml/model/error/liquid_not_enabled_error"
 require "lutaml/model/error/mapping_already_exists_error"
 require "lutaml/model/error/mapping_attribute_missing_error"
 require "lutaml/model/error/mapping_attribute_type_error"
+require "lutaml/model/error/max_exclusive_error"
+require "lutaml/model/error/max_inclusive_error"
+require "lutaml/model/error/max_length_error"
+require "lutaml/model/error/min_exclusive_error"
+require "lutaml/model/error/min_inclusive_error"
+require "lutaml/model/error/min_length_error"
 require "lutaml/model/error/mixed_content_collection_error"
 require "lutaml/model/error/multiple_mappings_error"
 require "lutaml/model/error/no_attributes_defined_liquid_error"
@@ -260,9 +269,11 @@ require "lutaml/model/error/ordered_content_mapping_error"
 require "lutaml/model/error/pattern_not_matched_error"
 require "lutaml/model/error/polymorphic_error"
 require "lutaml/model/error/required_attribute_missing_error"
+require "lutaml/model/error/restriction_error"
 require "lutaml/model/error/reverse_transform_block_not_defined_error"
 require "lutaml/model/error/reverse_transformation_declaration_error"
 require "lutaml/model/error/sorting_configuration_conflict_error"
+require "lutaml/model/error/total_digits_error"
 require "lutaml/model/error/transform_block_not_defined_error"
 require "lutaml/model/error/type_error"
 require "lutaml/model/error/type_not_enabled_error"
@@ -304,6 +315,7 @@ require "lutaml/model/schema/templates"
 require "lutaml/model/schema/yaml_schema"
 require "lutaml/model/serialize/attribute_definition"
 require "lutaml/model/serialize/builder"
+require "lutaml/model/serialize/conversion_caching"
 require "lutaml/model/serialize/deserialization_context"
 require "lutaml/model/serialize/enum_handling"
 require "lutaml/model/serialize/format_conversion"
@@ -380,6 +392,7 @@ require "lutaml/xml/serialization/instance_methods"
 require "lutaml/xml/serialization/model_import_ext"
 require "lutaml/xml/transformation/custom_method_wrapper"
 require "lutaml/xml/transformation/element_builder"
+require "lutaml/xml/transformation/order_reconciler"
 require "lutaml/xml/transformation/ordered_applier"
 require "lutaml/xml/transformation/rule_applier"
 require "lutaml/xml/transformation/rule_compiler"
@@ -437,8 +450,10 @@ require "lutaml/key_value/adapter/yamls/transform"
 require "lutaml/model/error/register/not_registrable_class_error"
 require "lutaml/model/error/type/invalid_value_error"
 require "lutaml/model/error/type/max_bound_error"
+require "lutaml/model/error/type/max_exclusive_error"
 require "lutaml/model/error/type/max_length_error"
 require "lutaml/model/error/type/min_bound_error"
+require "lutaml/model/error/type/min_exclusive_error"
 require "lutaml/model/error/type/min_length_error"
 require "lutaml/model/error/type/pattern_not_matched_error"
 require "lutaml/model/schema/decorators/attribute"

data/lib/lutaml/model/attribute.rb

@@ -7,6 +7,7 @@ module Lutaml
 
       include CollectionHandler
       include DeepDupable
+      include RestrictionValidation
 
       ALLOWED_OPTIONS = %i[
         raw
@@ -29,6 +30,11 @@ module Lutaml
         ref_key_attribute
         xsd_type
         union_member_types
+        min
+        max
+        signed
+        min_length
+        max_length
       ].freeze
 
       # Per-type-class memo of the custom from_xml/from_json probe used by #cast.
@@ -344,6 +350,32 @@ module Lutaml
         value.map { |v| cast_element(v, register) }
       end
 
+      # Cast the value a derived reader just recomputed.
+      #
+      # A derived attribute has no ivar and no writer. Its reader runs the
+      # source method and casts the result on every call, which makes the
+      # reader a casting entry point of its own — nothing a writer-side guard
+      # can reach. A collection still has to come back as a collection here,
+      # even when the source method returned nothing.
+      #
+      # @param value [Object] whatever the source method returned
+      # @param register [Symbol] register for type resolution
+      # @return [Object] the cast value, or an empty collection
+      def cast_derived(value, register)
+        return cast_element(value, register) unless collection?
+        return build_collection if no_data?(value)
+        return cast_value(value, register) if collection_instance?(value)
+        # A plain Array is a list of source elements even when the attribute
+        # declares its own collection class, which collection_instance? only
+        # recognises by that class. Without this it becomes one element whose
+        # value is the inspected Array.
+        if value.is_a?(::Array)
+          return build_collection(value.map { |v| cast_element(v, register) })
+        end
+
+        build_collection(cast_element(value, register))
+      end
+
       # Apply a value map to transform a value.
       #
       # value_map keys (:nil, :empty, :omitted) each map either to a symbolic
@@ -389,8 +421,32 @@ module Lutaml
         true
       end
 
+      # True when the value is "nothing arrived" rather than data.
+      #
+      # nil and the uninitialized sentinel both mean the source carried no
+      # value. Neither is something a type can be asked to turn into an
+      # instance.
+      #
+      # @param value [Object]
+      # @return [Boolean]
+      def no_data?(value)
+        value.nil? || Utils.uninitialized?(value)
+      end
+
       def cast_element(value, register)
+        # Resolve first: an undeclared type has to raise UnknownTypeError even
+        # when the value carries nothing, the way it did before the guard
+        # below existed.
         resolved_type = type(register)
+
+        # Casting is for data. Every built-in type already hands nil and the
+        # uninitialized sentinel straight back, so this changes nothing for
+        # them. A type with its own `self.cast` returns a real instance
+        # instead, and that instance becomes a value nobody wrote — a phantom
+        # element in the document, or a one-item collection the source never
+        # contained. `cast` below guards the format entry point the same way.
+        return value if no_data?(value)
+
         return cast_union(value, nil, register) if union?
         return resolved_type.new(value) if value.is_a?(::Hash) && !hash_type?
 
@@ -570,6 +626,7 @@ instance_object = nil)
                              register)
         end
         resolved_type = type(register)
+        validate_restriction_configuration!(resolved_type)
 
         # Shape before contents. An over-count is a cardinality violation, not
         # an enum or pattern one, and checking it first keeps those predicates
@@ -579,6 +636,8 @@ instance_object = nil)
           valid_pattern!(value, resolved_type) &&
           validate_polymorphic!(value, resolved_type) &&
           execute_validations!(value)
+
+        validate_restriction_values!(value, resolved_type)
       end
 
       # execute custom validations on the attribute value
@@ -724,6 +783,14 @@ instance_object = nil)
       end
 
       def cast(value, format, register, options = {})
+        # Same rule as cast_element, for the format entry point. from_json /
+        # from_yaml / from_toml / from_hash reach a missing key as nil, and a
+        # type with its own `self.cast` turns that nil into an instance the
+        # document never carried. Unlike cast_element this returns before
+        # resolving the type: resolution here depends on the format options
+        # below, and an undeclared type still raises through cast_element.
+        return value if no_data?(value)
+
         # Namespace-aware type resolution: use type_with_namespace if namespace_uri provided
         namespace_uri = options[:namespace_uri]
         resolved_type = if options[:resolved_type]
@@ -1122,6 +1189,28 @@ instance_object = nil)
           raise StandardError,
                 "Invalid option `initialize_empty` given without `collection: true` option"
         end
+
+        # Length facets are XSD nonNegativeInteger; reject a misconfigured
+        # type here so a String/Float/nil fails fast instead of raising an
+        # opaque TypeError later at `value.length >= min`.
+        %i[min_length max_length].each do |key|
+          next unless options.key?(key)
+
+          value = options[key]
+          next if value.is_a?(::Integer) && !value.negative?
+
+          raise ArgumentError,
+                "Invalid options for `#{name}`: " \
+                "`#{key}` must be a non-negative Integer, got #{value.inspect}"
+        end
+
+        # `signed` is true|false per issue #191; a non-boolean (e.g. "false")
+        # would silently read as signed, so reject it up front.
+        if options.key?(:signed) && ![true, false].include?(options[:signed])
+          raise ArgumentError,
+                "Invalid options for `#{name}`: " \
+                "`signed` must be true or false, got #{options[:signed].inspect}"
+        end
         true
       end
 

data/lib/lutaml/model/config.rb

@@ -92,6 +92,19 @@ module Lutaml
         end
       end
 
+      # Store used by classes that declare `cache_conversions`.
+      # Duck-typed: anything responding to #get(key) and #set(key, value).
+      # Defaults to a memory-backed Lutaml::Store::BasicStore when the
+      # lutaml-store gem is loaded; assign false to disable caching, or
+      # nil to return to auto-detection.
+      def conversion_cache
+        instance.conversion_cache
+      end
+
+      def conversion_cache=(store)
+        instance.conversion_cache = store
+      end
+
       def mappings_class_for(format)
         instance.mappings_class_for(format)
       end

data/lib/lutaml/model/configuration.rb

@@ -19,9 +19,11 @@ module Lutaml
       # compilable XML models (Leptris::XML::Descriptor walk). Opt-in
       # while the full semantics audit completes.
       attr_accessor :xml_plan_fast_path
+      attr_writer :conversion_cache
 
       def initialize
         @default_register = :default
+        @conversion_cache = nil
         @configured = false
         @xml_plan_fast_path = false
       end
@@ -32,6 +34,18 @@ module Lutaml
         self
       end
 
+      # Store consulted by classes that declare `cache_conversions`.
+      # Defaults to a memory-backed Lutaml::Store::BasicStore when the
+      # lutaml-store gem is loaded (the application opts in by adding it
+      # to its Gemfile and requiring "lutaml/store"). Assign any object
+      # responding to #get/#set to override, false to disable caching
+      # entirely, or nil to return to auto-detection.
+      def conversion_cache
+        return if @conversion_cache == false
+
+        @conversion_cache ||= default_conversion_cache
+      end
+
       def configured?
         @configured
       end
@@ -68,6 +82,7 @@ module Lutaml
       # Reset configuration to defaults
       def reset!
         @default_register = :default
+        @conversion_cache = nil
         @configured = false
         AdapterResolver.reset!
         AdapterScope.reset!
@@ -91,6 +106,14 @@ module Lutaml
       # Adapter accessors are defined dynamically by FormatRegistry.register
       # via define_method. These forward to AdapterResolver.
       # The generic set_adapter/get_adapter handle any format.
+
+      private
+
+      def default_conversion_cache
+        return unless defined?(::Lutaml::Store::BasicStore)
+
+        ::Lutaml::Store::BasicStore.new(adapter: { type: :memory })
+      end
     end
   end
 end

data/lib/lutaml/model/error/fraction_digits_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class FractionDigitsError < RestrictionError
+      def initialize(attr_name, value, fraction_digits)
+        @attr_name = attr_name
+        @value = value
+        @fraction_digits = fraction_digits
+
+        super()
+      end
+
+      def to_s
+        "#{@attr_name} (#{@value}) exceeds the maximum of " \
+          "#{@fraction_digits} fraction digits"
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/length_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class LengthError < RestrictionError
+      def initialize(attr_name, value, length)
+        @attr_name = attr_name
+        @value = value
+        @length = length
+
+        super()
+      end
+
+      def to_s
+        "#{@attr_name} length (#{@value.to_s.length}) must be exactly #{@length}"
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/max_exclusive_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class MaxExclusiveError < RestrictionError
+      def initialize(attr_name, value, max)
+        @attr_name = attr_name
+        @value = value
+        @max = max
+
+        super()
+      end
+
+      def to_s
+        "#{@attr_name} is `#{@value}`, must be less than #{@max}"
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/max_inclusive_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class MaxInclusiveError < RestrictionError
+      def initialize(attr_name, value, max)
+        @attr_name = attr_name
+        @value = value
+        @max = max
+
+        super()
+      end
+
+      def to_s
+        "#{@attr_name} is `#{@value}`, " \
+          "must be less than or equal to #{@max}"
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/max_length_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class MaxLengthError < RestrictionError
+      def initialize(attr_name, value, max_length)
+        @attr_name = attr_name
+        @value = value
+        @max_length = max_length
+
+        super()
+      end
+
+      def to_s
+        "#{@attr_name} length (#{@value.to_s.length}) is greater than " \
+          "the maximum allowed length #{@max_length}"
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/min_exclusive_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class MinExclusiveError < RestrictionError
+      def initialize(attr_name, value, min)
+        @attr_name = attr_name
+        @value = value
+        @min = min
+
+        super()
+      end
+
+      def to_s
+        "#{@attr_name} is `#{@value}`, must be greater than #{@min}"
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/min_inclusive_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class MinInclusiveError < RestrictionError
+      def initialize(attr_name, value, min)
+        @attr_name = attr_name
+        @value = value
+        @min = min
+
+        super()
+      end
+
+      def to_s
+        "#{@attr_name} is `#{@value}`, " \
+          "must be greater than or equal to #{@min}"
+      end
+    end
+  end
+end