schema-model 0.7.4 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f273128aa733d5737e486345a39b1c59f5af1bf3babea0917bc8d6e6a44707c8
-  data.tar.gz: 393e5e391cde21e5288da99d4321bb619f370d1a937052f427e32f570facd68e
+  metadata.gz: f672bab800b79f5e9a8b390268466caaf7a42822b0b0632f023f6539fbae48aa
+  data.tar.gz: 5486532778b3a246d66c0c2350586fd77ebf9955ef311a719c5053d656afe0be
 SHA512:
-  metadata.gz: df5f93d0615667c6bb455bf920a08f44507f59eec3031cde8fb5e73eb99403738d0d3afe447d53a4a39d1dd67df7e8d3ff2f375810580f26a5804851289c8016
-  data.tar.gz: 01eb576246b0efa42c3935c0cb1c73038b350062053a767a815c8eaced1b4e1aec3b8c79fca3c32d2810fb26618b8eda397c4eb6b1ecc08e6baf79ff5467f138
+  metadata.gz: ca482dfd23e73cea044bf572e819864415ee68768cdb0b98a756e92fbb06c2d800b7cdd6c2afde4d5c77559d226a7e3cf681f4043a17b118c17ed24fee0cdb9c
+  data.tar.gz: f555174a32c7adbe3b713bb726038f325168f07820d6309479be0715af91bb5e684d73d51466a0f71cc806ecd7ca98f2006bf8820008c126ee4f25f220ffdcde

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.8.0](https://github.com/dougyouch/schema/compare/v0.7.4...v0.8.0) (2026-10-04)
+
+
+### ⚠ BREAKING CHANGES
+
+* **model:** unrecognized boolean strings, and dates that aren't ISO 8601, are now invalid instead of false or a guessed date; blank strings parse to nil instead of being invalid (integer, float, date, time) or false (boolean); with ActiveModel, parsing_errors messages are readable text such as "is invalid" instead of codes such as "invalid"; capture_unknown_attributes= now changes nested association classes; and models compare by value with ==.
+
+### Features
+
+* **model:** stricter parsing, readable parsing errors and model helpers ([9267d77](https://github.com/dougyouch/schema/commit/9267d770f79b260bae2b3890f31f583e1684bdbe))
+
 ## [0.7.4](https://github.com/dougyouch/schema/compare/v0.7.3...v0.7.4) (2026-10-04)
 
 

data/README.md

@@ -8,7 +8,7 @@ A powerful Ruby gem for data transformation, validation, and type safety. Schema
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Requires Ruby 3.2 or newer. Add this line to your application's Gemfile:
 
 ```ruby
 gem 'schema-model'
@@ -65,17 +65,21 @@ user.tags          # => ["ruby", "rails", "developer"]
 
 ```ruby
 attribute :name, :string              # String values
-attribute :count, :integer            # Integer values (parses "123" to 123)
-attribute :price, :float              # Float values (parses "9.99" to 9.99)
-attribute :active, :boolean           # true for 1, t, true, on, y, yes (any case); other strings are false; numbers are true unless 0
+attribute :count, :integer            # Integer values (parses "123", " 123 " and "0123" to 123)
+attribute :price, :float              # Float values (parses "9.99" to 9.99, also "1e+5")
+attribute :active, :boolean           # see below
 attribute :notes, :string_or_nil      # String, but returns nil if empty
 ```
 
+Booleans accept `1, t, true, on, y, yes` as `true` and `0, f, false, off, n, no` as `false` (any case). Any other string is an `invalid` parsing error, and numbers are `true` unless they're 0.
+
+For `:integer`, `:float`, `:boolean`, `:date`, `:time`, `:american_date` and `:american_time`, strings are stripped first and a blank string parses to `nil` without an error, so empty CSV cells don't count as bad input.
+
 ### Date and Time Types
 
 ```ruby
-attribute :created_at, :time          # ISO 8601 format (Time.xmlschema)
-attribute :birth_date, :date          # Date.parse format
+attribute :created_at, :time          # ISO 8601 date and time (Time.xmlschema)
+attribute :birth_date, :date          # ISO 8601 (Date.iso8601), e.g. "2024-01-31"; free text like "May 1" is invalid
 attribute :us_date, :american_date    # MM/DD/YYYY format
 attribute :us_time, :american_time    # MM/DD/YYYY HH:MM:SS format
 ```
@@ -90,6 +94,8 @@ attribute :metadata, :hash                        # Hash/dictionary values
 attribute :config, :json                          # Parse JSON strings
 ```
 
+Each type `:foo` is parsed by a `parse_foo` method, so you can add types by defining that method on the model or in a module you `schema_include`. Setting a value on an attribute whose type has no parser raises `Schema::UnknownTypeError` naming the attribute and the missing method.
+
 ## Attribute Options
 
 ### Aliases
@@ -293,7 +299,7 @@ end
 
 ### Parsing Errors vs Validation Errors
 
-Parsing errors and validation errors are tracked separately. `valid?` only runs validations, so check `parsed?` too (or call `valid!`, which checks both).
+Parsing errors and validation errors are tracked separately. `valid?` only runs validations, so check `parsed?` too (or call `valid!`, which checks both). `parsed?` and `parsed!` are available on every `Schema::Model`, not only with ActiveModel.
 
 ```ruby
 user = UserSchema.from_hash(name: 'John', email: 'john@example.com', age: 'not-a-number')
@@ -308,6 +314,22 @@ user.valid?                 # => true (age is nil, which allow_nil permits)
 user.errors.full_messages   # => []
 ```
 
+With `Schema::All` (or `Schema::ActiveModelValidations`), `parsing_errors` is an `ActiveModel::Errors` with readable messages:
+
+```ruby
+user.parsing_errors.full_messages  # => ["Age is invalid"]
+```
+
+| Code | Message | I18n key |
+|---|---|---|
+| `invalid` | is invalid | `schema.parsing_errors.invalid` |
+| `incompatible` | is an incompatible type | `schema.parsing_errors.incompatible` |
+| `unknown` | has an unknown type | `schema.parsing_errors.unknown` |
+| `unknown_attribute` | is an unknown attribute | `schema.parsing_errors.unknown_attribute` |
+| `unhandled_type` | is an unhandled type | `schema.parsing_errors.unhandled_type` |
+
+A plain `Schema::Model` uses `Schema::Errors`, which stores the codes themselves (`user.parsing_errors[:age] # => ["invalid"]`).
+
 ### Validating Nested Schemas
 
 `validates ..., schema: true` (`SchemaValidator`) marks the parent invalid when a nested model, or any model in a has-many list, is invalid:
@@ -349,13 +371,13 @@ By default, unknown attributes are captured as parsing errors:
 
 ```ruby
 user = UserSchema.from_hash(name: 'John', unknown_field: 'value')
-user.parsing_errors[:unknown_field]  # => ["unknown_attribute"]
+user.parsing_errors[:unknown_field]  # => ["is an unknown attribute"]
 
 # Disable this behavior
 UserSchema.capture_unknown_attributes = false
 ```
 
-The setting is per class. Nested association classes keep their own setting, so an unknown key inside a nested hash still makes the parent record an `invalid` error for that association.
+The setting also applies to nested association classes, including ones declared after it is set.
 
 ## Serialization
 
@@ -380,6 +402,23 @@ user.as_json(select_filter: ->(name, value, opts) { name == :name })
 user.as_json(reject_filter: ->(name, value, opts) { value.nil? })
 ```
 
+### Comparing, Inspecting and Copying
+
+```ruby
+a = ContactSchema.from_hash(name: 'John')
+b = ContactSchema.from_hash('name' => 'John')
+
+a == b               # => true (same class and attribute values, nested models included)
+a.attribute_values   # => { name: "John", email: nil }
+a.inspect            # => #<ContactSchema name: "John"> (only attributes that were set)
+
+copy = a.deep_dup    # copies nested models, arrays, hashes, strings and parsing errors
+copy.name << '!'
+a.name               # => "John"
+```
+
+`dup` is Ruby's shallow copy, so nested models are shared with the original.
+
 ## Protecting Fields with skip_fields
 
 Prevent certain fields from being set by user input:
@@ -446,6 +485,8 @@ end
 UserSchema.to_headers  # => [..., "phones[1].number", "phones[2].number", "phones[3].number"]
 ```
 
+`to_a` writes at most `size` entries: a model with more entries than that has the extra ones left out of the array, with no error, so pick a `size` large enough for your data.
+
 ### Schema::CSVParser
 
 `Schema::CSVParser` is a class that reads rows from a `CSV` object into models. The model needs `Schema::ArrayHeaders` and `Schema::Arrays`. Pass a plain `CSV` (not one created with `headers: true`); the first row is used as the headers unless you pass them in:

data/lib/schema/active_model_parsing_errors.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module Schema
+  # Schema::ActiveModelParsingErrors turns parsing error codes into readable messages,
+  # e.g. "Age is invalid" instead of "Age invalid". Override them with I18n keys under schema.parsing_errors.
+  class ActiveModelParsingErrors < ActiveModel::Errors
+    MESSAGES = {
+      ::Schema::ParsingErrors::INVALID => 'is invalid',
+      ::Schema::ParsingErrors::INCOMPATIBLE => 'is an incompatible type',
+      ::Schema::ParsingErrors::UNKNOWN => 'has an unknown type',
+      ::Schema::ParsingErrors::UNKNOWN_ATTRIBUTE => 'is an unknown attribute',
+      ::Schema::ParsingErrors::UNHANDLED_TYPE => 'is an unhandled type'
+    }.freeze
+
+    # parsing error keys (e.g. "items:0" or an unknown key) often aren't attributes on the model,
+    # so codes are added as message strings rather than ActiveModel error types
+    def add(attribute, type = :invalid, **)
+      super(attribute, message_for(type), **)
+    end
+
+    private
+
+    def message_for(type)
+      return type unless MESSAGES.key?(type)
+
+      I18n.t("schema.parsing_errors.#{type}", default: MESSAGES[type])
+    end
+  end
+end

data/lib/schema/active_model_validations.rb

@@ -3,7 +3,7 @@
 require 'active_model'
 
 module Schema
-  # Schema::Model adds schema building methods to a class, uses ActiveModel::Errors for parsing_errors
+  # Schema::ActiveModelValidations adds ActiveModel validations, and readable ActiveModel::Errors for parsing_errors
   module ActiveModelValidations
     def self.included(base)
       base.schema_include ::ActiveModel::Validations
@@ -28,21 +28,7 @@ module Schema
     # no-doc
     module OverrideParsingErrors
       def parsing_errors
-        @parsing_errors ||= ActiveModel::Errors.new(self)
-      end
-
-      def parsed?
-        parsing_errors.empty?
-      end
-
-      def parsed!
-        return if parsed?
-
-        raise ParsingException.new(
-          "schema parsing failed for attributes #{parsing_errors.errors.map(&:attribute).join(', ')}",
-          self,
-          parsing_errors
-        )
+        @parsing_errors ||= ActiveModelParsingErrors.new(self)
       end
     end
   end

data/lib/schema/attribute_values.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Schema
+  # Schema::AttributeValues compares and inspects models by their attribute values
+  module AttributeValues
+    # every attribute (aliases excluded) and its current value, defaults included
+    def attribute_values
+      self.class.schema.each_with_object({}) do |(field_name, field_options), values|
+        next if field_options[:alias_of]
+
+        values[field_name] = public_send(field_options[:getter])
+      end
+    end
+
+    def ==(other)
+      other.instance_of?(self.class) && other.attribute_values == attribute_values
+    end
+
+    # lists the attributes that were set, e.g. #<UserSchema name: "Joe", age: 30>
+    def inspect
+      details = set_field_options.map do |field_options|
+        "#{field_options[:name]}: #{public_send(field_options[:getter]).inspect}"
+      end
+      "#<#{self.class.name || self.class}#{" #{details.join(', ')}" unless details.empty?}>"
+    end
+
+    private
+
+    def set_field_options
+      self.class.schema.each_value.select do |field_options|
+        !field_options[:alias_of] && instance_variable_defined?(field_options[:instance_variable])
+      end
+    end
+  end
+end

data/lib/schema/deep_copy.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Schema
+  # Schema::DeepCopy copies a model along with its nested models, collections and parsing errors
+  module DeepCopy
+    def deep_dup
+      copy = dup
+      copy.copy_attribute_values_from(self)
+      copy.copy_parsing_errors_from(self)
+      copy
+    end
+
+    protected
+
+    def copy_attribute_values_from(source)
+      self.class.schema.each_value do |field_options|
+        next if field_options[:alias_of]
+
+        ivar = field_options[:instance_variable]
+        next unless source.instance_variable_defined?(ivar)
+
+        instance_variable_set(ivar, ::Schema::Utils.deep_dup_value(source.instance_variable_get(ivar)))
+      end
+    end
+
+    def copy_parsing_errors_from(source)
+      @parsing_errors = nil
+      ::Schema::Utils.parsing_error_pairs(source.parsing_errors).each do |attribute, message|
+        parsing_errors.add(attribute, message)
+      end
+    end
+  end
+end

data/lib/schema/errors.rb

@@ -24,5 +24,9 @@ module Schema
     def empty?
       @errors.empty?
     end
+
+    def attribute_names
+      @errors.keys
+    end
   end
 end

data/lib/schema/model.rb

@@ -8,6 +8,9 @@ module Schema
     def self.included(base)
       base.extend InheritanceHelper::Methods
       base.send(:include, Schema::Parsers::Common)
+      base.send(:include, Schema::ParsingStatus)
+      base.send(:include, Schema::AttributeValues)
+      base.send(:include, Schema::DeepCopy)
       base.extend ClassMethods
     end
 
@@ -45,10 +48,17 @@ module Schema
         }.freeze
       end
 
+      # applies to nested association classes too, like schema_include
       def capture_unknown_attributes=(v)
         config = schema_config.dup
         config[:capture_unknown_attributes] = v
         redefine_class_method(:schema_config, config.freeze)
+
+        schema.each_value do |field_options|
+          next unless field_options[:association]
+
+          const_get(field_options[:class_name]).capture_unknown_attributes = v
+        end
       end
 
       def capture_unknown_attributes?
@@ -87,6 +97,7 @@ module Schema
       end
 
       def add_attribute_methods(name, options)
+        parser_check = parser_check_code(name, options)
         class_eval(
           <<-STR, __FILE__, __LINE__ + 1
   def #{options[:getter]}
@@ -94,6 +105,7 @@ module Schema
   end
 
   def #{options[:setter]}(v)
+    #{parser_check}
     #{options[:instance_variable]} = #{options[:parser]}(#{name.inspect}, parsing_errors, v)
   end
 
@@ -104,6 +116,13 @@ module Schema
         )
       end
 
+      # a parser that isn't defined yet may come from a module included later, so it's checked when a value is set
+      def parser_check_code(name, options)
+        return if method_defined?(options[:parser])
+
+        "::Schema::Utils.check_parser!(self, #{options[:parser].inspect}, #{name.inspect}, #{options[:type].inspect})"
+      end
+
       def add_aliases(name, options)
         return unless options[:aliases]
 

data/lib/schema/parsers/american.rb

@@ -6,6 +6,8 @@ module Schema
   module Parsers
     # Schema::Parsers::American parses dates and times in American format
     module American
+      include StringValue
+
       DATE_FORMAT = '%m/%d/%Y'
       TIME_FORMAT = '%m/%d/%Y %H:%M:%S'
 
@@ -16,12 +18,7 @@ module Schema
         when Time
           value.to_date
         when String
-          begin
-            Date.strptime(value, DATE_FORMAT)
-          rescue ArgumentError
-            parsing_errors.add(field_name, ::Schema::ParsingErrors::INVALID)
-            nil
-          end
+          parse_string_value(field_name, parsing_errors, value) { |str| Date.strptime(str, DATE_FORMAT) }
         when nil
           nil
         else
@@ -37,12 +34,7 @@ module Schema
         when Date
           value.to_time
         when String
-          begin
-            Time.strptime(value, TIME_FORMAT)
-          rescue ArgumentError
-            parsing_errors.add(field_name, ::Schema::ParsingErrors::INVALID)
-            nil
-          end
+          parse_string_value(field_name, parsing_errors, value) { |str| Time.strptime(str, TIME_FORMAT) }
         when nil
           nil
         else

data/lib/schema/parsers/array.rb

@@ -35,6 +35,7 @@ module Schema
         return data unless (data_type = schema_options[:data_type])
 
         parser_method = "parse_#{data_type}"
+        ::Schema::Utils.check_parser!(model, parser_method, field_name, data_type)
         data.each_with_index.map do |datum, idx|
           model.send(parser_method, "#{field_name}:#{idx}", parsing_errors, datum)
         end

data/lib/schema/parsers/common.rb

@@ -6,20 +6,24 @@ module Schema
   module Parsers
     # Schema::Parsers::Common are parser methods for basic types
     module Common
-      INTEGER_REGEX = /\A[-+]?(?:[1-9]\d*|0)(?:\.0+)?\z/
-      FLOAT_REGEX = /\A[-+]?(?:[1-9]\d*|0)(?:\.\d+)?([Ee][-+]?\d+)?\z/
-      BOOLEAN_REGEX = /\A(?:1|t|true|on|y|yes)\z/i
+      include StringValue
+
+      # strings are stripped first; a blank string parses to nil without an error
+      INTEGER_REGEX = /\A[-+]?\d+(?:\.0+)?\z/
+      FLOAT_REGEX = /\A[-+]?\d+(?:\.\d+)?([Ee][-+]?\d+)?\z/
+      # matched case-insensitively; any other string is invalid
+      BOOLEAN_STRINGS = {
+        '1' => true, 't' => true, 'true' => true, 'on' => true, 'y' => true, 'yes' => true,
+        '0' => false, 'f' => false, 'false' => false, 'off' => false, 'n' => false, 'no' => false
+      }.freeze
 
       def parse_integer(field_name, parsing_errors, value)
         case value
         when Integer
           value
         when String
-          if INTEGER_REGEX.match(value)
-            value.to_i
-          else
-            parsing_errors.add(field_name, ::Schema::ParsingErrors::INVALID)
-            nil
+          parse_string_value(field_name, parsing_errors, value) do |str|
+            str.to_i if INTEGER_REGEX.match?(str)
           end
         when Float
           parse_float_as_integer(field_name, parsing_errors, value)
@@ -77,11 +81,8 @@ module Schema
         when Integer
           value.to_f
         when String
-          if FLOAT_REGEX.match(value)
-            Float(value)
-          else
-            parsing_errors.add(field_name, ::Schema::ParsingErrors::INVALID)
-            nil
+          parse_string_value(field_name, parsing_errors, value) do |str|
+            Float(str) if FLOAT_REGEX.match?(str)
           end
         when nil
           nil
@@ -98,12 +99,7 @@ module Schema
         when Date
           value.to_time
         when String
-          begin
-            Time.xmlschema(value)
-          rescue ArgumentError
-            parsing_errors.add(field_name, ::Schema::ParsingErrors::INVALID)
-            nil
-          end
+          parse_string_value(field_name, parsing_errors, value) { |str| Time.xmlschema(str) }
         when nil
           nil
         else
@@ -119,12 +115,7 @@ module Schema
         when Time
           value.to_date
         when String
-          begin
-            Date.parse(value)
-          rescue ArgumentError
-            parsing_errors.add(field_name, ::Schema::ParsingErrors::INVALID)
-            nil
-          end
+          parse_string_value(field_name, parsing_errors, value) { |str| Date.iso8601(str) }
         when nil
           nil
         else
@@ -140,7 +131,7 @@ module Schema
         when Integer, Float
           value != 0
         when String
-          BOOLEAN_REGEX.match?(value)
+          parse_string_value(field_name, parsing_errors, value) { |str| BOOLEAN_STRINGS[str.downcase] }
         when nil
           nil
         else

data/lib/schema/parsers/string_value.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Schema
+  module Parsers
+    # Schema::Parsers::StringValue is the shared string handling for parsers
+    module StringValue
+      # strips the string, returns nil when it's blank, and otherwise yields it; a nil result
+      # or an ArgumentError (e.g. Date::Error) from the block is recorded as invalid
+      def parse_string_value(field_name, parsing_errors, value)
+        str = value.strip
+        return nil if str.empty?
+
+        result = begin
+          yield str
+        rescue ArgumentError
+          nil
+        end
+        parsing_errors.add(field_name, ::Schema::ParsingErrors::INVALID) if result.nil?
+        result
+      end
+    end
+  end
+end

data/lib/schema/parsing_status.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Schema
+  # Schema::ParsingStatus reports whether a model parsed cleanly, and raises at an explicit boundary
+  module ParsingStatus
+    def parsed?
+      parsing_errors.empty?
+    end
+
+    def parsed!
+      return if parsed?
+
+      raise ParsingException.new(
+        "schema parsing failed for attributes #{parsing_errors.attribute_names.join(', ')}",
+        self,
+        parsing_errors
+      )
+    end
+  end
+end

data/lib/schema/utils.rb

@@ -5,6 +5,14 @@ module Schema
   module Utils
     module_function
 
+    def check_parser!(model, parser, field_name, type)
+      return if model.respond_to?(parser)
+
+      raise ::Schema::UnknownTypeError,
+            "unknown type #{type.inspect} for #{model.class.name || model.class}##{field_name}: " \
+            "no #{parser} method (schema_include the parser module that defines it)"
+    end
+
     def classify_name(name)
       name.gsub(/[^\da-z_-]/, '').gsub(/(^.|[_|-].)/) { |m| m[-1].upcase }
     end
@@ -14,6 +22,7 @@ module Schema
       kls = Class.new(options[:base_class] || Object)
       kls = base_schema_class.const_set(options[:class_name], kls)
       include_schema_modules(kls, base_schema_class.schema_config) unless options[:base_class]
+      kls.capture_unknown_attributes = base_schema_class.capture_unknown_attributes?
       kls
     end
 
@@ -56,6 +65,24 @@ module Schema
       kls.send(:include, ::Schema::Associations::DynamicTypes)
     end
 
+    # copies nested models and collections so the copy can be changed without touching the original
+    def deep_dup_value(value)
+      case value
+      when ::Schema::Model then value.deep_dup
+      when ::Array then value.map { |element| deep_dup_value(element) }
+      when ::Hash then value.to_h { |key, element| [key, deep_dup_value(element)] }
+      when ::String then value.frozen? ? value : value.dup
+      else value
+      end
+    end
+
+    # [attribute, message] pairs from Schema::Errors or ActiveModel::Errors
+    def parsing_error_pairs(errors)
+      return errors.map { |error| [error.attribute, error.message] } unless errors.is_a?(::Schema::Errors)
+
+      errors.errors.flat_map { |attribute, messages| messages.map { |message| [attribute, message] } }
+    end
+
     # each call gets its own copy so callers can't mutate the shared default
     def copy_default(value)
       return value if value.frozen?

data/lib/schema/version.rb

@@ -2,5 +2,5 @@
 
 module Schema
   # Gem version, bumped by release-please
-  VERSION = '0.7.4'
+  VERSION = '0.8.0'
 end

data/lib/schema-model.rb

@@ -18,14 +18,21 @@ module Schema
   class ParsingException < SchemaException; end
   class ValidationException < SchemaException; end
 
+  # raised when a value is assigned to an attribute whose type has no parse_<type> method
+  class UnknownTypeError < StandardError; end
+
   autoload :ActiveModelValidations, 'schema/active_model_validations'
   autoload :All, 'schema/all'
+  autoload :ActiveModelParsingErrors, 'schema/active_model_parsing_errors'
   autoload :ArrayHeaders, 'schema/array_headers'
   autoload :Arrays, 'schema/arrays'
+  autoload :AttributeValues, 'schema/attribute_values'
   autoload :CSVParser, 'schema/csv_parser'
+  autoload :DeepCopy, 'schema/deep_copy'
   autoload :Errors, 'schema/errors'
   autoload :Model, 'schema/model'
   autoload :ParsingErrors, 'schema/parsing_errors'
+  autoload :ParsingStatus, 'schema/parsing_status'
   autoload :Utils, 'schema/utils'
 
   # Schema::Parsers are used to convert values into the correct data type
@@ -35,6 +42,7 @@ module Schema
     autoload :Common, 'schema/parsers/common'
     autoload :Hash, 'schema/parsers/hash'
     autoload :Json, 'schema/parsers/json'
+    autoload :StringValue, 'schema/parsers/string_value'
   end
 
   # Schema::Associations mange the associations between schema models