schema-model 0.7.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 274769a5b3652ece9a8c2583a8867310882800377563f7e5e8eb387a219ea4a3
-  data.tar.gz: f42a01e476eeb0101df7e5fbaa8bb9fde390637016876ed749a1f1f850d0ae0e
+  metadata.gz: c75de56a15a674efd32d16fdedda825e056c4b71e6e3a1d20c63761ae685c5c2
+  data.tar.gz: 25537f375a8da4d892bc4c6950e790d8db3b0859f925d302d27b9bef82a773f9
 SHA512:
-  metadata.gz: cef6b96d50da9c84ac9b80afd6c74f6f941668eecea8d7d6dd5260e3e73b0163f7906deb86af4f7bca141efbdccd3fffa2d12d6955fa7986ccc889c89c472194
-  data.tar.gz: 4372f3250e704cc8569411659663fc946ab3f87b2ea7a6255aca7966dde8dbcff8e2ef8eec50ece7aa3bba5f4ebc01ea352219f79c743db32974663f807e5440
+  metadata.gz: ec765c52a43b319a6e47879239f92f268a6c7c359163c001c2d9411f286fa41f7036a6739adf4e3f6531f7f9becc5c191c5ef51610f1128903d94a5f4ab6653e
+  data.tar.gz: 39dc1faf72f89f17dc75909421e1b1cc4c1d3e1b04db03661716f4f772a0ef5051ad8046e284ff34185b0da4dc27fdb44aaf720d7441a795fae18cd89c4f36a8

data/.github/workflows/ci.yml

@@ -3,51 +3,91 @@ name: CI
 on:
   push:
     branches: [master]
+  # release-please PRs change only these files. Their runs are triggered by
+  # github-actions[bot], which GitHub holds for approval until they expire as
+  # failures; release.yml runs this workflow before publishing anyway. A PR is
+  # skipped only if every file it changes is listed here.
   pull_request:
-    branches: [master]
+    paths-ignore:
+      - CHANGELOG.md
+      - .release-please-manifest.json
+      - lib/schema/version.rb
+  workflow_call:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
 jobs:
   lint:
     name: RuboCop
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
-          ruby-version: '3.4'
+          persist-credentials: false
+      - uses: ruby/setup-ruby@14594264cd68ce8a2345dd349bc3d138a4ef85c8 # v1.327.0
+        with:
+          ruby-version: '4.0'
           bundler-cache: true
+      - run: bundle exec rubocop --format github
 
-      - name: Run RuboCop
-        run: bundle exec rubocop --format github
-
+  # Runs on the Ruby in .ruby-version, the version Gemfile.lock is resolved against
   test:
-    name: Tests (Ruby ${{ matrix.ruby }})
+    name: Tests
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: ['3.2', '3.3', '3.4']
-
     steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Ruby ${{ matrix.ruby }}
-        uses: ruby/setup-ruby@v1
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - uses: ruby/setup-ruby@14594264cd68ce8a2345dd349bc3d138a4ef85c8 # v1.327.0
         with:
-          ruby-version: ${{ matrix.ruby }}
+          # no ruby-version: setup-ruby reads .ruby-version
           bundler-cache: true
+      - run: bundle exec rspec
+      # feeds the coverage badge
+      - name: Upload coverage report
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: coverage
+          path: coverage/
+          # .last_run.json (read by the badge job) is a dotfile; upload-artifact skips those by default
+          include-hidden-files: true
+          retention-days: 14
 
-      - name: Run tests
-        run: bundle exec rspec
-
-      - name: Upload coverage to Codecov
-        if: matrix.ruby == '3.4'
-        uses: codecov/codecov-action@v4
+  # Publishes coverage.svg and branches.svg to the orphan `badges` branch; the README badges point at them.
+  # Skipped when called from release.yml (github.workflow is the caller's name there).
+  coverage-badge:
+    if: github.workflow == 'CI' && github.event_name == 'push' && github.ref == 'refs/heads/master'
+    needs: test
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: ruby/setup-ruby@14594264cd68ce8a2345dd349bc3d138a4ef85c8 # v1.327.0
+        with:
+          ruby-version: '4.0'
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
-          files: coverage/coverage.xml
-          fail_ci_if_error: false
-          verbose: true
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+          name: coverage
+          path: coverage/
+      - run: |
+          ruby script/coverage_badge.rb coverage/.last_run.json "$RUNNER_TEMP/coverage.svg"
+          ruby script/coverage_badge.rb coverage/.last_run.json "$RUNNER_TEMP/branches.svg" branch
+      - name: Push badge to badges branch
+        run: |
+          git config user.name 'github-actions[bot]'
+          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
+          if git fetch --depth=1 origin badges; then
+            git switch badges
+          else
+            git switch --orphan badges
+          fi
+          cp "$RUNNER_TEMP/coverage.svg" "$RUNNER_TEMP/branches.svg" .
+          git add coverage.svg branches.svg
+          git diff --cached --quiet || git commit -m "coverage badge for ${GITHUB_SHA::7}"
+          git push origin badges

data/.github/workflows/release.yml

@@ -0,0 +1,93 @@
+name: Release
+
+# release-please keeps a release PR open that bumps lib/schema/version.rb
+# and CHANGELOG.md from conventional commits. Merging it tags the release,
+# creates the GitHub release and publishes the gem to RubyGems.
+# Run it manually (workflow_dispatch) to retry publishing the current version.
+on:
+  push:
+    branches: [master]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # release commits, tags and GitHub releases
+      issues: write # release labels
+      pull-requests: write # the release PR
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
+      version: ${{ steps.release.outputs.version }}
+      pr_branch: ${{ steps.release.outputs.pr && fromJSON(steps.release.outputs.pr).headBranchName || '' }}
+    steps:
+      - uses: googleapis/release-please-action@45996ed1f6d02564a971a2fa1b5860e934307cf7 # v5.0.0
+        id: release
+        with:
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+
+  # The release PR is opened with GITHUB_TOKEN, which doesn't trigger CI on it,
+  # so run the suite here before anything is published.
+  ci:
+    needs: release-please
+    if: needs.release-please.outputs.release_created == 'true' || github.event_name == 'workflow_dispatch'
+    uses: ./.github/workflows/ci.yml
+    # ceiling for the called workflow: its coverage-badge job declares contents: write
+    # (skipped when called from here); lint/test still run with ci.yml's top-level contents: read
+    permissions:
+      contents: write
+
+  publish:
+    needs: [release-please, ci]
+    runs-on: ubuntu-latest
+    environment:
+      name: rubygems
+      url: https://rubygems.org/gems/schema-model
+    permissions:
+      contents: write # attach the gem to the GitHub release
+      id-token: write # RubyGems trusted publishing (OIDC)
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          # the new tag on release; the dispatched commit on a manual retry
+          ref: ${{ needs.release-please.outputs.tag_name || github.sha }}
+          persist-credentials: false
+      - uses: ruby/setup-ruby@14594264cd68ce8a2345dd349bc3d138a4ef85c8 # v1.327.0
+        with:
+          ruby-version: '4.0'
+
+      - name: Read version
+        run: |
+          version=$(ruby -e 'puts Gem::Specification.load("schema-model.gemspec").version')
+          echo "VERSION=$version" >> "$GITHUB_ENV"
+          echo "TAG=v$version" >> "$GITHUB_ENV"
+
+      - name: Build gem
+        run: gem build schema-model.gemspec
+
+      - uses: rubygems/configure-rubygems-credentials@dc5a8d8553e6ee01fc26761a49e99e733d17954a # v2.1.0
+
+      # A version that's already on RubyGems is skipped, so a manual retry can finish a
+      # partially published release.
+      - name: Push gem
+        run: |
+          if curl -sf "https://rubygems.org/api/v2/rubygems/schema-model/versions/$VERSION.json" > /dev/null; then
+            echo "schema-model $VERSION is already published"
+          else
+            gem push "schema-model-$VERSION.gem"
+          fi
+
+      - name: Attach gem to GitHub release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release upload "$TAG" "schema-model-$VERSION.gem" --repo "$GITHUB_REPOSITORY" --clobber

data/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.7.2"
+}

data/.ruby-version

@@ -1 +1 @@
-3.4.2
+ruby-4.0.7

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

@@ -0,0 +1,18 @@
+# Changelog
+
+## [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)
+
+
+### Bug Fixes
+
+* **specs:** replace deprecated SimpleCov API calls ([dadae4a](https://github.com/dougyouch/schema/commit/dadae4aa2d0246e964fdb160e1b505187e3fadc6))
+* **specs:** wrap trailing hash literals in braces per Style/HashAsLastArrayItem ([cf8f18a](https://github.com/dougyouch/schema/commit/cf8f18af5b7c472298c7c0cbd7b6176356b476fc))

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,16 +47,28 @@ 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, ...)`.
 
 **Dynamic Types**: For polymorphic associations, use `type_field` option with `add_type` blocks. Supports `external_type_field`, `type_ignorecase`, and `default_type`.
 
+## CI
+
+`.github/workflows/ci.yml` runs RuboCop and the specs on the `.ruby-version` Ruby. On pushes to `master`, it publishes `coverage.svg` (line) and `branches.svg` (branch) from `script/coverage_badge.rb` to the orphan `badges` branch for the README badges.
+
+## Releases
+
+Releases are automated by release-please (`.github/workflows/release.yml`). Conventional commits on `master` (`fix:` → patch, `feat:` → minor, `!`/`BREAKING CHANGE` → major) update an open release PR that bumps `lib/schema/version.rb` (`Schema::VERSION`, read by the gemspec) and `CHANGELOG.md`. Merging that PR tags `vX.Y.Z`, creates the GitHub release, and publishes the gem to RubyGems. Don't bump the version by hand.
+
 ## Code Commits
 
 Format using angular formatting:
@@ -72,3 +84,4 @@ Format using angular formatting:
 When modifying the codebase, keep documentation in sync:
 - **ARCHITECTURE.md** - Update when adding/removing classes, changing component relationships, or altering data flow patterns
 - **README.md** - Update when adding new features, changing public APIs, or modifying usage examples
+- **CHANGELOG.md** - Generated by release-please from commit messages; don't edit by hand except to fix release notes

data/Gemfile

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
 gem 'inheritance-helper'
 
@@ -13,5 +13,4 @@ end
 group :spec do
   gem 'rspec'
   gem 'simplecov'
-  gem 'simplecov-cobertura'
 end

data/Gemfile.lock

@@ -1,9 +1,9 @@
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
-    activemodel (8.1.2)
-      activesupport (= 8.1.2)
-    activesupport (8.1.2)
+    activemodel (8.1.4)
+      activesupport (= 8.1.4)
+    activesupport (8.1.4)
       base64
       bigdecimal
       concurrent-ruby (~> 1.0, >= 1.3.1)
@@ -18,31 +18,30 @@ GEM
       uri (>= 0.13.1)
     ast (2.4.3)
     base64 (0.3.0)
-    bigdecimal (4.0.1)
-    concurrent-ruby (1.3.6)
+    bigdecimal (4.1.3)
+    concurrent-ruby (1.3.8)
     connection_pool (3.0.2)
-    csv (3.3.5)
+    csv (3.3.6)
     diff-lcs (1.6.2)
-    docile (1.4.1)
     drb (2.2.3)
-    i18n (1.14.8)
+    i18n (1.15.2)
       concurrent-ruby (~> 1.0)
     inheritance-helper (0.2.5)
-    json (2.18.0)
-    language_server-protocol (3.17.0.5)
+    json (3.0.2)
+    language_server-protocol (3.17.0.6)
     lint_roller (1.1.0)
     logger (1.7.0)
-    minitest (6.0.1)
+    minitest (6.0.6)
+      drb (~> 2.0)
       prism (~> 1.5)
-    parallel (1.27.0)
-    parser (3.3.10.1)
+    parallel (2.3.0)
+    parser (3.3.12.0)
       ast (~> 2.4.1)
       racc
     prism (1.9.0)
     racc (1.8.1)
     rainbow (3.1.1)
-    regexp_parser (2.11.3)
-    rexml (3.4.4)
+    regexp_parser (2.13.1)
     rspec (3.13.2)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
@@ -52,45 +51,37 @@ GEM
     rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.7)
+    rspec-mocks (3.13.8)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
     rspec-support (3.13.7)
-    rubocop (1.84.0)
-      json (~> 2.3)
+    rubocop (1.91.0)
+      json (>= 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
-      parallel (~> 1.10)
+      parallel (>= 1.10)
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 2.9.3, < 3.0)
       rubocop-ast (>= 1.49.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.49.0)
+    rubocop-ast (1.50.0)
       parser (>= 3.3.7.2)
       prism (~> 1.7)
     ruby-progressbar (1.13.0)
     securerandom (0.4.1)
-    simplecov (0.22.0)
-      docile (~> 1.1)
-      simplecov-html (~> 0.11)
-      simplecov_json_formatter (~> 0.1)
-    simplecov-cobertura (3.1.0)
-      rexml
-      simplecov (~> 0.19)
-    simplecov-html (0.13.2)
-    simplecov_json_formatter (0.1.4)
+    simplecov (1.3.2)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    unicode-display_width (3.2.0)
-      unicode-emoji (~> 4.1)
-    unicode-emoji (4.2.0)
+    unicode-display_width (3.3.0)
+      unicode-emoji (~> 4.3)
+    unicode-emoji (4.3.0)
     uri (1.1.1)
 
 PLATFORMS
-  arm64-darwin-24
   ruby
+  x86_64-darwin-24
 
 DEPENDENCIES
   activemodel
@@ -99,7 +90,45 @@ DEPENDENCIES
   rspec
   rubocop
   simplecov
-  simplecov-cobertura
+
+CHECKSUMS
+  activemodel (8.1.4) sha256=9a0906c127bd118aa5f06157db12b8f750da83dccee72db2f658547a0ae7a0e8
+  activesupport (8.1.4) sha256=891dd3fe43c4fc8391934b237b1189bb1f661c932a84a840043db9d46a4e80df
+  ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
+  base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
+  bigdecimal (4.1.3) sha256=61ebe1e5e559bdc3cc6f2c0ee7f427321fc838f59611c294356eb04d6e21cf66
+  concurrent-ruby (1.3.8) sha256=b2f1be836e968ccc78ccfce277ea79c72a88633f22306782c16ff23fb415d1e1
+  connection_pool (3.0.2) sha256=33fff5ba71a12d2aa26cb72b1db8bba2a1a01823559fb01d29eb74c286e62e0a
+  csv (3.3.6) sha256=aba61e7e507a66f03d45cb1f3c4b6359861c3504038b422962875dce099e4456
+  diff-lcs (1.6.2) sha256=9ae0d2cba7d4df3075fe8cd8602a8604993efc0dfa934cff568969efb1909962
+  drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373
+  i18n (1.15.2) sha256=00f9eb62412fe593b2a65a97daa75300d37abb8f7202ec748e94b6d46a9dd1b5
+  inheritance-helper (0.2.5) sha256=e318d548d2e201910ab484b2139a11e61f3dfac012c4aba090bcfaa5f9687b85
+  json (3.0.2) sha256=8e6d7e7b11384c21230430cef90b71f14849a34a1f4452796670f7c981bd19df
+  language_server-protocol (3.17.0.6) sha256=5ef2c0c138f8267e1bc631d3328347d354f96724b0af22f2c79516120443b7f0
+  lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87
+  logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
+  minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1
+  parallel (2.3.0) sha256=f75a3e904101ce6a1ccb6b8dc800cbafd42166d83330192438dcf29395167a6f
+  parser (3.3.12.0) sha256=21a6d7f755d5a24dfbdc6e6b772e4e879a52e7631a88bc5a3a134606052c9828
+  prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
+  racc (1.8.1) sha256=4a7f6929691dbec8b5209a0b373bc2614882b55fc5d2e447a21aaa691303d62f
+  rainbow (3.1.1) sha256=039491aa3a89f42efa1d6dec2fc4e62ede96eb6acd95e52f1ad581182b79bc6a
+  regexp_parser (2.13.1) sha256=5aedb6b7c35688f51e86eef17a15374dfd287c83f4ca644b2c5f3ec50a33b44b
+  rspec (3.13.2) sha256=206284a08ad798e61f86d7ca3e376718d52c0bc944626b2349266f239f820587
+  rspec-core (3.13.6) sha256=a8823c6411667b60a8bca135364351dda34cd55e44ff94c4be4633b37d828b2d
+  rspec-expectations (3.13.5) sha256=33a4d3a1d95060aea4c94e9f237030a8f9eae5615e9bd85718fe3a09e4b58836
+  rspec-mocks (3.13.8) sha256=086ad3d3d17533f4237643de0b5c42f04b66348c28bf6b9c2d3f4a3b01af1d47
+  rspec-support (3.13.7) sha256=0640e5570872aafefd79867901deeeeb40b0c9875a36b983d85f54fb7381c47c
+  rubocop (1.91.0) sha256=9c82b7bf391c5d7e3798c5b9996e22a1fe3bd7468e351dfdeb96140c058296d0
+  rubocop-ast (1.50.0) sha256=b9ca88300da0803ee222ad20cdb30494c0a784eed06fdc35d254b06d662788db
+  ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33
+  securerandom (0.4.1) sha256=cc5193d414a4341b6e225f0cb4446aceca8e50d5e1888743fac16987638ea0b1
+  simplecov (1.3.2) sha256=2a22ec1759f1b8db60881a2e038758956fc69ef93ed669be0bde0678de6d0e85
+  tzinfo (2.0.6) sha256=8daf828cc77bcf7d63b0e3bdb6caa47e2272dcfaf4fbfe46f8c3a9df087a829b
+  unicode-display_width (3.3.0) sha256=4b7aa66a4b11db50f6f7e98411215cd0dd10eaecb665d36eec5bcacb3fa0b613
+  unicode-emoji (4.3.0) sha256=11c02fa73290378c066bb0562cd4c87d8e1b706fbbe0059ca12746a4244de8ce
+  uri (1.1.1) sha256=379fa58d27ffb1387eaada68c749d1426738bd0f654d812fcc07e7568f5c57c6
 
 BUNDLED WITH
-   2.6.2
+  4.0.20

data/README.md

@@ -2,8 +2,9 @@
 
 A powerful Ruby gem for data transformation, validation, and type safety. Schema provides a flexible and intuitive way to define data models with support for complex nested structures, dynamic associations, and robust validation.
 
-[![CI](https://github.com/dougyouch/schema/actions/workflows/ci.yml/badge.svg)](https://github.com/dougyouch/schema/actions/workflows/ci.yml)
-[![codecov](https://codecov.io/gh/dougyouch/schema/graph/badge.svg)](https://codecov.io/gh/dougyouch/schema)
+[![CI](https://github.com/dougyouch/schema/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/dougyouch/schema/actions/workflows/ci.yml)
+[![Coverage](https://raw.githubusercontent.com/dougyouch/schema/badges/coverage.svg)](https://github.com/dougyouch/schema/actions/workflows/ci.yml)
+[![Branch Coverage](https://raw.githubusercontent.com/dougyouch/schema/badges/branches.svg)](https://github.com/dougyouch/schema/actions/workflows/ci.yml)
 
 ## Installation
 
@@ -58,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
 ```
 
@@ -81,6 +82,8 @@ attribute :metadata, :hash                        # Hash/dictionary values
 attribute :config, :json                          # Parse JSON strings
 ```
 
+Unlike the basic types, `:array`, `:hash` and `:json` record an `incompatible` parsing error when given `nil`.
+
 ## Attribute Options
 
 ### Aliases
@@ -99,8 +102,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:
@@ -170,10 +176,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
@@ -235,7 +250,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
@@ -249,6 +265,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
@@ -269,16 +287,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
@@ -311,12 +349,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)
@@ -347,17 +394,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
@@ -377,21 +430,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`:
 
-Parse CSV data directly into models:
+```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
+
+`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
@@ -415,10 +483,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/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/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/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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Schema
+  # Gem version, bumped by release-please
+  VERSION = '0.7.2'
+end

data/release-please-config.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+  "bootstrap-sha": "de8a6c418c6b662696e48b7af3b2d8ad55fb3b4e",
+  "packages": {
+    ".": {
+      "release-type": "ruby",
+      "package-name": "schema-model",
+      "version-file": "lib/schema/version.rb",
+      "include-component-in-tag": false
+    }
+  }
+}

data/schema-model.gemspec

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'lib/schema/version'
+
 Gem::Specification.new do |s|
   s.name        = 'schema-model'
-  s.version     = '0.7.0'
+  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'

data/script/coverage_badge.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Renders a shields-style SVG badge from SimpleCov's .last_run.json.
+#   script/coverage_badge.rb coverage/.last_run.json coverage.svg          # line coverage
+#   script/coverage_badge.rb coverage/.last_run.json branches.svg branch   # branch coverage
+
+require 'json'
+
+input, output, metric = ARGV
+abort "usage: #{$PROGRAM_NAME} <.last_run.json> <out.svg> [line|branch]" unless input && output
+
+result = JSON.parse(File.read(input)).fetch('result')
+title = metric == 'branch' ? 'branches' : 'coverage'
+percent = (metric == 'branch' ? result.fetch('branch') : result['line'] || result.fetch('covered_percent')).to_f
+label = "#{percent.floor(1)}%"
+
+color =
+  if percent >= 95 then '#4c1'
+  elsif percent >= 90 then '#97ca00'
+  elsif percent >= 80 then '#dfb317'
+  elsif percent >= 70 then '#fe7d37'
+  else '#e05d44'
+  end
+
+# ~7px per character at 11px Verdana, plus padding
+left_width = 63
+right_width = (label.length * 7) + 10
+width = left_width + right_width
+
+File.write(output, <<~SVG)
+  <svg xmlns="http://www.w3.org/2000/svg" width="#{width}" height="20" role="img" aria-label="#{title}: #{label}">
+    <title>#{title}: #{label}</title>
+    <linearGradient id="s" x2="0" y2="100%">
+      <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+      <stop offset="1" stop-opacity=".1"/>
+    </linearGradient>
+    <clipPath id="r"><rect width="#{width}" height="20" rx="3" fill="#fff"/></clipPath>
+    <g clip-path="url(#r)">
+      <rect width="#{left_width}" height="20" fill="#555"/>
+      <rect x="#{left_width}" width="#{right_width}" height="20" fill="#{color}"/>
+      <rect width="#{width}" height="20" fill="url(#s)"/>
+    </g>
+    <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
+      <text x="#{left_width / 2}" y="14">#{title}</text>
+      <text x="#{left_width + (right_width / 2)}" y="14">#{label}</text>
+    </g>
+  </svg>
+SVG

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: schema-model
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.2
 platform: ruby
 authors:
 - Doug Youch
 bindir: bin
 cert_chain: []
-date: 2026-02-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inheritance-helper
@@ -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
@@ -32,11 +35,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
+- ".release-please-manifest.json"
 - ".rubocop.yml"
 - ".ruby-gemset"
 - ".ruby-version"
 - ARCHITECTURE.md
+- CHANGELOG.md
 - CLAUDE.md
 - Gemfile
 - Gemfile.lock
@@ -63,9 +69,12 @@ files:
 - lib/schema/parsers/json.rb
 - lib/schema/parsing_errors.rb
 - lib/schema/utils.rb
+- lib/schema/version.rb
 - lib/schema_validator.rb
+- release-please-config.json
 - schema-model.gemspec
 - script/console
+- script/coverage_badge.rb
 homepage: https://github.com/dougyouch/schema
 licenses:
 - MIT
@@ -85,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+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: []