schema-model 0.7.1 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53c13ff970f92e81b387ef19cb957afed64e77ec42ff63998a2d73fd2c383849
-  data.tar.gz: fe073187e725a642bc9e38a43798d99c5388bfad239e709c6d0d8be1c8cf699a
+  metadata.gz: cd3db69d1a56251cda03284c2af23954d69d79e697fa74c47d564eb1ceb9ddb7
+  data.tar.gz: 79687f0746ef3ea15c78b9ca99baf650b361e31e7ef2f7612f54da6e6fc2ec2d
 SHA512:
-  metadata.gz: 8186811e01c702fd082948daccc4ec5f0aaf67afefe15c0ca4200557e0b7397178eb0dcdb4ad1c44500d7284b8da31d6f607f4ae8f5652b3bff3fd66512cc0cd
-  data.tar.gz: 4d8b2fc23e68a4209571ce131b893dfa250ad85cf61f37fae48a47098d1fb4cda6730171c32a3c86dfb406f55cafea10a28ff3b65b8b1e33870801c4cfc39c3d
+  metadata.gz: 96fa7aa88bbc344fe24dbb245c7e2f3bc90a2dccda8386a41a0171eedb740ca15b3413bf6f73db4ef4f642e21142b83acf6a3de4f136e3b70e87a4e7752bb052
+  data.tar.gz: 7b0e3e1960f407ca135516910340b7f05679f1fd12ebed0efe66b4865b8f9d96ea73d64156bc60d45a3298a3be1aaa95cb2c2a34c82af1282438a69b0707ee45

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.7.1"
+  ".": "0.7.3"
 }

data/.rubocop.yml

@@ -48,10 +48,6 @@ Naming/FileName:
   Exclude:
     - 'lib/schema-model.rb'
 
-# Gemspec settings
-Gemspec/RequiredRubyVersion:
-  Enabled: false
-
 # DSL methods following ActiveRecord conventions (has_one, has_many)
 Naming/PredicatePrefix:
   Exclude:

data/ARCHITECTURE.md

@@ -17,16 +17,26 @@ Hash Data → from_hash() → Parser Methods → Schema Instance
 ```
 Schema::All (convenience bundle)
     ├── Schema::Model (core attribute system)
+    │     └── Schema::Parsers::Common
     ├── Schema::Associations::HasOne
     ├── Schema::Associations::HasMany
-    ├── Schema::Parsers::Common
     ├── Schema::Parsers::American
     ├── Schema::Parsers::Array
     ├── Schema::Parsers::Hash
     ├── Schema::Parsers::Json
     └── Schema::ActiveModelValidations
+
+Opt-in (via schema_include):
+    ├── Schema::ArrayHeaders (map CSV headers to attributes)
+    └── Schema::Arrays (models to/from flat arrays)
+
+Standalone:
+    ├── Schema::CSVParser (class; reads CSV rows into models)
+    └── SchemaValidator (ActiveModel validator for `schema: true`)
 ```
 
+`schema_include` both includes a module and records it in `schema_config[:schema_includes]`, so it is also included in every nested association class, including ones defined later.
+
 ## Core Components
 
 ### Schema::Model (`lib/schema/model.rb`)
@@ -40,7 +50,9 @@ The foundation module providing:
 
 - **`from_hash(data, skip_fields)`**: Class method that creates instance and calls `update_attributes`
 
-- **`update_attributes(data, skip_fields)`**: Iterates hash keys, matches against schema, invokes setters
+- **`update_attributes(data, skip_fields)`**: Iterates the data's key/value pairs, matches them against the schema, and invokes setters. Plain attributes are set before associations, so an association's `external_type_field` can read a sibling attribute. Each key is looked up on its own: symbol keys in `schema`, anything else in `schema_with_string_keys` (rebuilt whenever `schema` changes). `skip_fields` entries match a field by name or alias, as a symbol or string; a `{ association: [...] }` entry passes a nested list down.
+
+- **Aliases**: each alias adds a second schema entry with `alias_of:` pointing at the real attribute, plus aliased getter/setter methods. Serialization and array conversion skip entries with `alias_of`.
 
 - **`as_json` / `to_hash`**: Serialization back to hash format
 
@@ -66,10 +78,14 @@ has_one(:profile) { attribute :bio, :string }
 has_many(:posts) { attribute :title, :string }
 ```
 
+Each association gets a generated class (`SchemaHasOne<Name>` / `SchemaHasMany<Name>` by default, or `class_name:`), defined as a constant inside the parent class. `base_class:` subclasses an existing schema instead of creating a fresh model class.
+
 Both use **SchemaCreator** (`schema_creator.rb`) to:
 1. Determine which class to instantiate (static or dynamic)
 2. Call `from_hash` on the nested class
-3. Propagate parsing errors to parent
+3. Propagate parsing errors to parent: `invalid` when the nested model has parsing errors, `incompatible` when the value isn't a hash (or, for has-many, an array), and `unknown` when no dynamic type matches
+
+`has_many ..., from: :hash` accepts a hash keyed by id instead of an array; each key is written to `hash_key_field` (default `:id`) on the nested model.
 
 **DynamicTypes** enables polymorphic associations:
 
@@ -81,7 +97,9 @@ has_many(:items, type_field: :kind) do
 end
 ```
 
-The `type_field` option tells SchemaCreator which data key determines the subclass.
+The `type_field` option tells SchemaCreator which key in the nested data determines the subclass (the type field attribute's aliases are checked too); `external_type_field` reads the type from an attribute on the parent instead. `type_ignorecase: true` compares type names case-insensitively. Each `add_type` creates a subclass of the association class, defined on the parent class as `<Name>AssociationType<Type>`.
+
+`Associations::Base` stores the parent class by name and resolves it with `Object.const_get`, so a parent class must be assigned to a constant before any association that uses dynamic types is declared.
 
 ### Schema::Utils (`lib/schema/utils.rb`)
 
@@ -89,7 +107,7 @@ Utility methods for:
 - `classify_name`: String → ClassName conversion
 - `create_schema_class`: Dynamically creates nested schema classes
 - `add_association_class`: Wires up association with proper modules
-- `add_attribute_default_methods` / `add_association_default_methods`: Default value handling
+- `add_attribute_default_methods` / `add_association_default_methods`: Default value handling (`copy_default` hands each read a deep copy of the default)
 
 ### Error Handling
 
@@ -103,7 +121,15 @@ Parsing errors are distinct from validation errors:
 - **Parsing errors**: Type conversion failures (string "abc" → integer)
 - **Validation errors**: Business rule failures (via `validates` DSL)
 
-Methods `parsed!` and `valid!` raise `ParsingException`/`ValidationException` respectively.
+`parsed!` raises `ParsingException` when there are parsing errors and `valid_model!` raises `ValidationException` when validations fail; `valid!` calls both. `valid?` runs validations only and does not look at parsing errors.
+
+Parsing errors use these codes from `Schema::ParsingErrors`: `invalid`, `incompatible`, `unknown`, `unknown_attribute`, `unhandled_type`.
+
+### CSV and Arrays
+
+- **`Schema::ArrayHeaders`** (`lib/schema/array_headers.rb`): `map_headers_to_attributes(headers)` returns a nested hash of `{ field: { index: n } }` entries. Has-many fields are matched as `<prefix><n><key>` (prefix is the association name or an alias, `n` counts from 1) and map to `{ indexes: [...] }`.
+- **`Schema::Arrays`** (`lib/schema/arrays.rb`): `to_headers`, `to_empty_array`, `to_a` and `from_array(array, mapped_headers)`. Has-many associations need a `size:` option for the fixed-width methods.
+- **`Schema::CSVParser`** (`lib/schema/csv_parser.rb`): wraps a `CSV` object, maps its header row once, and yields a model per row (`each`, `shift`, `missing_fields`).
 
 ### Inheritance Helper Integration
 

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.7.3](https://github.com/dougyouch/schema/compare/v0.7.2...v0.7.3) (2026-10-04)
+
+
+### Bug Fixes
+
+* **array-headers:** map aliased associations once under their name ([20258e2](https://github.com/dougyouch/schema/commit/20258e22bb59bbfaac088a71dccd773b7ef9255c))
+* **parsers:** accept signed exponents and treat nil as nil for array, hash and json ([d4ac539](https://github.com/dougyouch/schema/commit/d4ac539ceba92354b47504523c18bbe3ed209e09))
+
+## [0.7.2](https://github.com/dougyouch/schema/compare/v0.7.1...v0.7.2) (2026-10-04)
+
+
+### Bug Fixes
+
+* **associations:** read type field aliases and handle bad hash-keyed entries ([d5bdb05](https://github.com/dougyouch/schema/commit/d5bdb05c4ce90cd40e50f1619829f0e29082cec6))
+* **model:** honor skip_fields for any key style and fix key lookup edge cases ([3ca3450](https://github.com/dougyouch/schema/commit/3ca34500f71e62c9bfcf0c49419bac22bdfc56bd))
+* **parsers:** anchor parser regexes and reject non-finite floats as integers ([0514bd6](https://github.com/dougyouch/schema/commit/0514bd6175031a146bbc3a5d178b9e0fd32b4c7f))
+
 ## [0.7.1](https://github.com/dougyouch/schema/compare/v0.7.0...v0.7.1) (2026-10-04)
 
 

data/CLAUDE.md

@@ -35,7 +35,7 @@ This is a Ruby gem (`schema-model`) for data transformation, validation, and typ
 - **Schema::All** (`lib/schema/all.rb`) - Convenience module bundling Model + Associations + Parsers + ActiveModel validations. This is the typical include.
 
 - **Schema::Parsers** - Type parsers in `lib/schema/parsers/`:
-  - `Common` - integer, string, float, time, date, boolean
+  - `Common` - integer, string, string_or_nil, float, time, date, boolean (included by `Schema::Model`)
   - `American` - american_date, american_time (MM/DD/YYYY format)
   - `Array` - array with optional separator and data_type
   - `Hash` - hash/dictionary values
@@ -47,11 +47,15 @@ This is a Ruby gem (`schema-model`) for data transformation, validation, and typ
 
 - **Schema::ArrayHeaders** (`lib/schema/array_headers.rb`) - Map CSV headers to schema attributes.
 
+- **Schema::CSVParser** (`lib/schema/csv_parser.rb`) - Class that reads `CSV` rows into models (needs ArrayHeaders + Arrays on the model).
+
+- **SchemaValidator** (`lib/schema_validator.rb`) - ActiveModel validator behind `validates :assoc, schema: true`.
+
 ### Key Patterns
 
 **Attribute Definition**: Each `attribute` call generates getter, setter, and `<name>_was_set?` predicate. Setter invokes type-specific parser.
 
-**Parsing Errors**: Stored in `parsing_errors`. Parsers add errors for invalid values rather than raising exceptions. With ActiveModelValidations, use `parsed?`/`parsed!`.
+**Parsing Errors**: Stored in `parsing_errors`. Parsers add errors for invalid values rather than raising exceptions. With ActiveModelValidations, use `parsed?`/`parsed!`; `valid?` does not check parsing errors.
 
 **Schema Inheritance**: Uses `inheritance-helper` gem. Schema definitions accumulate via `add_value_to_class_method(:schema, ...)`.
 

data/README.md

@@ -59,7 +59,7 @@ user.tags          # => ["ruby", "rails", "developer"]
 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           # Boolean (accepts: 1, t, true, on, y, yes)
+attribute :active, :boolean           # true for 1, t, true, on, y, yes (any case); other strings are false; numbers are true unless 0
 attribute :notes, :string_or_nil      # String, but returns nil if empty
 ```
 
@@ -100,8 +100,11 @@ attribute :name, :string, aliases: [:full_name, :display_name]
 attribute :status, :string, default: 'pending'
 attribute :count, :integer, default: 0
 attribute :tags, :array, default: []
+attribute :starts_on, :date, default: Date.new(2024, 1, 1)
 ```
 
+Each read of a default returns a fresh copy (frozen values are shared), so mutating it doesn't change the default for other instances.
+
 ### Checking If Attribute Was Set
 
 Every attribute generates a `_was_set?` predicate method:
@@ -171,10 +174,19 @@ order.items.first.sku    # => "ABC"
 has_one :profile, default: true
 has_many :tags, default: true
 
+# Aliases for the association key
+has_one :profile, alias: :user_profile
+has_many :items, aliases: [:line_items]
+
 # Reuse existing schema class
 has_one :shipping_address, base_class: AddressSchema
 has_one :billing_address, base_class: AddressSchema
 
+# Name the generated class (defaults to SchemaHasOneProfile, SchemaHasManyItems, ...)
+has_one :profile, class_name: 'ProfileSchema' do
+  attribute :bio, :string
+end
+
 # Has many from hash (keyed by field)
 has_many :items, from: :hash, hash_key_field: :id do
   attribute :id, :string
@@ -236,7 +248,8 @@ company.employees[1].team_size              # => 5
 ```ruby
 # Type field within nested data (default)
 has_many :items, type_field: :kind do
-  # looks for :kind in each item's data
+  # looks for :kind in each item's data, or an alias of the kind attribute
+  attribute :kind, :string, alias: :category
 end
 
 # Type determined by parent field
@@ -250,6 +263,8 @@ has_many :items, type_field: :type, type_ignorecase: true do
 end
 ```
 
+When the type matches no `add_type` and there is no `default_type`, the association is `nil` and the parent records an `unknown` parsing error.
+
 ## Validation and Error Handling
 
 ### ActiveModel Validations
@@ -270,16 +285,36 @@ 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).
+
 ```ruby
-user = UserSchema.from_hash(name: 'John', age: 'not-a-number')
+user = UserSchema.from_hash(name: 'John', email: 'john@example.com', age: 'not-a-number')
 
 # Parsing errors (type conversion failures)
 user.parsing_errors.empty?  # => false
 user.parsed?                # => false
+user.age                    # => nil
 
 # Validation errors (business rules)
-user.valid?                 # => false (also runs validations)
-user.errors.full_messages   # => ["Age is invalid", ...]
+user.valid?                 # => true (age is nil, which allow_nil permits)
+user.errors.full_messages   # => []
+```
+
+### 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:
+
+```ruby
+class OrderSchema
+  include Schema::All
+
+  has_one :customer do
+    attribute :name, :string
+    validates :name, presence: true
+  end
+
+  validates :customer, presence: true, schema: true
+end
 ```
 
 ### Raising Exceptions
@@ -312,12 +347,21 @@ user.parsing_errors[:unknown_field]  # => ["unknown_attribute"]
 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.
+
 ## Serialization
 
 ### to_hash / as_json
 
 ```ruby
-user = UserSchema.from_hash(name: 'John', email: nil)
+class ContactSchema
+  include Schema::All
+
+  attribute :name, :string
+  attribute :email, :string
+end
+
+user = ContactSchema.from_hash(name: 'John', email: nil)
 
 user.to_hash                          # => { name: "John", email: nil }
 user.as_json                          # => { name: "John" } (excludes nils)
@@ -348,17 +392,23 @@ user.created_at  # => nil (not set)
 
 # Nested skip_fields for associations
 order = OrderSchema.from_hash(data, [:id, { items: [:id] }])
+
+# Skip an association entirely
+order = OrderSchema.from_hash(data, [:items])
 ```
 
+A skipped field is ignored whether the data uses symbol keys, string keys, or one of the field's aliases.
+
 ## Array and CSV Support
 
 ### Schema::Arrays Module
 
-Convert models to/from flat arrays (useful for CSV/spreadsheet data):
+Convert models to/from flat arrays (useful for CSV/spreadsheet data). `from_array` takes the header mapping built by `Schema::ArrayHeaders`, so include both:
 
 ```ruby
 class UserSchema
   include Schema::All
+  schema_include Schema::ArrayHeaders
   schema_include Schema::Arrays
 
   attribute :name, :string
@@ -378,21 +428,36 @@ mapped = UserSchema.map_headers_to_attributes(headers)
 user = UserSchema.from_array(['Jane', 'jane@example.com'], mapped)
 ```
 
-### Schema::CSVParser Module
+`to_headers`, `to_empty_array` and `to_a` need a fixed number of columns for each has-many association, so give it a `size`:
+
+```ruby
+has_many :phones, size: 3 do
+  attribute :number, :string
+end
+
+UserSchema.to_headers  # => [..., "phones[1].number", "phones[2].number", "phones[3].number"]
+```
+
+### Schema::CSVParser
 
-Parse CSV data directly into models:
+`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:
 
 ```ruby
+require 'csv'
+
 class UserCSVSchema
-  include Schema::Model
-  include Schema::CSVParser
+  include Schema::All
+  schema_include Schema::ArrayHeaders
+  schema_include Schema::Arrays
 
   attribute :name, :string
   attribute :email, :string
 end
 
-csv_data = CSV.parse("name,email\nJohn,john@example.com", headers: true)
-parser = Schema::CSVParser.new(csv_data, UserCSVSchema)
+csv = CSV.new("name,email\nJohn,john@example.com\n")
+parser = Schema::CSVParser.new(csv, UserCSVSchema)
+
+parser.missing_fields(%w[name email phone])  # => ["phone"]
 
 parser.each do |user|
   puts user.name
@@ -416,10 +481,13 @@ headers = ['FullName', 'email', 'unknown_column']
 mapped = UserSchema.map_headers_to_attributes(headers)
 # => { name: { index: 0 }, email: { index: 1 } }
 
-UserSchema.get_mapped_field_names(mapped)    # => ["name", "email"]
+# Field names are reported by their first alias when they have one
+UserSchema.get_mapped_field_names(mapped)    # => ["FullName", "email"]
 UserSchema.get_unmapped_field_names(mapped)  # => []
 ```
 
+Has-many columns are matched by the association name (or its aliases) followed by a 1-based index and the field key, e.g. `Phones1Number`, `Phones2Number` for `has_many :phones, alias: 'Phones'` with `attribute :number, :string, alias: 'Number'`.
+
 ## Extending Schemas
 
 ### schema_include

data/lib/schema/array_headers.rb

@@ -75,6 +75,8 @@ module Schema
       def map_headers_to_has_one_associations(headers, mapped_headers, header_prefix)
         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)
           next if mapped_model.empty?
@@ -87,6 +89,7 @@ module Schema
       def map_headers_to_has_many_associations(headers, mapped_headers)
         schema.each do |field_name, field_options|
           next unless field_options[:type] == :has_many
+          next if field_options[:alias_of]
 
           get_header_prefixes(field_name, field_options).each do |header_prefix|
             mapped_model = get_mapped_model(field_options, headers, header_prefix)

data/lib/schema/arrays.rb

@@ -137,7 +137,7 @@ module Schema
       mapped_model.each_value do |info|
         if info[:indexes]
           size = info[:indexes].size if info[:indexes].size > size
-        elsif info.is_a?(Hash)
+        else
           new_size = largest_number_of_indexes_from_map(info)
           size = new_size if new_size > size
         end

data/lib/schema/associations/schema_creator.rb

@@ -10,7 +10,6 @@ module Schema
         options = base_schema.class.schema[name]
         @schema_name = name
         @schema_class = base_schema.class.const_get(options[:class_name])
-        @aliases = options.fetch(:aliases, [])
         @ignorecase = options[:type_ignorecase]
         @is_list = options[:from] != :hash
         @hash_key_field = options[:hash_key_field]
@@ -38,7 +37,7 @@ module Schema
         elsif !is_list? && list.is_a?(Hash)
           list.map do |(key, data)|
             schema = create_schema(base_schema, data, "#{@schema_name}:#{key}", skip_fields)
-            schema.send(schema.class.schema[@hash_key_field][:setter], key)
+            schema&.public_send(schema.class.schema[@hash_key_field][:setter], key)
             schema
           end
         elsif !list.nil?
@@ -86,16 +85,17 @@ module Schema
             return type if type
           end
           nil
-        elsif @external_type_field
+        else
           base_schema.public_send(@external_type_field)
         end
       end
 
+      # the type field and its attribute aliases, as symbols and strings
       def type_fields
-        @type_fields ||= [
-          @type_field,
-          @type_field.to_s
-        ] + @aliases
+        @type_fields ||= begin
+          aliases = @schema_class.schema.dig(@type_field.to_sym, :aliases) || []
+          [@type_field, *aliases].flat_map { |name| [name.to_sym, name.to_s] }.uniq
+        end
       end
 
       def add_parsing_error(base_schema, error_name, error_msg)

data/lib/schema/model.rb

@@ -25,21 +25,17 @@ module Schema
 
     # no-doc
     module ClassMethods
-      def self.include(base)
-        base.capture_unknown_attributes = true
-      end
-
       def schema
         {}.freeze
       end
 
+      # rebuilt whenever schema is redefined, e.g. by an attribute added after the first lookup
       def schema_with_string_keys
-        @schema_with_string_keys ||=
-          begin
-            hsh = {}
-            schema.each { |field_name, field_options| hsh[field_name.to_s] = field_options }
-            hsh.freeze
-          end
+        current_schema = schema
+        return @schema_with_string_keys if @schema_with_string_keys_source.equal?(current_schema)
+
+        @schema_with_string_keys_source = current_schema
+        @schema_with_string_keys = current_schema.transform_keys(&:to_s).freeze
       end
 
       def schema_config
@@ -120,9 +116,10 @@ module Schema
     end
 
     def update_attributes(data = nil, skip_fields = [])
-      schema = get_schema(data)
-      update_model_attributes(schema, data, skip_fields)
-      update_associations(schema, data, skip_fields)
+      return self if data.nil?
+
+      update_model_attributes(data, skip_fields)
+      update_associations(data, skip_fields)
       self
     end
 
@@ -135,11 +132,7 @@ module Schema
         next if opts[:select_filter] && !opts[:select_filter].call(field_name, value, field_options)
         next if opts[:reject_filter]&.call(field_name, value, field_options)
 
-        memo[field_name] = if value.is_a?(Array)
-                             value.map { |e| e.as_json(opts) }
-                           else
-                             value.respond_to?(:as_json) ? value.as_json(opts) : value
-                           end
+        memo[field_name] = value.is_a?(Array) ? value.map { |e| value_as_json(e, opts) } : value_as_json(value, opts)
       end
     end
 
@@ -160,38 +153,54 @@ module Schema
 
     private
 
-    def get_schema(data)
-      return self.class.schema_with_string_keys unless data.is_a?(Hash)
+    # values without as_json (no ActiveSupport JSON extension) are returned as is
+    def value_as_json(value, opts)
+      value.respond_to?(:as_json) ? value.as_json(opts) : value
+    end
 
-      first_key = data.each_key.first
-      return self.class.schema_with_string_keys unless first_key.is_a?(Symbol)
+    # symbol keys use the schema directly, anything else is matched by its string form
+    def field_options_for_key(key)
+      key.is_a?(Symbol) ? self.class.schema[key] : self.class.schema_with_string_keys[key.to_s]
+    end
 
-      self.class.schema
+    # names a field can be listed under in skip_fields: its name or the alias used in the data
+    def skip_field_names(field_options)
+      [field_options[:name], field_options[:key]].flat_map { |name| [name.to_sym, name.to_s] }
     end
 
-    def update_model_attributes(schema, data, skip_fields)
+    def update_model_attributes(data, skip_fields)
       data.each do |key, value|
-        unless schema.key?(key)
+        unless (field_options = field_options_for_key(key))
           parsing_errors.add(key, ::Schema::ParsingErrors::UNKNOWN_ATTRIBUTE) if self.class.capture_unknown_attributes?
           next
         end
 
-        next if schema[key][:association]
-        next if skip_fields.include?(key)
+        next if field_options[:association]
+        next if skip_fields.intersect?(skip_field_names(field_options))
 
-        public_send(schema[key][:setter], value)
+        public_send(field_options[:setter], value)
       end
     end
 
-    def update_associations(schema, data, skip_fields)
+    def update_associations(data, skip_fields)
       data.each do |key, value|
-        next unless schema.key?(key)
-        next unless schema[key][:association]
+        next unless (field_options = field_options_for_key(key))
+        next unless field_options[:association]
+
+        names = skip_field_names(field_options)
+        next if skip_fields.intersect?(names)
+
+        public_send(field_options[:setter], value, association_skip_fields(skip_fields, names))
+      end
+    end
+
+    def association_skip_fields(skip_fields, names)
+      skip_fields.each do |skip_field|
+        next unless skip_field.is_a?(Hash)
 
-        association_skip_fields = skip_fields.detect { |f| f.is_a?(Hash) && f.include?(key) }
-        association_skip_fields = association_skip_fields ? association_skip_fields[key] : []
-        public_send(schema[key][:setter], value, association_skip_fields)
+        names.each { |name| return skip_field[name] if skip_field.key?(name) }
       end
+      []
     end
   end
 end

data/lib/schema/parsers/array.rb

@@ -17,6 +17,8 @@ module Schema
 
           parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE)
           nil
+        when nil
+          nil
         else
           parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE)
           nil

data/lib/schema/parsers/common.rb

@@ -6,9 +6,9 @@ module Schema
   module Parsers
     # Schema::Parsers::Common are parser methods for basic types
     module Common
-      INTEGER_REGEX = /^[-+]?(?:[1-9]\d*|0)(?:\.0+)?$/
-      FLOAT_REGEX = /^[-+]?(?:[1-9]\d*|0)(?:\.\d+)?([Ee]-?\d+)?$/
-      BOOLEAN_REGEX = /^(?:1|t|true|on|y|yes)$/i
+      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
 
       def parse_integer(field_name, parsing_errors, value)
         case value
@@ -22,8 +22,7 @@ module Schema
             nil
           end
         when Float
-          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE) if (value % 1) > 0.0
-          value.to_i
+          parse_float_as_integer(field_name, parsing_errors, value)
         when nil
           nil
         else
@@ -32,6 +31,16 @@ module Schema
         end
       end
 
+      def parse_float_as_integer(field_name, parsing_errors, value)
+        unless value.finite?
+          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE)
+          return nil
+        end
+
+        parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE) if (value % 1) > 0.0
+        value.to_i
+      end
+
       def parse_string(field_name, parsing_errors, value)
         case value
         when String

data/lib/schema/parsers/hash.rb

@@ -8,6 +8,8 @@ module Schema
         case value
         when ::Hash
           value
+        when nil
+          nil
         else
           parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE)
           nil

data/lib/schema/parsers/json.rb

@@ -15,6 +15,8 @@ module Schema
             parsing_errors.add(field_name, ::Schema::ParsingErrors::INVALID)
             nil
           end
+        when nil
+          nil
         else
           parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE)
           nil

data/lib/schema/utils.rb

@@ -56,13 +56,20 @@ module Schema
       kls.send(:include, ::Schema::Associations::DynamicTypes)
     end
 
+    # each call gets its own copy so callers can't mutate the shared default
+    def copy_default(value)
+      return value if value.frozen?
+
+      Marshal.load(Marshal.dump(value))
+    rescue TypeError
+      value.dup
+    end
+
     def add_attribute_default_methods(kls, options)
+      default = options[:default]
+      kls.send(:define_method, options[:default_method]) { ::Schema::Utils.copy_default(default) }
       kls.class_eval(
         <<-STR, __FILE__, __LINE__ + 1
-  def #{options[:default_method]}
-    #{options[:default].inspect}
-  end
-
   def #{options[:getter]}
     if #{options[:instance_variable]}.nil?
       #{options[:default_method]}

data/lib/schema/version.rb

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

data/lib/schema-model.rb

@@ -24,7 +24,6 @@ module Schema
   autoload :Arrays, 'schema/arrays'
   autoload :CSVParser, 'schema/csv_parser'
   autoload :Errors, 'schema/errors'
-  autoload :CSVParser, 'schema/csv_parser'
   autoload :Model, 'schema/model'
   autoload :ParsingErrors, 'schema/parsing_errors'
   autoload :Utils, 'schema/utils'

data/schema-model.gemspec

@@ -6,13 +6,16 @@ Gem::Specification.new do |s|
   s.name        = 'schema-model'
   s.version     = Schema::VERSION
   s.licenses    = ['MIT']
-  s.summary     = 'Data transformation, validation, and type safety for Ruby'
-  s.description = 'A flexible DSL for defining strongly-typed data models with automatic parsing, ' \
-                  'nested associations, dynamic types, and ActiveModel validations'
+  s.summary     = 'Typed Ruby models built from hashes, JSON and CSV rows'
+  s.description = 'Declare typed attributes and Schema turns incoming hashes, JSON and CSV rows into Ruby objects. ' \
+                  'Values are coerced to integers, floats, booleans, dates, times, arrays and hashes, and bad input ' \
+                  'is recorded as parsing errors instead of raised. Supports nested has_one/has_many associations, ' \
+                  'polymorphic types chosen by a type field, CSV header mapping, and ActiveModel validations.'
   s.authors     = ['Doug Youch']
   s.email       = 'dougyouch@gmail.com'
   s.homepage    = 'https://github.com/dougyouch/schema'
   s.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.required_ruby_version = '>= 3.2'
   s.bindir      = 'bin'
   s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema-model
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.3
 platform: ruby
 authors:
 - Doug Youch
@@ -23,8 +23,11 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A flexible DSL for defining strongly-typed data models with automatic
-  parsing, nested associations, dynamic types, and ActiveModel validations
+description: Declare typed attributes and Schema turns incoming hashes, JSON and CSV
+  rows into Ruby objects. Values are coerced to integers, floats, booleans, dates,
+  times, arrays and hashes, and bad input is recorded as parsing errors instead of
+  raised. Supports nested has_one/has_many associations, polymorphic types chosen
+  by a type field, CSV header mapping, and ActiveModel validations.
 email: dougyouch@gmail.com
 executables:
 - schema-json2csv
@@ -84,7 +87,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -93,5 +96,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.20
 specification_version: 4
-summary: Data transformation, validation, and type safety for Ruby
+summary: Typed Ruby models built from hashes, JSON and CSV rows
 test_files: []