schema-model 0.6.10 → 0.6.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f8ccd138c2e52700656fe5bcf67ba518cdfb4c756cf656f821928758872c795
-  data.tar.gz: 90f75db3fc2e4fbae2bf350894b973cea392e652ca0be9b81368f0e9195f6c4b
+  metadata.gz: 0604e96e9d70ef3b47b7581ef0c6c43005960af46dde776565700abf86482ad5
+  data.tar.gz: cdfdbf20d77cfd81521df44308083b1134062c19e041752a2a194ee05c420c4d
 SHA512:
-  metadata.gz: ed515074d1a4ec263196f6217c9917f03dadb24dd6dc0b116168198b0c78e73c2cb18f268ed23ea19997d3d06a7fc46b269a51bd42b4e33c38325be0226b86d1
-  data.tar.gz: 58ccd5d4e9902f0dfff14e92222dcb2a6095cbd5bf281004ca738bdbc33618c38c300f76115d25ca91749d3d8b08cd4ec3548c0eb1fdeb43eabb0494b893055e
+  metadata.gz: 590a840b90865bc31c4c75c0f34f10135c9d410532c6585d64afa20e39f712262bb43794cea9414877eb8df3602567cf057deb75867d9436eea0315a313aea15
+  data.tar.gz: 0d9b8ee1ba799df269f396c68692e9210f90bde87192f3f121809a42db99647630b12c5624ed108ff58079a661a1f51b6547e876797dc32a0a887ebb7bcbfc41

data/.cursor-rules

@@ -0,0 +1,39 @@
+# Cursor Rules Configuration
+
+# Ignore common development and system files
+ignore {
+    ".git/"
+    ".DS_Store"
+    "*.log"
+    "tmp/"
+    "node_modules/"
+    "coverage/"
+}
+
+# Define common code block markers
+markers {
+    start "# START"
+    end "# END"
+}
+
+# Define language-specific comment styles
+comments {
+    ruby "#"
+    javascript "//"
+    python "#"
+    html "<!--"
+    css "/*"
+}
+
+# Define safe edit boundaries
+boundaries {
+    function_start "^(def|function|class) "
+    block_start "^(if|while|for|begin|module) "
+}
+
+# Define merge conflict markers to avoid
+conflicts {
+    start "<<<<<<< "
+    middle "======="
+    end ">>>>>>> "
+} 

data/.ruby-version

@@ -1 +1 @@
-3.1.0
+3.4.2

data/Gemfile

@@ -6,6 +6,7 @@ gem 'inheritance-helper'
 
 group :development do
   gem 'activemodel'
+  gem 'csv'
   gem 'rake'
   gem 'rubocop'
 end

data/Gemfile.lock

@@ -1,68 +1,97 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (7.0.2.3)
-      activesupport (= 7.0.2.3)
-    activesupport (7.0.2.3)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
+    activemodel (8.0.2)
+      activesupport (= 8.0.2)
+    activesupport (8.0.2)
+      base64
+      benchmark (>= 0.3)
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
       i18n (>= 1.6, < 2)
+      logger (>= 1.4.2)
       minitest (>= 5.1)
-      tzinfo (~> 2.0)
-    ast (2.4.2)
-    concurrent-ruby (1.1.9)
-    diff-lcs (1.5.0)
-    docile (1.4.0)
-    i18n (1.10.0)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    ast (2.4.3)
+    base64 (0.2.0)
+    benchmark (0.4.0)
+    bigdecimal (3.1.9)
+    concurrent-ruby (1.3.5)
+    connection_pool (2.5.0)
+    csv (3.3.3)
+    diff-lcs (1.6.1)
+    docile (1.4.1)
+    drb (2.2.1)
+    i18n (1.14.7)
       concurrent-ruby (~> 1.0)
     inheritance-helper (0.2.5)
-    minitest (5.15.0)
-    parallel (1.21.0)
-    parser (3.1.1.0)
+    json (2.10.2)
+    language_server-protocol (3.17.0.4)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    minitest (5.25.5)
+    parallel (1.26.3)
+    parser (3.3.7.4)
       ast (~> 2.4.1)
+      racc
+    prism (1.4.0)
+    racc (1.8.1)
     rainbow (3.1.1)
-    rake (13.0.6)
-    regexp_parser (2.2.1)
-    rexml (3.2.5)
-    rspec (3.11.0)
-      rspec-core (~> 3.11.0)
-      rspec-expectations (~> 3.11.0)
-      rspec-mocks (~> 3.11.0)
-    rspec-core (3.11.0)
-      rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.0)
+    rake (13.2.1)
+    regexp_parser (2.10.0)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.3)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.3)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-mocks (3.11.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-support (3.11.0)
-    rubocop (1.26.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.2)
+    rubocop (1.75.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
       parallel (~> 1.10)
-      parser (>= 3.1.0.0)
+      parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml
-      rubocop-ast (>= 1.16.0, < 2.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.44.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.16.0)
-      parser (>= 3.1.1.0)
-    ruby-progressbar (1.11.0)
-    simplecov (0.21.2)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.44.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.4)
+    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-html (0.12.3)
+    simplecov-html (0.13.1)
     simplecov_json_formatter (0.1.4)
-    tzinfo (2.0.4)
+    tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    unicode-display_width (2.1.0)
+    unicode-display_width (3.1.4)
+      unicode-emoji (~> 4.0, >= 4.0.4)
+    unicode-emoji (4.0.4)
+    uri (1.0.3)
 
 PLATFORMS
-  x86_64-darwin-21
+  arm64-darwin-24
+  ruby
 
 DEPENDENCIES
   activemodel
+  csv
   inheritance-helper
   rake
   rspec
@@ -70,4 +99,4 @@ DEPENDENCIES
   simplecov
 
 BUNDLED WITH
-   2.3.3
+   2.6.2

data/README.md

@@ -1,163 +1,190 @@
-# schema
+# Schema
 
-Fast and easy way to transform data into models for validation and type safety.
+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.
 
 [![Build Status](https://travis-ci.org/dougyouch/schema.svg?branch=master)](https://travis-ci.org/dougyouch/schema)
 [![Maintainability](https://api.codeclimate.com/v1/badges/c142d46a7a37d4a8c2e5/maintainability)](https://codeclimate.com/github/dougyouch/schema/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/c142d46a7a37d4a8c2e5/test_coverage)](https://codeclimate.com/github/dougyouch/schema/test_coverage)
 
-Attributes of a model have a name and type.  Any value passed in goes through a parser method.  If the value can not be parsed successfully the error is added to parsing_errors.
+## Features
 
-Associations are nested schema models.  Each association can have its own set of attributes.
+- **Type Safety**: Strong typing with automatic parsing and validation
+- **Flexible Attributes**: Support for aliases and custom data types
+- **Nested Models**: Complex data structures with nested associations
+- **Dynamic Associations**: Runtime type-based model creation
+- **ActiveModel Integration**: Seamless integration with ActiveModel validations
+- **Error Handling**: Comprehensive error collection and reporting
+- **CSV Support**: Built-in CSV parsing capabilities
 
-Dynamic associations are useful when creating custom logic around schema validation.
+## Installation
 
-#### Example that show cases multiple features
+Add this line to your application's Gemfile:
 
-###### spec/examples/company_schema.rb
 ```ruby
-# frozen_string_literal: true
+gem 'schema-model'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+## Quick Start
+
+Here's a simple example to get you started:
 
-# Example that show cases multiple features
-class CompanySchema
-  # includes model, associations, parsers and active model validations
+```ruby
+class UserSchema
   include Schema::All
 
-  # add common attributes
-  # attributes support additional names through the alias(es) option
-  attribute :name, :string, alias: 'CompanyName'
-  attribute :industry_type, :string, aliases: %w[IndustryType industry]
+  attribute :name, :string
+  attribute :age, :integer
+  attribute :email, :string
+  attribute :tags, :array, separator: ',', data_type: :string
+
+  validates :name, presence: true
+  validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
+end
+
+# Usage
+user_data = {
+  name: 'John Doe',
+  age: '30',
+  email: 'john@example.com',
+  tags: 'ruby,rails,developer'
+}
+
+user = UserSchema.from_hash(user_data)
+if user.valid?
+  puts "User created: #{user.name}"
+else
+  puts "Validation errors: #{user.errors.full_messages}"
+end
+```
 
-  # will take a string split on the separator and use the parse_<data_type> method on every element
-  # basically take a list of comma separated numbers and create an array of integers
-  # code snippet: str.split(',').map { |v| parse_integer(field_name, parsing_errors, v) }
-  attribute :number_list, :array, separator: ',', data_type: :integer
+## Core Concepts
 
-  # creates a nested dynamic schema based on the industry_type which is part of the main company data
-  industry_schema = has_one(:industry, external_type_field: :industry_type) do
-    attribute :name, :string
+### Attributes
 
-    validates :name, presence: true
+Attributes define the structure of your data model. Each attribute has:
+- A name
+- A type
+- Optional aliases
+- Custom parsing rules
 
-    add_type('tech') do
-      attribute :custom_description, :string
-    end
+```ruby
+attribute :name, :string, alias: 'FullName'
+attribute :age, :integer
+attribute :tags, :array, separator: ',', data_type: :string
+```
 
-    add_type('qsr') do
-      attribute :number_of_locations, :integer
+### Associations
 
-      # custom validation
-      validates :number_of_locations, presence: true
-    end
-  end
+Schema supports various types of associations:
 
-  # create multiple dynamic location schemas based on the type field in the location data
-  has_many(:locations, type_field: :type) do
-    attribute :type, :string
-    attribute :address, :string
-    attribute :city, :string
-    attribute :state, :string
-    attribute :zip, :string
+1. **Has One**: Single nested model
+2. **Has Many**: Multiple nested models
+3. **Dynamic Associations**: Type-based model creation
+
+```ruby
+has_one(:profile) do
+  attribute :bio, :string
+  attribute :website, :string
+end
+
+has_many(:posts) do
+  attribute :title, :string
+  attribute :content, :string
+end
+```
 
-    add_type('headquarters') do
-      attribute :main_floor, :integer
+### Dynamic Types
 
-      validates :city, presence: true
-      validates :main_floor, presence: true
-    end
+Create different model structures based on a type field:
 
-    add_type('store_front') do
-      attribute :main_entrance, :string
+```ruby
+has_many(:vehicles, type_field: :type) do
+  attribute :type, :string
+  attribute :color, :string
 
-      validates :address, presence: true
-      validates :main_entrance, presence: true
-    end
+  add_type('car') do
+    attribute :doors, :integer
   end
 
-  # create multiple dynamic employee schemas based on the type field in the employee data
-  has_many(:employees, type_field: :type) do
-    attribute :type, :integer
-    attribute :name, :string
-    attribute :start_date, :date
-    add_type(1) do # worker
-      attribute :manager_name, :string
-    end
-    add_type(2) do # manager
-      attribute :rank, :float
-    end
-    # if no or an invalid type is specified, create a default employee schema object
-    # useful for communicating errors in an API
-    default_type
-
-    # dynamic_type_names returns all the types used, except for :default
-    validates :type, inclusion: { in: dynamic_type_names }
+  add_type('truck') do
+    attribute :bed_length, :float
   end
+end
+```
 
-  has_many(:admins, from: :hash, hash_key_field: :username) do
-    attribute :username, :string
-    attribute :email, :string
-    attribute :name, :string
+## Advanced Features
 
-    validates :username, presence: true
-    validates :email, presence: true
+### Custom Parsers
+
+Define custom parsing logic for your attributes:
+
+```ruby
+attribute :custom_field, :custom_type do
+  def parse_custom_type(field_name, errors, value)
+    # Custom parsing logic
   end
+end
+```
 
-  validates :name, presence: true
-  validates :industry_type, inclusion: { in: industry_schema.dynamic_type_names }
+### CSV Integration
 
-  # use the schema validator
-  validates :industry, presence: true, schema: true
-  validates :locations, presence: true, schema: true
-  validates :employees, presence: true, schema: true
-  validates :admins, presence: true, schema: true
+Parse CSV data directly into your models:
+
+```ruby
+class UserCSVSchema
+  include Schema::CSVParser
+  
+  attribute :name, :string
+  attribute :email, :string
 end
+
+users = UserCSVSchema.parse_csv(csv_data)
 ```
 
-###### spec/examples/company_schema.json
-```javascript
-{
-  "CompanyName": "Good Burger",
-  "IndustryType": "qsr",
-  "industry": {
-    "name": "Food & Beverage",
-    "number_of_locations": 2
-  },
-  "locations": [
-    {
-      "type": "headquarters",
-      "city": "Boston",
-      "main_floor": 5
-    },
-    {
-      "type": "store_front",
-      "address": "1st Ave",
-      "zip": "02211",
-      "main_entrance": "side door"
-    }
-  ],
-  "employees": [
-    {
-      "type": 2,
-      "name": "Queen Bee",
-      "start_date": "2016-01-09",
-      "rank": "0.9"
-    },
-    {
-      "type": 1,
-      "name": "Worker Bee",
-      "start_date": "2018-05-10",
-      "manager_name": "Queen Bee"
-    }
-  ],
-  "admins": {
-    "captain": {
-      "email": "captain@example.com",
-      "name": "Captain Kurk"
-    },
-    "joe": {
-      "email": "joe.smith@example.com",
-      "name": "Joe Smith"
-    }
-  }
+## Using `skip_fields` to Protect Internal Fields
+
+When instantiating a schema with `from_hash`, you can use the `skip_fields` argument to prevent certain fields (such as `id`, `created_at`, `updated_at`) from being set by user input. This is especially useful for fields managed by the database or internal logic, ensuring end users cannot override these values.
+
+**Example:**
+
+```ruby
+user_data = {
+  id: 123, # Should be managed by DB
+  name: 'John Doe',
+  email: 'john@example.com',
+  created_at: '2024-06-01T12:00:00Z', # Should be managed by DB
+  updated_at: '2024-06-01T12:00:00Z'  # Should be managed by DB
 }
+
+# Skip DB-managed fields
+user = UserSchema.from_hash(user_data, [:id, :created_at, :updated_at])
+
+puts user.id          # => nil (not set from user input)
+puts user.created_at  # => nil (not set from user input)
+puts user.updated_at  # => nil (not set from user input)
+puts user.name        # => 'John Doe'
 ```
+
+**Benefit:**
+- Prevents end users from setting or changing internal DB values.
+- Ensures only safe, intended fields are settable from external input.
+- Helps maintain data integrity and security in your application.
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

data/docs/ARCHITECTURE.md

@@ -0,0 +1,171 @@
+# Schema Architecture Documentation
+
+## Overview
+
+Schema is a Ruby gem that provides a robust framework for data transformation, validation, and type safety. It follows a modular architecture that allows for flexible and extensible data modeling.
+
+## Core Components
+
+### 1. Model System (`lib/schema/model.rb`)
+
+The foundation of the Schema system, providing:
+- Attribute definition and management
+- Type system integration
+- Data parsing and validation
+- Association handling
+
+Key features:
+- Dynamic attribute registration
+- Type coercion and validation
+- Nested model support
+- Error collection and reporting
+
+### 2. Association System (`lib/schema/associations/`)
+
+Handles relationships between models:
+- `has_one`: Single nested model
+- `has_many`: Multiple nested models
+- Dynamic associations based on type fields
+- Hash-based associations
+
+### 3. Parser System (`lib/schema/parsers/`)
+
+Responsible for data type conversion and validation:
+- Built-in parsers for common types (string, integer, float, etc.)
+- Custom parser support
+- Array parsing with separators
+- CSV data parsing
+
+### 4. Validation System (`lib/schema/active_model_validations.rb`)
+
+Integrates with ActiveModel validations to provide:
+- Attribute presence validation
+- Format validation
+- Custom validation rules
+- Nested model validation
+
+### 5. Error Handling (`lib/schema/errors.rb`, `lib/schema/parsing_errors.rb`)
+
+Comprehensive error management:
+- Parsing errors
+- Validation errors
+- Nested model errors
+- Error message formatting
+
+## Data Flow
+
+1. **Initialization**
+   - Schema class definition
+   - Attribute registration
+   - Association setup
+   - Validation rules configuration
+
+2. **Data Processing**
+   - Input data parsing
+   - Type coercion
+   - Association resolution
+   - Validation execution
+
+3. **Error Collection**
+   - Parsing error collection
+   - Validation error aggregation
+   - Nested model error propagation
+
+## Extension Points
+
+### Custom Parsers
+
+```ruby
+module Schema::Parsers
+  class CustomParser
+    def self.parse(field_name, errors, value)
+      # Custom parsing logic
+    end
+  end
+end
+```
+
+### Custom Validators
+
+```ruby
+class CustomValidator < ActiveModel::Validator
+  def validate(record)
+    # Custom validation logic
+  end
+end
+```
+
+### Custom Associations
+
+```ruby
+module Schema::Associations
+  class CustomAssociation < Base
+    def initialize(name, options = {}, &block)
+      # Custom association logic
+    end
+  end
+end
+```
+
+## Performance Considerations
+
+1. **Attribute Access**
+   - Dynamic method generation for attribute accessors
+   - Caching of parsed values
+   - Lazy loading of associations
+
+2. **Validation**
+   - Early termination on first error
+   - Parallel validation of independent attributes
+   - Caching of validation results
+
+3. **Memory Management**
+   - Efficient error object creation
+   - Minimal object allocation during parsing
+   - Garbage collection optimization
+
+## Security Considerations
+
+1. **Data Validation**
+   - Strict type checking
+   - Input sanitization
+   - Size limits on collections
+
+2. **Error Handling**
+   - Safe error message generation
+   - No sensitive data exposure
+   - Controlled error propagation
+
+## Testing Strategy
+
+1. **Unit Tests**
+   - Individual component testing
+   - Mock dependencies
+   - Edge case coverage
+
+2. **Integration Tests**
+   - Component interaction testing
+   - Real-world usage scenarios
+   - Performance benchmarks
+
+3. **Regression Tests**
+   - Backward compatibility
+   - Bug fixes verification
+   - Performance regression detection
+
+## Future Considerations
+
+1. **Planned Features**
+   - JSON Schema integration
+   - GraphQL type generation
+   - Async validation support
+
+2. **Performance Improvements**
+   - Parallel processing
+   - Memory optimization
+   - Caching strategies
+
+3. **API Evolution**
+   - Backward compatibility
+   - Deprecation strategy
+   - Version management 

data/lib/schema/associations/has_many.rb

@@ -24,13 +24,13 @@ module Schema
     @#{name}_schema_creator ||= ::Schema::Associations::SchemaCreator.new(self, #{name.inspect})
   end
 
-  def #{options[:setter]}(v)
-    #{options[:instance_variable]} = #{name}_schema_creator.create_schemas(self, v)
+  def #{options[:setter]}(v, skip_fields = [])
+    #{options[:instance_variable]} = #{name}_schema_creator.create_schemas(self, v, skip_fields)
   end
 
-  def append_to_#{options[:getter]}(v)
+  def append_to_#{options[:getter]}(v, skip_fields = [])
     #{options[:instance_variable]} ||= []
-    #{options[:instance_variable]} << #{name}_schema_creator.create_schema(self, v)
+    #{options[:instance_variable]} << #{name}_schema_creator.create_schema(self, v, nil, skip_fields)
   end
 STR
           )

data/lib/schema/associations/has_one.rb

@@ -24,8 +24,8 @@ module Schema
     @#{name}_schema_creator ||= ::Schema::Associations::SchemaCreator.new(self, #{name.inspect})
   end
 
-  def #{options[:setter]}(v)
-    #{options[:instance_variable]} = #{name}_schema_creator.create_schema(self, v)
+  def #{options[:setter]}(v, skip_fields = [])
+    #{options[:instance_variable]} = #{name}_schema_creator.create_schema(self, v, nil, skip_fields)
   end
 STR
           )

data/lib/schema/associations/schema_creator.rb

@@ -17,13 +17,13 @@ module Schema
         configure_dynamic_schema_options(options)
       end
 
-      def create_schema(base_schema, data, error_name = nil)
+      def create_schema(base_schema, data, error_name = nil, skip_fields = [])
         if data.is_a?(Hash)
           unless (schema_class = get_schema_class(base_schema, data))
             add_parsing_error(base_schema, error_name, UNKNOWN) if base_schema.class.capture_unknown_attributes?
             return nil
           end
-          schema = schema_class.from_hash(data)
+          schema = schema_class.from_hash(data, skip_fields)
           add_parsing_error(base_schema, error_name, INVALID) unless schema.parsing_errors.empty?
           schema
         elsif !data.nil?
@@ -32,12 +32,12 @@ module Schema
         end
       end
 
-      def create_schemas(base_schema, list)
+      def create_schemas(base_schema, list, skip_fields = [])
         if is_list? && list.is_a?(Array)
-          list.each_with_index.map { |data, idx| create_schema(base_schema, data, "#{@schema_name}:#{idx}") }
+          list.each_with_index.map { |data, idx| create_schema(base_schema, data, "#{@schema_name}:#{idx}", skip_fields) }
         elsif !is_list? && list.is_a?(Hash)
           list.map do |(key, data)|
-            schema = create_schema(base_schema, data, "#{@schema_name}:#{key}")
+            schema = create_schema(base_schema, data, "#{@schema_name}:#{key}", skip_fields)
             schema.send(schema.class.schema[@hash_key_field][:setter], key)
             schema
           end

data/lib/schema/model.rb

@@ -73,8 +73,8 @@ module Schema
         add_aliases(name, options)
       end
 
-      def from_hash(data)
-        new.update_attributes(data)
+      def from_hash(data = nil, skip_fields = [])
+        new.update_attributes(data, skip_fields)
       end
 
       def schema_include(mod)
@@ -114,10 +114,10 @@ STR
       end
     end
 
-    def update_attributes(data)
+    def update_attributes(data = nil, skip_fields = [])
       schema = get_schema(data)
-      update_model_attributes(schema, data)
-      update_associations(schema, data)
+      update_model_attributes(schema, data, skip_fields)
+      update_associations(schema, data, skip_fields)
       self
     end
 
@@ -164,7 +164,7 @@ STR
       self.class.schema_with_string_keys
     end
 
-    def update_model_attributes(schema, data)
+    def update_model_attributes(schema, data, skip_fields)
       data.each do |key, value|
         unless schema.key?(key)
           parsing_errors.add(key, ::Schema::ParsingErrors::UNKNOWN_ATTRIBUTE) if self.class.capture_unknown_attributes?
@@ -172,17 +172,20 @@ STR
         end
 
         next if schema[key][:association]
+        next if skip_fields.include?(key)
 
         public_send(schema[key][:setter], value)
       end
     end
 
-    def update_associations(schema, data)
+    def update_associations(schema, data, skip_fields)
       data.each do |key, value|
         next unless schema.key?(key)
         next unless schema[key][:association]
 
-        public_send(schema[key][:setter], value)
+        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)
       end
     end
   end

data/schema-model.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'schema-model'
-  s.version     = '0.6.10'
+  s.version     = '0.6.11'
   s.licenses    = ['MIT']
   s.summary     = 'Schema Model'
   s.description = 'Easy way to create models from payloads'

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: schema-model
 version: !ruby/object:Gem::Version
-  version: 0.6.10
+  version: 0.6.11
 platform: ruby
 authors:
 - Doug Youch
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-28 00:00:00.000000000 Z
+date: 2025-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inheritance-helper
@@ -31,6 +30,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".cursor-rules"
 - ".gitignore"
 - ".rubocop.yml"
 - ".ruby-gemset"
@@ -42,6 +42,7 @@ files:
 - README.md
 - Rakefile
 - bin/schema-json2csv
+- docs/ARCHITECTURE.md
 - lib/schema-model.rb
 - lib/schema/active_model_validations.rb
 - lib/schema/all.rb
@@ -71,7 +72,6 @@ homepage: https://github.com/dougyouch/schema
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,8 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Schema Model
 test_files: []