schema-model 0.7.4 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f273128aa733d5737e486345a39b1c59f5af1bf3babea0917bc8d6e6a44707c8
-  data.tar.gz: 393e5e391cde21e5288da99d4321bb619f370d1a937052f427e32f570facd68e
+  metadata.gz: bd3614644a664aa647cc01d0ae8032a4f08d3523f0377b9e92f2c34597228815
+  data.tar.gz: 2f6c67150e5473230f8660cc21d7a7f26a2351dbc18f05b5754578c33cf521a3
 SHA512:
-  metadata.gz: df5f93d0615667c6bb455bf920a08f44507f59eec3031cde8fb5e73eb99403738d0d3afe447d53a4a39d1dd67df7e8d3ff2f375810580f26a5804851289c8016
-  data.tar.gz: 01eb576246b0efa42c3935c0cb1c73038b350062053a767a815c8eaced1b4e1aec3b8c79fca3c32d2810fb26618b8eda397c4eb6b1ecc08e6baf79ff5467f138
+  metadata.gz: 28674549ae35fc72fa413a59aa87a20d72ed752ee56688d657bb61911a8d032308b3fc44908bd4c2702f7b86c261519801bf86c7751cd3b40c9364fdfce32bb4
+  data.tar.gz: 5da6fcb9b0a79b21f926340d16486e4a5f8774725c1ca9cf3a58e3bbf996cee2856df0f84ad74acd4345dac1b999c1dcf09e41cfacf5f158819f13e78e432084

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.9.0](https://github.com/dougyouch/schema/compare/v0.8.0...v0.9.0) (2026-10-04)
+
+
+### Features
+
+* **model:** add set_attribute_values, parsed_and_valid? and full_error_messages ([0c8b922](https://github.com/dougyouch/schema/commit/0c8b922cb4417720b70d069a8c51fb80b3b1c644))
+
+
+### Bug Fixes
+
+* **validator:** fail schema validation on nested parsing errors ([b17704a](https://github.com/dougyouch/schema/commit/b17704af2629d3a4a81ee69f748e216a8c5d7488))
+
+## [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'
@@ -59,23 +59,149 @@ user.active        # => true (parsed from "yes")
 user.tags          # => ["ruby", "rails", "developer"]
 ```
 
+## Use Cases
+
+### Typed JSON columns on ActiveRecord models
+
+Wrap a JSON/JSONB column in a schema so the record works with typed values, rejects bad data, and writes back clean JSON:
+
+```ruby
+class ConfigSchema
+  include Schema::All
+
+  attribute :api_key, :string
+  attribute :timeout, :integer, default: 30
+  attribute :enabled, :boolean
+
+  has_many :endpoints do
+    attribute :url, :string
+    validates :url, presence: true
+  end
+
+  validates :api_key, presence: true
+  validates :endpoints, schema: true
+end
+
+class Integration < ActiveRecord::Base
+  validate :validate_config, if: :config_updated?
+  before_save :update_data_from_config, if: :config_updated?
+
+  def config=(config_data)
+    @config = ConfigSchema.from_hash(config_data)
+  end
+
+  def config
+    @config ||= ConfigSchema.from_hash(data)
+  end
+
+  # reading config counts as an update, since the caller may change it in place
+  def config_updated?
+    defined?(@config)
+  end
+
+  private
+
+  def update_data_from_config
+    self.data = config.as_json
+  end
+
+  # parsing errors (e.g. timeout: "abc") don't make valid? false, so check both
+  def validate_config
+    return if config.parsed_and_valid?
+
+    config.full_error_messages.each { |message| errors.add(:config, message) }
+  end
+end
+
+integration.config = { 'api_key' => 'abc', 'timeout' => '60', 'endpoints' => [{ 'url' => 'https://example.com' }] }
+integration.config.timeout  # => 60
+integration.save            # writes data as { api_key: "abc", timeout: 60, endpoints: [{ url: "https://example.com" }] }
+```
+
+Use `from_hash`, not `new`, to build a schema from data. `from_hash(nil)` returns an empty model, so a record whose column is still `NULL` works too.
+
+If a single "Config is invalid" error is enough, `validates :config, schema: true, if: :config_updated?` replaces `validate_config`; it fails on parsing errors as well as validation errors.
+
+### Validating API input in controllers
+
+Describe the JSON an endpoint accepts as a schema. Values arrive converted to the right types, unknown keys are reported, and the schema acts as the allowlist, so strong parameters aren't needed:
+
+```ruby
+class CreateUserSchema
+  include Schema::All
+
+  attribute :name, :string
+  attribute :email, :string
+  attribute :age, :integer
+
+  validates :name, :email, presence: true
+end
+
+class UsersController < ApplicationController
+  def create
+    input = CreateUserSchema.from_hash(JSON.parse(request.raw_post))
+    unless input.parsed_and_valid?
+      return render json: { errors: input.full_error_messages }, status: :unprocessable_entity
+    end
+
+    user = User.create!(input.as_json)
+    render json: user, status: :created
+  end
+end
+```
+
+`parsed_and_valid?` runs the validations even when there are parsing errors, so `full_error_messages` reports everything wrong with the input at once, e.g. `["Age is invalid", "Admin is an unknown attribute", "Email can't be blank"]`.
+
+The body is parsed from `request.raw_post` rather than taken from `params`, because Rails adds keys to `params` (`controller`, `action`, and the wrapped parameters key) that the schema would report as unknown attributes.
+
+### PATCH endpoints
+
+`set_attribute_values` returns only the fields that were present in the input, including ones sent as `null`. That separates "not sent" from "sent as null", which is what a PATCH route needs:
+
+```ruby
+class UpdateUserSchema
+  include Schema::All
+
+  attribute :name, :string
+  attribute :email, :string
+  attribute :age, :integer
+end
+
+def update
+  input = UpdateUserSchema.from_hash(JSON.parse(request.raw_post))
+  unless input.parsed_and_valid?
+    return render json: { errors: input.full_error_messages }, status: :unprocessable_entity
+  end
+
+  # body {"name": "Joe", "age": null} => { name: "Joe", age: nil }: updates name, clears age, leaves email alone
+  user.update!(input.set_attribute_values)
+  render json: user
+end
+```
+
+Associations in `set_attribute_values` are schema models; call `as_json` on them if the record expects hashes. For a single attribute, `input.name_was_set?` answers the same question.
+
 ## Data Types
 
 ### Basic Types
 
 ```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 +216,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 +421,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,9 +436,36 @@ 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"]`).
+
+### Checking Everything at Once
+
+```ruby
+user = UserSchema.from_hash(name: 'John', age: 'not-a-number', email: nil)
+
+user.parsed_and_valid?    # => false; runs validations even though parsing failed
+user.full_error_messages  # => ["Age is invalid", "Email can't be blank"] (parsing messages, then validation messages)
+```
+
+`full_error_messages` reports the last validation run, so call `parsed_and_valid?` (or `valid?`) first.
+
 ### 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:
+`validates ..., schema: true` (`SchemaValidator`) marks the parent invalid when a nested model, or any model in a has-many list, has parsing errors or fails its validations:
 
 ```ruby
 class OrderSchema
@@ -349,13 +504,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 +535,24 @@ 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.set_attribute_values   # => { name: "John" } (only fields present in the input)
+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 +619,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
@@ -25,24 +25,21 @@ module Schema
       valid_model!
     end
 
+    # runs validations even when there are parsing errors, so full_error_messages has both
+    def parsed_and_valid?
+      valid = valid?
+      valid && parsed?
+    end
+
+    # parsing error messages followed by the messages from the last validation run
+    def full_error_messages
+      parsing_errors.full_messages + errors.full_messages
+    end
+
     # 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,41 @@
+# 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
+
+    # only the attributes and associations present in the input (including ones set to nil),
+    # e.g. the fields a PATCH request sent
+    def set_attribute_values
+      set_field_options.to_h { |field_options| [field_options[:name], public_send(field_options[:getter])] }
+    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