schema-model 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd3db69d1a56251cda03284c2af23954d69d79e697fa74c47d564eb1ceb9ddb7
-  data.tar.gz: 79687f0746ef3ea15c78b9ca99baf650b361e31e7ef2f7612f54da6e6fc2ec2d
+  metadata.gz: f672bab800b79f5e9a8b390268466caaf7a42822b0b0632f023f6539fbae48aa
+  data.tar.gz: 5486532778b3a246d66c0c2350586fd77ebf9955ef311a719c5053d656afe0be
 SHA512:
-  metadata.gz: 96fa7aa88bbc344fe24dbb245c7e2f3bc90a2dccda8386a41a0171eedb740ca15b3413bf6f73db4ef4f642e21142b83acf6a3de4f136e3b70e87a4e7752bb052
-  data.tar.gz: 7b0e3e1960f407ca135516910340b7f05679f1fd12ebed0efe66b4865b8f9d96ea73d64156bc60d45a3298a3be1aaa95cb2c2a34c82af1282438a69b0707ee45
+  metadata.gz: ca482dfd23e73cea044bf572e819864415ee68768cdb0b98a756e92fbb06c2d800b7cdd6c2afde4d5c77559d226a7e3cf681f4043a17b118c17ed24fee0cdb9c
+  data.tar.gz: f555174a32c7adbe3b713bb726038f325168f07820d6309479be0715af91bb5e684d73d51466a0f71cc806ecd7ca98f2006bf8820008c126ee4f25f220ffdcde

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # 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)
+
+
+### Bug Fixes
+
+* **array-headers:** fix nested field names, association columns and column collisions ([f0373e0](https://github.com/dougyouch/schema/commit/f0373e0450e9d474dcde5e02b1db76b9c7bbc7d4))
+* **associations:** support dynamic types in anonymous parent classes ([45d22da](https://github.com/dougyouch/schema/commit/45d22da233ec97703ba3c3bd90a91e577bac5390))
+* **cli:** write csv headers to stdout and lint schema-json2csv ([58ebb13](https://github.com/dougyouch/schema/commit/58ebb138d58cbddca60c2e7214ab980d3c0aae12))
+
 ## [0.7.3](https://github.com/dougyouch/schema/compare/v0.7.2...v0.7.3) (2026-10-04)
 
 

data/README.md

@@ -8,10 +8,16 @@ 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'
+
+# needed for Schema::All and Schema::ActiveModelValidations (already present in Rails apps)
+gem 'activemodel'
+
+# needed for Schema::CSVParser and bin/schema-json2csv on Ruby 3.4+, where csv is no longer a default gem
+gem 'csv'
 ```
 
 And then execute:
@@ -20,6 +26,8 @@ And then execute:
 $ bundle install
 ```
 
+`Schema::Model` on its own has no dependencies beyond `inheritance-helper`.
+
 ## Quick Start
 
 ```ruby
@@ -57,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
 ```
@@ -82,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
@@ -285,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')
@@ -300,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:
@@ -341,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
 
@@ -372,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:
@@ -438,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:
@@ -521,6 +570,8 @@ schema-json2csv --require ./my_schema.rb --schema MySchema --json data.json --cs
 cat data.json | schema-json2csv --require ./my_schema.rb --schema MySchema - --csv output.csv
 ```
 
+The JSON can be one object or an array of objects. Output goes to stdout when `--csv` is omitted. A header row (from `to_headers`) is written to stdout or to a new file; an existing `--csv` file is appended to without repeating it. Has-many associations need a `size:` so every row has the same columns.
+
 ## Contributing
 
 1. Fork the repository

data/bin/schema-json2csv

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'schema-model'
 require 'csv'
@@ -13,7 +14,7 @@ options = {
 }
 
 OptionParser.new do |opts|
-  opts.banner = "Usage: " + File.basename(__FILE__)
+  opts.banner = "Usage: #{File.basename(__FILE__)} --require FILE --schema CLASS (--json FILE | -) [--csv FILE]"
 
   opts.on('--json JSON_FILE', 'JSON data') do |v|
     options[:json_file] = v
@@ -23,7 +24,7 @@ OptionParser.new do |opts|
     options[:require_file] = v
   end
 
-  opts.on('--csv CSV_FILE', 'File to output csv data') do |v|
+  opts.on('--csv CSV_FILE', 'File to output csv data (appended to if it exists)') do |v|
     options[:csv_file] = v
   end
 
@@ -32,54 +33,39 @@ OptionParser.new do |opts|
   end
 end.parse!
 
-raise('no filed required') unless options[:require_file]
-raise('no schema specified') unless options[:schema_class_name]
+abort('no file required') unless options[:require_file]
+abort('no schema specified') unless options[:schema_class_name]
+abort("file #{options[:require_file]} not found") unless File.exist?(options[:require_file])
 
-$LOAD_PATH << '.'
-raise("file #{options[:require_file]} not found") unless require(options[:require_file])
+require File.expand_path(options[:require_file])
 
-raise("schema #{options[:schema_class_name]} not found") unless Object.const_defined?(options[:schema_class_name])
+abort("schema #{options[:schema_class_name]} not found") unless Object.const_defined?(options[:schema_class_name])
 
 schema_class = Object.const_get(options[:schema_class_name])
 schema_class.schema_include Schema::Arrays
 
 json_data =
   if options[:json_file]
-    raise("json file #{options[:json_file]} not found") unless File.exist?(options[:json_file])
+    abort("json file #{options[:json_file]} not found") unless File.exist?(options[:json_file])
     File.read(options[:json_file])
   elsif ARGV.last == '-'
-    ARGF.read
+    $stdin.read
   else
-    raise('no json data specified')
+    abort('no json data specified')
   end
 
-def output_csv(schema, io)
-  str = CSV.generate do |csv|
-    csv << schema.to_a.flatten
-  end
-
-  io.print str
-end
+# headers are written to stdout and to new files; an existing file is appended to as is
+csv_file = options[:csv_file]
+write_headers = csv_file.nil? || !File.exist?(csv_file)
+io = csv_file ? File.open(csv_file, 'ab') : $stdout
 
-io =
-  if file = options[:csv_file]
-    if File.exist?(file)
-      File.open(options[:csv_file], 'ab')
-    else
-      headers = CSV.generate do |csv|
-        csv << schema_class.to_headers
-      end
-      f = File.open(options[:csv_file], 'wb')
-      f.print headers
-      f
-    end
-  else
-    $stdout
-  end
+io.print CSV.generate_line(schema_class.to_headers) if write_headers
 
 json_data = JSON.parse(json_data)
 json_data = [json_data] unless json_data.is_a?(Array)
 
 json_data.each do |data|
-  output_csv(schema_class.from_hash(data), io)
+  io.print CSV.generate_line(schema_class.from_hash(data).to_a.flatten)
 end
+
+io.close if csv_file

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/array_headers.rb

@@ -45,13 +45,11 @@ module Schema
 
       private
 
+      # has_many columns are reported as <prefix>X<field>; has_one fields share the parent's prefix
       def get_model_field_names(field_name, field_options, mapped_headers, header_prefix, mapped)
         mapped_model = mapped_headers[field_name] || {}
-        const_get(field_options[:class_name]).get_field_names(
-          mapped_model,
-          header_prefix || field_options[:aliases]&.first,
-          mapped
-        )
+        header_prefix ||= (field_options[:aliases]&.first || field_name).to_s if field_options[:type] == :has_many
+        const_get(field_options[:class_name]).get_field_names(mapped_model, header_prefix, mapped)
       end
 
       def skip_field?(field_name, mapped_headers, mapped)
@@ -72,20 +70,36 @@ module Schema
         const_get(field_options[:class_name]).map_headers_to_attributes(headers, header_prefix)
       end
 
+      # a column already claimed by the parent (or an earlier has_one) isn't reused for a nested field
       def map_headers_to_has_one_associations(headers, mapped_headers, header_prefix)
+        claimed_indexes = mapped_header_indexes(mapped_headers)
         schema.each do |field_name, field_options|
           next unless field_options[:type] == :has_one
           # aliases are matched through the association's own entry
           next if field_options[:alias_of]
 
-          mapped_model = get_mapped_model(field_options, headers, header_prefix)
+          available_headers = headers.each_with_index.map { |header, idx| claimed_indexes.include?(idx) ? nil : header }
+          mapped_model = get_mapped_model(field_options, available_headers, header_prefix)
           next if mapped_model.empty?
 
           mapped_headers[field_name] = mapped_model
+          claimed_indexes.concat(mapped_header_indexes(mapped_model))
         end
         mapped_headers
       end
 
+      def mapped_header_indexes(mapped_headers)
+        mapped_headers.each_value.flat_map do |info|
+          if info.key?(:index)
+            [info[:index]]
+          elsif info.key?(:indexes)
+            info[:indexes]
+          else
+            mapped_header_indexes(info)
+          end
+        end
+      end
+
       def map_headers_to_has_many_associations(headers, mapped_headers)
         schema.each do |field_name, field_options|
           next unless field_options[:type] == :has_many
@@ -104,6 +118,9 @@ module Schema
 
       def map_headers_to_fields(headers, mapped_headers, header_prefix)
         schema.each do |field_name, field_options|
+          # associations are mapped through their nested fields, not a column of their own
+          next if field_options[:association]
+
           if header_prefix
             unless (indexes = find_indexes_for_field(headers, field_options, header_prefix)).empty?
               mapped_headers[field_options[:alias_of] || field_name] = { indexes: indexes }

data/lib/schema/associations/base.rb

@@ -12,12 +12,15 @@ module Schema
       module ClassMethods
         attr_accessor :schema_name
 
+        # named classes are looked up by name so reloaded constants are picked up;
+        # anonymous classes have no name, so they are kept by reference
         def base_schema_class=(kls)
+          @base_schema_class = kls
           @base_schema_class_name = kls.name
         end
 
         def base_schema_class
-          Object.const_get(@base_schema_class_name)
+          @base_schema_class_name ? Object.const_get(@base_schema_class_name) : @base_schema_class
         end
 
         def schema_options

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