schema-model 0.6.10 → 0.7.0

data/lib/schema/arrays.rb

@@ -15,7 +15,7 @@ module Schema
 
       def to_empty_array
         data = []
-        schema.each do |_, field_options|
+        schema.each_value do |field_options|
           next if field_options[:alias_of]
 
           data <<
@@ -24,8 +24,6 @@ module Schema
               const_get(field_options[:class_name]).to_empty_array
             when :has_many
               field_options[:size].times.map { const_get(field_options[:class_name]).to_empty_array }
-            else
-              nil
             end
         end
         data
@@ -33,16 +31,16 @@ module Schema
 
       def to_headers(prefix = nil)
         headers = []
-        schema.each do |_, field_options|
+        schema.each_value do |field_options|
           next if field_options[:alias_of]
 
           headers <<
             case field_options[:type]
             when :has_one
-              const_get(field_options[:class_name]).to_headers(prefix.to_s + field_options[:key] + '.')
+              const_get(field_options[:class_name]).to_headers("#{prefix}#{field_options[:key]}.")
             when :has_many
               field_options[:size].times.map do |i|
-                const_get(field_options[:class_name]).to_headers(prefix.to_s + field_options[:key] + "[#{i +1}].")
+                const_get(field_options[:class_name]).to_headers(prefix.to_s + field_options[:key] + "[#{i + 1}].")
               end
             else
               prefix.to_s + field_options[:key]
@@ -54,7 +52,7 @@ module Schema
 
     def to_a
       data = []
-      self.class.schema.each do |_, field_options|
+      self.class.schema.each_value do |field_options|
         next if field_options[:alias_of]
 
         value = public_send(field_options[:getter])
@@ -76,7 +74,7 @@ module Schema
     end
 
     def update_attributes_with_array(array, mapped_headers, offset = nil)
-      self.class.schema.each do |_, field_options|
+      self.class.schema.each_value do |field_options|
         next unless (mapped_field = mapped_headers[field_options[:name]])
 
         if offset
@@ -103,7 +101,7 @@ module Schema
     end
 
     def update_nested_has_one_associations_from_array(array, mapped_headers, current_offset = nil)
-      self.class.schema.each do |_, field_options|
+      self.class.schema.each_value do |field_options|
         next unless field_options[:type] == :has_one
         next unless (mapped_model = mapped_headers[field_options[:name]])
 
@@ -115,7 +113,7 @@ module Schema
     end
 
     def update_nested_has_many_associations_from_array(array, mapped_headers)
-      self.class.schema.each do |_, field_options|
+      self.class.schema.each_value do |field_options|
         next unless field_options[:type] == :has_many
         next unless (mapped_model = mapped_headers[field_options[:name]])
 
@@ -136,10 +134,10 @@ module Schema
 
     def largest_number_of_indexes_from_map(mapped_model)
       size = 0
-      mapped_model.each do |_, info|
+      mapped_model.each_value do |info|
         if info[:indexes]
-          size = info[:indexes].size if info[:indexes] && info[:indexes].size > size
-        else
+          size = info[:indexes].size if info[:indexes].size > size
+        elsif info.is_a?(Hash)
           new_size = largest_number_of_indexes_from_map(info)
           size = new_size if new_size > size
         end

data/lib/schema/associations/dynamic_types.rb

@@ -19,8 +19,8 @@ module Schema
           kls
         end
 
-        def default_type(options = {}, &block)
-          add_type(:default, options, &block)
+        def default_type(options = {}, &)
+          add_type(:default, options, &)
         end
 
         def dynamic_types
@@ -34,9 +34,7 @@ module Schema
         private
 
         def schema_dynamic_type_class_name(type)
-          ::Schema::Utils.classify_name(schema_name.to_s) +
-            'AssociationType' +
-            ::Schema::Utils.classify_name(type.to_s)
+          "#{::Schema::Utils.classify_name(schema_name.to_s)}AssociationType#{::Schema::Utils.classify_name(type.to_s)}"
         end
 
         def schema_add_dynamic_type(type, class_name)

data/lib/schema/associations/has_many.rb

@@ -10,12 +10,11 @@ module Schema
 
       # no-doc
       module ClassMethods
-        # rubocop:disable Naming/PredicateName
         def has_many(name, options = {}, &block)
           options = ::Schema::Utils.add_association_class(self, name, :has_many, options)
 
           class_eval(
-<<-STR, __FILE__, __LINE__ + 1
+            <<-STR, __FILE__, __LINE__ + 1
   def #{options[:getter]}
     #{options[:instance_variable]}
   end
@@ -24,15 +23,15 @@ 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
+            STR
           )
 
           kls = const_get(options[:class_name])
@@ -44,7 +43,6 @@ STR
           add_aliases(name, options)
           kls
         end
-        # rubocop:enable Naming/PredicateName
       end
     end
   end

data/lib/schema/associations/has_one.rb

@@ -10,12 +10,11 @@ module Schema
 
       # no-doc
       module ClassMethods
-        # rubocop:disable Naming/PredicateName
         def has_one(name, options = {}, &block)
           options = ::Schema::Utils.add_association_class(self, name, :has_one, options)
 
           class_eval(
-<<-STR, __FILE__, __LINE__ + 1
+            <<-STR, __FILE__, __LINE__ + 1
   def #{options[:getter]}
     #{options[:instance_variable]}
   end
@@ -24,22 +23,21 @@ 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
+            STR
           )
 
           kls = const_get(options[:class_name])
           kls.class_eval(&block) if block
           if options[:default]
-            options[:default_code] = options[:class_name] + '.new'
+            options[:default_code] = "#{options[:class_name]}.new"
             ::Schema::Utils.add_association_default_methods(self, options)
           end
           add_aliases(name, options)
           kls
         end
-        # rubocop:enable Naming/PredicateName
       end
     end
   end

data/lib/schema/associations/schema_creator.rb

@@ -17,32 +17,32 @@ 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?
-          add_parsing_error(base_schema, error_name, INCOMPATABLE)
+          add_parsing_error(base_schema, error_name, INCOMPATIBLE)
           nil
         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
         elsif !list.nil?
-          add_parsing_error(base_schema, @schema_name, INCOMPATABLE)
+          add_parsing_error(base_schema, @schema_name, INCOMPATIBLE)
           nil
         end
       end

data/lib/schema/csv_parser.rb

@@ -32,7 +32,7 @@ module Schema
 
     def get_mapped_headers(mapped_headers)
       indexed_headers = []
-      mapped_headers.each do |_, info|
+      mapped_headers.each_value do |info|
         if (index = info[:index])
           indexed_headers << @headers[index]
         elsif (indexes = info[:indexes])

data/lib/schema/model.rb

@@ -69,12 +69,12 @@ module Schema
 
         add_value_to_class_method(:schema, name => options)
         add_attribute_methods(name, options)
-        ::Schema::Utils.add_attribute_default_methods(self, options) if options.has_key?(:default)
+        ::Schema::Utils.add_attribute_default_methods(self, options) if options.key?(:default)
         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)
@@ -82,7 +82,8 @@ module Schema
         config[:schema_includes] = config[:schema_includes] + [mod]
         redefine_class_method(:schema_config, config.freeze)
         include mod
-        schema.values.each do |field_options|
+
+        schema.each_value do |field_options|
           next unless field_options[:association]
 
           const_get(field_options[:class_name]).schema_include(mod)
@@ -91,7 +92,7 @@ module Schema
 
       def add_attribute_methods(name, options)
         class_eval(
-<<-STR, __FILE__, __LINE__ + 1
+          <<-STR, __FILE__, __LINE__ + 1
   def #{options[:getter]}
     #{options[:instance_variable]}
   end
@@ -99,7 +100,11 @@ module Schema
   def #{options[:setter]}(v)
     #{options[:instance_variable]} = #{options[:parser]}(#{name.inspect}, parsing_errors, v)
   end
-STR
+
+  def #{options[:getter]}_was_set?
+    instance_variable_defined?(:#{options[:instance_variable]})
+  end
+          STR
         )
       end
 
@@ -114,27 +119,27 @@ 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
 
     def as_json(opts = {})
       self.class.schema.each_with_object({}) do |(field_name, field_options), memo|
-        unless field_options[:alias_of]
-          value = public_send(field_options[:getter])
-          next if value.nil? && !opts[:include_nils]
-          next if opts[:select_filter] && !opts[:select_filter].call(field_name, value, field_options)
-          next if opts[:reject_filter] && opts[:reject_filter].call(field_name, value, field_options)
-
-          if value.is_a?(Array)
-            memo[field_name] = value.map { |e| e.as_json(opts) }
-          else
-            memo[field_name] = value.respond_to?(:as_json) ? value.as_json(opts) : value
-          end
-        end
+        next if field_options[:alias_of]
+
+        value = public_send(field_options[:getter])
+        next if value.nil? && !opts[:include_nils]
+        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
       end
     end
 
@@ -156,15 +161,15 @@ STR
     private
 
     def get_schema(data)
-      data.each_key do |key|
-        break unless key.is_a?(Symbol)
+      return self.class.schema_with_string_keys unless data.is_a?(Hash)
 
-        return self.class.schema
-      end
-      self.class.schema_with_string_keys
+      first_key = data.each_key.first
+      return self.class.schema_with_string_keys unless first_key.is_a?(Symbol)
+
+      self.class.schema
     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 +177,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/lib/schema/parsers/array.rb

@@ -15,10 +15,10 @@ module Schema
             return data
           end
 
-          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATABLE)
+          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE)
           nil
         else
-          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATABLE)
+          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE)
           nil
         end
       end

data/lib/schema/parsers/common.rb

@@ -6,11 +6,10 @@ module Schema
   module Parsers
     # Schema::Parsers::Common are parser methods for basic types
     module Common
-      INTEGER_REGEX = /^[-+]?(?:[1-9]\d*|0)(?:\.0+)?$/.freeze
-      FLOAT_REGEX = /^[-+]?(?:[1-9]\d*|0)(?:\.\d+)?([Ee]-?\d+)?$/.freeze
-      BOOLEAN_REGEX = /^(?:1|t|true|on|y|yes)$/i.freeze
+      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
 
-      # rubocop:disable Metrics/CyclomaticComplexity
       def parse_integer(field_name, parsing_errors, value)
         case value
         when Integer
@@ -23,7 +22,7 @@ module Schema
             nil
           end
         when Float
-          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATABLE) if (value % 1) > 0.0
+          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE) if (value % 1) > 0.0
           value.to_i
         when nil
           nil
@@ -32,14 +31,13 @@ module Schema
           nil
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       def parse_string(field_name, parsing_errors, value)
         case value
         when String
           value
         when ::Hash, ::Array
-          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATABLE)
+          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE)
           nil
         when nil
           nil
@@ -54,7 +52,7 @@ module Schema
         when String
           value.empty? ? nil : value
         when ::Hash, ::Array
-          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATABLE)
+          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE)
           nil
         when nil
           nil

data/lib/schema/parsers/hash.rb

@@ -9,7 +9,7 @@ module Schema
         when ::Hash
           value
         else
-          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATABLE)
+          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE)
           nil
         end
       end

data/lib/schema/parsers/json.rb

@@ -16,7 +16,7 @@ module Schema
             nil
           end
         else
-          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATABLE)
+          parsing_errors.add(field_name, ::Schema::ParsingErrors::INCOMPATIBLE)
           nil
         end
       end

data/lib/schema/parsing_errors.rb

@@ -4,7 +4,7 @@ module Schema
   # Schema::ParsingErrors is a collection of parsing error messages
   module ParsingErrors
     INVALID = 'invalid'
-    INCOMPATABLE = 'incompatable'
+    INCOMPATIBLE = 'incompatible'
     UNKNOWN = 'unknown'
     UNKNOWN_ATTRIBUTE = 'unknown_attribute'
     UNHANDLED_TYPE = 'unhandled_type'

data/lib/schema/utils.rb

@@ -25,7 +25,7 @@ module Schema
     end
 
     def association_options(schema_name, schema_type, options)
-      options[:class_name] ||= 'Schema' + classify_name(schema_type.to_s) + classify_name(schema_name.to_s)
+      options[:class_name] ||= "Schema#{classify_name(schema_type.to_s)}#{classify_name(schema_name.to_s)}"
       options[:association] = true
       options[:aliases] = [options[:alias]] if options.key?(:alias)
       options[:hash_key_field] ||= :id if options[:from] == :hash
@@ -58,7 +58,7 @@ module Schema
 
     def add_attribute_default_methods(kls, options)
       kls.class_eval(
- <<-STR, __FILE__, __LINE__ + 1
+        <<-STR, __FILE__, __LINE__ + 1
   def #{options[:default_method]}
     #{options[:default].inspect}
   end
@@ -70,13 +70,13 @@ module Schema
       #{options[:instance_variable]}
     end
   end
-STR
+        STR
       )
     end
 
     def add_association_default_methods(kls, options)
       kls.class_eval(
- <<-STR, __FILE__, __LINE__ + 1
+        <<-STR, __FILE__, __LINE__ + 1
   def #{options[:default_method]}
     #{options[:default_code]}
   end
@@ -84,7 +84,7 @@ STR
   def #{options[:getter]}
     #{options[:instance_variable]} ||= #{options[:default_method]}
   end
-STR
+        STR
       )
     end
   end

data/lib/schema-model.rb

@@ -14,6 +14,7 @@ module Schema
       @errors = errors
     end
   end
+
   class ParsingException < SchemaException; end
   class ValidationException < SchemaException; end
 

data/schema-model.gemspec

@@ -2,10 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name        = 'schema-model'
-  s.version     = '0.6.10'
+  s.version     = '0.7.0'
   s.licenses    = ['MIT']
-  s.summary     = 'Schema Model'
-  s.description = 'Easy way to create models from payloads'
+  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.authors     = ['Doug Youch']
   s.email       = 'dougyouch@gmail.com'
   s.homepage    = 'https://github.com/dougyouch/schema'
@@ -13,5 +14,6 @@ Gem::Specification.new do |s|
   s.bindir      = 'bin'
   s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
 
-  s.add_runtime_dependency 'inheritance-helper'
+  s.add_dependency 'inheritance-helper'
+  s.metadata['rubygems_mfa_required'] = 'true'
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: schema-model
 version: !ruby/object:Gem::Version
-  version: 0.6.10
+  version: 0.7.0
 platform: ruby
 authors:
 - Doug Youch
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-28 00:00:00.000000000 Z
+date: 2026-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inheritance-helper
@@ -24,23 +23,25 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Easy way to create models from payloads
+description: A flexible DSL for defining strongly-typed data models with automatic
+  parsing, nested associations, dynamic types, and ActiveModel validations
 email: dougyouch@gmail.com
 executables:
 - schema-json2csv
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".ruby-gemset"
 - ".ruby-version"
-- ".travis.yml"
+- ARCHITECTURE.md
+- CLAUDE.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
-- Rakefile
 - bin/schema-json2csv
 - lib/schema-model.rb
 - lib/schema/active_model_validations.rb
@@ -64,14 +65,12 @@ files:
 - lib/schema/utils.rb
 - lib/schema_validator.rb
 - schema-model.gemspec
-- script/bundle_install_all_versions
 - script/console
-- script/rspec_all_versions
 homepage: https://github.com/dougyouch/schema
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -86,8 +85,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
+summary: Data transformation, validation, and type safety for Ruby
 test_files: []

data/.travis.yml

@@ -1,14 +0,0 @@
-env:
-  global:
-    - CC_TEST_REPORTER_ID=f06234974aa4c4c52d14cb9ef800df79de52013c38e1d149fd04f2284e722f57
-rvm:
-  - 3.1.0
-language: ruby
-before_script:
-  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
-  - chmod +x ./cc-test-reporter
-  - ./cc-test-reporter before-build
-script:
-  - bundle exec rspec
-after_script:
-  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

data/Rakefile

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubygems'
-require 'bundler/setup'
-require 'rake'
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.pattern = Dir.glob('spec/**/*_spec.rb')
-  t.rspec_opts = '--format documentation'
-end
-task default: :spec

data/script/bundle_install_all_versions

@@ -1,8 +0,0 @@
-#!/bin/bash
-
-cp Gemfile gemfiles/travis.gemfile
-
-for ruby_version in 1.9.3 2.1.9 2.6.3; do
-  cp Gemfile gemfiles/ruby_${ruby_version}.gemfile
-  rvm $ruby_version@schema do bundle install --gemfile=gemfiles/ruby_${ruby_version}.gemfile
-done

data/script/rspec_all_versions

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-for ruby_version in 1.9.3 2.1.9 2.6.3; do
-  rvm $ruby_version@schema do bundle exec --gemfile=gemfiles/ruby_${ruby_version}.gemfile rspec
-done