dynamicschema 1.0.1 → 2.1.0

metadata

@@ -1,28 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: dynamicschema
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Kristoph Cichocki-Romanov
 bindir: bin
 cert_chain: []
-date: 2025-07-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.13'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.13'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -43,7 +43,11 @@ description: "The DynamicSchema gem provides a elegant and expressive way to def
   configurations or  interfacing with external APIs, where data structures need to
   adhere to specific formats  and validations. By allowing default values, type constraints,
   nested schemas, and  transformations, DynamicSchema ensures that your data structures
-  are both robust and  flexible."
+  are both robust and  flexible.  \n\nNew in 2.0, DynamicSchema adds DynamicSchema::Struct
+  which faciliates effortless definition and construction of complex object hierarchies,
+  with optional type coersion and validation. Where DynamicSchema simplified configuration
+  and API payload construction,  DynamicSchema::Struct simplifies construction of
+  complex API reponses."
 email:
 - rubygems.org@kristoph.net
 executables: []
@@ -56,12 +60,15 @@ files:
 - lib/dynamic_schema.rb
 - lib/dynamic_schema/buildable.rb
 - lib/dynamic_schema/builder.rb
-- lib/dynamic_schema/builder_methods/conversion.rb
-- lib/dynamic_schema/builder_methods/validation.rb
+- lib/dynamic_schema/compiler.rb
+- lib/dynamic_schema/converter.rb
 - lib/dynamic_schema/definable.rb
 - lib/dynamic_schema/errors.rb
-- lib/dynamic_schema/receiver.rb
-- lib/dynamic_schema/resolver.rb
+- lib/dynamic_schema/receiver/base.rb
+- lib/dynamic_schema/receiver/object.rb
+- lib/dynamic_schema/receiver/value.rb
+- lib/dynamic_schema/struct.rb
+- lib/dynamic_schema/validator.rb
 homepage: https://github.com/EndlessInternational/dynamic_schema
 licenses:
 - MIT
@@ -82,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: DynamicSchema is a lightweight and simple yet powerful gem that enables flexible
   semantic   schema definitions for constructing and validating complex configurations

data/lib/dynamic_schema/builder_methods/validation.rb

@@ -1,109 +0,0 @@
-module DynamicSchema
-  module BuilderMethods
-    module Validation
-
-      def validate!( values, schema: self.schema )
-        traverse_and_validate_values( values, schema: schema ) { | error | 
-          raise error 
-        } 
-      end
-    
-      def validate( values, schema: self.schema )
-        errors = []
-          traverse_and_validate_values( values, schema: schema ) { | error | 
-            errors << error 
-        }
-        errors
-      end
-
-      def valid?( values, schema: self.schema )
-        traverse_and_validate_values( values, schema: schema ) { 
-          return false 
-        }
-        return true
-      end
-
-    protected
-
-      def value_matches_types?( value, types )
-        type_match = false  
-        Array( types ).each do | type |
-          type_match = value.is_a?( type )
-          break if type_match
-        end
-        type_match
-      end 
-
-      def traverse_and_validate_values( values, schema:, path: nil, options: nil, &block )  
-        path.chomp( '/' ) if path
-        unless values.is_a?( Hash )
-          raise ArgumentError, "The values must always be a Hash." 
-        end
-
-        schema.each do | key, criteria |
-
-          name = criteria[ :as ] || key 
-          value = values[ name ]
-
-          if criteria[ :required ] && 
-             ( !value || ( value.respond_to?( :empty ) && value.empty? ) )
-            block.call( RequiredOptionError.new( path: path, key: key ) )
-          elsif criteria[ :in ] 
-            Array( value ).each do | v |
-              unless criteria[ :in ].include?( v ) || v.nil?
-                block.call( 
-                  InOptionError.new( path: path, key: key, option: criteria[ :in ], value: v )
-                )
-              end
-            end
-          elsif !criteria[ :default_assigned ] && !value.nil?
-            unless criteria[ :array ]
-              if criteria[ :type ] == Object
-                traverse_and_validate_values( 
-                  values[ name ],
-                  schema: criteria[ :schema ] ||= criteria[ :resolver ]._schema,
-                  path: "#{ ( path || '' ) + ( path ? '/' : '' ) + key.to_s }", 
-                  &block 
-                )
-              else     
-                if criteria[ :type ] && value && !criteria[ :default_assigned ]
-                  unless value_matches_types?( value, criteria[ :type ] )
-                    block.call( IncompatibleTypeError.new( 
-                      path: path, key: key, type: criteria[ :type ], value: value
-                    ) )
-                  end          
-                end
-              end
-            else 
-              if criteria[ :type ] == Object
-                groups = Array( value )
-                groups.each do | group |
-                  traverse_and_validate_values(
-                    group, 
-                    schema: criteria[ :schema ] ||= criteria[ :resolver ]._schema,
-                    path: "#{ ( path || '' ) + ( path ? '/' : '' ) + key.to_s }", 
-                    &block 
-                  )
-                end
-              else
-                if criteria[ :type ] && !criteria[ :default_assigned ]
-                  value_array = Array( value )
-                  value_array.each do | v | 
-                    unless value_matches_types?( v, criteria[ :type ] )
-                      block.call( IncompatibleTypeError.new( 
-                        path: path, key: key, type: criteria[ :type ], value: v
-                      ) )
-                    end
-                  end  
-                end
-              end
-            end
-          end
-
-        end
-        nil
-      end
-
-    end
-  end
-end

data/lib/dynamic_schema/receiver.rb

@@ -1,227 +0,0 @@
-module DynamicSchema 
-  class Receiver < BasicObject
-
-    if defined?( ::PP )
-      include ::PP::ObjectMixin 
-      def pretty_print( pp )
-        pp.pp( { values: @values, schema: @schema } )
-      end
-    end
-
-    def initialize( values = nil, schema:, converters: )
-      raise ArgumentError, 'The Receiver values must be a nil or a Hash.'\
-        unless values.nil? || ( values.respond_to?( :[] ) && values.respond_to?( :key? ) )
-      
-      @values = {}
-      @schema = schema
-      @defaults_assigned = {}
-
-      @converters = converters&.dup 
-      
-      @schema.each do | key, criteria |
-        name = criteria[ :as ] || key 
-        if criteria.key?( :default )
-          self.__send__( key, criteria[ :default ] )
-          @defaults_assigned[ key ] = true        
-        end
-        self.__send__( key, values[ key ] ) if values && values.key?( key ) 
-      end
-
-    end
-
-    def evaluate( &block )
-      self.instance_eval( &block )
-      self
-    end
-
-    def nil?
-      false  
-    end
-
-    def empty?
-      @values.empty?
-    end
-
-    def to_h
-      recursive_to_h = ->( object ) do
-        case object
-        when ::NilClass
-          nil
-        when ::DynamicSchema::Receiver
-          recursive_to_h.call( object.to_h )
-        when ::Hash
-          object.transform_values { | value | recursive_to_h.call( value ) }
-        when ::Array
-          object.map { | element | recursive_to_h.call( element ) }
-        else
-          object.respond_to?( :to_h ) ? object.to_h : object
-        end
-      end
-
-      recursive_to_h.call( @values )
-    end
-
-    def to_s
-      inspect
-    end
-
-    def inspect
-      { values: @values, schema: @schema }.inspect 
-    end
-
-    def class
-      ::DynamicSchema::Receiver
-    end
-
-    def is_a?( klass )
-      klass == ::DynamicSchema::Receiver || klass == ::BasicObject
-    end
-
-    alias :kind_of? :is_a?
-
-    def method_missing( method, *args, &block )
-      if @schema.key?( method )
-        criteria = @schema[ method ]
-        name = criteria[ :as ] || method
-        value = @values[ name ]
-
-        unless criteria[ :array ] 
-          if criteria[ :type ] == ::Object 
-            value = __object( method, args, value: value, criteria: criteria, &block )
-          else 
-            value = __value( method, args, value: value, criteria: criteria )
-          end
-        else
-          value = @defaults_assigned[ method ] ? ::Array.new : value || ::Array.new
-          if criteria[ :type ] == ::Object
-            value = __object_array( method, args, value: value, criteria: criteria, &block )
-          else
-            value = __values_array( method, args, value: value, criteria: criteria )
-          end
-        end
-
-        @defaults_assigned[ method ] = false
-        @values[ name ] = value 
-      else
-        ::Kernel.raise ::NoMethodError, 
-          "There is no schema value or object '#{method}' defined in this scope which includes: " \
-          "#{@schema.keys.join( ', ' )}." 
-      end
-    end
-
-    def respond_to?( method, include_private = false )
-      @schema.key?( method ) || self.class.instance_methods.include?( method ) 
-    end
-
-    def respond_to_missing?( method, include_private = false )
-      @schema.key?( method ) || self.class.instance_methods.include?( method ) 
-    end
-
-  protected 
-    
-    def __process_arguments( name, arguments, required_arguments:  )
-      count = arguments.count 
-      required_arguments = [ required_arguments ].flatten if required_arguments
-      required_count = required_arguments&.length || 0
-      ::Kernel.raise ::ArgumentError, 
-          "The attribute '#{name}' requires #{required_count} arguments " \
-          "(#{required_arguments.join(', ')}) but #{count} was given." \
-        if count < required_count 
-      ::Kernel.raise ::ArgumentError, 
-          "The attribute '#{name}' should have at most #{required_count + 1} arguments but " \
-          "#{count} was given." \
-        if count > required_count + 1
-
-      result = {}
-
-      required_arguments&.each_with_index do | name, index  |
-        result[ name.to_sym ] = arguments[ index ]
-      end
-      arguments.slice!( 0, required_arguments.length ) if required_arguments
-
-      last = arguments.last
-      case last 
-      when ::Hash 
-        result.merge( last )
-      when ::Array 
-        last.map { | v | result.merge( v ) }
-      else
-        result
-      end
-    end
-
-    def __coerce_value( types, value )
-      return value unless types && !value.nil?
-
-      types = ::Kernel.method( :Array ).call( types ) 
-      result = nil
-
-      if value.respond_to?( :is_a? )
-        types.each do | type |
-          result = value.is_a?( type ) ? value : nil 
-          break unless result.nil?
-        end
-      end
-
-      if result.nil?
-        types.each do | type |
-          result = @converters[ type ].call( value ) rescue nil
-          break unless result.nil?
-        end
-      end
-
-      result
-    end
-
-    def __value( method, arguments, value:, criteria: )
-      value = arguments.first
-      new_value = criteria[ :type ] ? __coerce_value( criteria[ :type ], value ) : value
-      new_value.nil? ? value : new_value
-    end
-
-    def __values_array( method, arguments, value:, criteria: )
-      values = [ arguments.first ].flatten
-      if type = criteria[ :type ]
-        values = values.map do | v | 
-          new_value = __coerce_value( type, v )
-          new_value.nil? ? v : new_value
-        end 
-      end
-      value.concat( values )
-    end 
-
-    def __object( method, arguments, value:, criteria:, &block )
-      attributes = __process_arguments( 
-        method, arguments, 
-        required_arguments: criteria[ :arguments ] 
-      )
-      if value.nil? || attributes&.any?  
-        value = 
-          Receiver.new( 
-            attributes,
-            converters: @converters, 
-            schema: criteria[ :schema ] ||= criteria[ :resolver ]._schema 
-          )
-      end
-      value.instance_eval( &block ) if block
-      value 
-    end
-
-    def __object_array( method, arguments, value:, criteria:, &block )
-      attributes = __process_arguments( 
-        method, arguments, 
-        required_arguments: criteria[ :arguments ] 
-      )
-      value.concat( [ attributes ].flatten.map { | a |
-        receiver = Receiver.new( 
-          a,
-          converters: @converters, 
-          schema: criteria[ :schema ] ||= criteria[ :resolver ]._schema 
-        )
-        receiver.instance_eval( &block ) if block
-        receiver
-      } )
-    end
-
-  end
-end