dynamicschema 1.0.1 → 2.1.0

data/lib/dynamic_schema/receiver/object.rb

@@ -0,0 +1,301 @@
+require_relative 'base'
+require_relative 'value'
+
+module DynamicSchema 
+  module Receiver
+    class Object < Base
+
+      def initialize( values = nil, schema:, converter:, defaults: true )
+        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 = defaults
+        @defaults_assigned = {}
+
+        @converter = converter
+        
+        @schema.each do | key, criteria |
+          name = criteria[ :as ] || key 
+          if @defaults && 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 empty?
+        @values.empty?
+      end
+
+      def to_h
+        recursive_to_h = ->( object ) do
+          case object
+          when ::NilClass
+            nil
+          when ::DynamicSchema::Receiver::Object
+            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 class
+        ::DynamicSchema::Receiver::Object
+      end
+
+      def is_a?( klass )
+        klass == ::DynamicSchema::Receiver::Object || 
+        klass == ::DynamicSchema::Receiver::Base || 
+        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 ]
+
+          type = criteria[ :type ]
+          has_multiple_types = type.is_a?( ::Array ) && criteria[ :compiler ]
+
+          unless criteria[ :array ]
+            if has_multiple_types
+              value = __types( method, args, value: value, criteria: criteria, &block )
+            elsif type == ::Object
+              value = __object( method, args, value: value, criteria: criteria, &block )
+            else
+              value = __value( method, args, value: value, criteria: criteria, &block )
+            end
+          else
+            value = @defaults_assigned[ method ] ? ::Array.new : value || ::Array.new
+            if has_multiple_types
+              value = __types_array( method, args, value: value, criteria: criteria, &block )
+            elsif type == ::Object
+              value = __object_array( method, args, value: value, criteria: criteria, &block )
+            else
+              value = __values_array( method, args, value: value, criteria: criteria, &block )
+            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 = @converter.convert( value, to: type ) rescue nil
+            break unless result.nil?
+          end
+        end
+
+        result
+      end
+
+      def __value( method, arguments, value:, criteria:, &block )
+        value = arguments.first
+        new_value = criteria[ :type ] ? __coerce_value( criteria[ :type ], value ) : value
+        new_value = new_value.nil? ? value : new_value
+        block ? 
+          __value_block( method, value: new_value, criteria: criteria, &block ) : 
+          new_value
+      end
+
+      def __values_array( method, arguments, value:, criteria:, &block )
+        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
+        if block 
+          values = values.map do | value | 
+            __value_block( method, value: value, criteria: criteria, &block )
+          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::Object.new( 
+              attributes,
+              converter: @converter, 
+              schema: criteria[ :schema ] ||= criteria[ :compiler ].compiled,
+              defaults: @defaults
+            )
+        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::Object.new(
+            a,
+            converter: @converter,
+            schema: criteria[ :schema ] ||= criteria[ :compiler ].compiled,
+            defaults: @defaults
+          )
+          receiver.instance_eval( &block ) if block
+          receiver
+        } )
+      end
+
+      def __types( method, arguments, value:, criteria:, &block )
+        argument = arguments.first
+        if block || argument.is_a?( ::Hash )
+          if block && !value.nil? && !value.is_a?( ::DynamicSchema::Receiver::Object )
+            value = nil
+          end
+          __object( method, arguments, value: value, criteria: criteria, &block )
+        else
+          scalar_criteria = criteria.merge( type: __non_object_types( criteria[ :type ] ) )
+          __value( method, arguments, value: value, criteria: scalar_criteria, &block )
+        end
+      end
+
+      def __types_array( method, arguments, value:, criteria:, &block )
+        items = [ arguments.first ].flatten
+        if block
+          __object_array( method, arguments, value: value, criteria: criteria, &block )
+        else
+          items.each do | item |
+            if item.is_a?( ::Hash )
+              __object_array( method, [ item ], value: value, criteria: criteria )
+            else
+              scalar_criteria = criteria.merge( type: __non_object_types( criteria[ :type ] ) )
+              __values_array( method, [ item ], value: value, criteria: scalar_criteria )
+            end
+          end
+          value
+        end
+      end
+
+      def __non_object_types( types )
+        types_array = types.is_a?( ::Array ) ? types : [ types ]
+        result = types_array.reject { | type | type == ::Object }
+        result.length == 1 ? result.first : result
+      end
+
+      def __value_block( method, value:, criteria:, &block )
+        type = criteria[ :type ]
+
+        # if the value type is a Proc the block is the value 
+        return block if type == ::Proc
+        
+        if value.nil?
+          if type.is_a?( ::Array )
+            if type.length == 1
+              type = type.first
+            else
+              ::Kernel.raise ::TypeError, 
+                             "An explicit value for '#{method}' is required when using a block " +
+                             "because multiple types were specified."
+            end
+          end
+
+          case type
+          when ::Class
+            begin
+              value = type.new
+            rescue => error
+              ::Kernel.raise ::TypeError, 
+                             "An explicit value for '#{method}' is required because '#{type}' " + 
+                             "could not be constructed: #{error.message}."
+            end
+          else
+            ::Kernel.raise ::TypeError, 
+                           "An explicit value for '#{method}' is required because '#{type}' is " +
+                           "not a Class."
+          end
+
+        end
+        ::DynamicSchema::Receiver::Value.new( value ).instance_eval( &block )
+        value
+      end
+
+    end
+  end
+end    

data/lib/dynamic_schema/receiver/value.rb

@@ -0,0 +1,27 @@
+require_relative 'base'
+
+module DynamicSchema
+  module Receiver
+    class Value < Base
+      def initialize( target )
+        @target = target
+      end
+
+      def method_missing( method_name, *args, &block )
+        writer_method = :"#{ method_name }="
+        unless @target.respond_to?( writer_method )
+          ::Kernel.raise ::NoMethodError,
+            "The attribute '#{ method_name }' cannot be assigned because '#{ @target.class.name }' does not define '#{ writer_method }'."
+        end
+
+        if args.length != 1
+          ::Kernel.raise ::ArgumentError,
+            "The attribute '#{ method_name }' requires 1 argument but #{ args.length } was given."
+        end
+
+        @target.public_send( writer_method, args.first )
+      end
+    end
+  end
+end
+

data/lib/dynamic_schema/struct.rb

@@ -0,0 +1,203 @@
+module DynamicSchema
+  class Struct
+    include Validator
+    class << self
+
+      def define( inherit: nil, &block )
+        builder = ::DynamicSchema.define( inherit: inherit, &block )
+        new( builder.schema )
+      end
+     
+      def new( *arguments, &block )
+        unless self == ::DynamicSchema::Struct
+          super
+        else
+          __schema = arguments.first  
+          ::Kernel.raise ::ArgumentError, "A Struct requires a schema." \
+            unless __schema 
+          __converter = ::DynamicSchema::Converter
+
+          __compiled_schema = __compile_schema( __schema )
+          __klass = ::Class.new( self ) do
+            
+            class << self
+              def build( attributes = {}, &block )
+                struct = new( attributes )
+                block.call( struct ) if block
+                struct
+              end
+
+              def build!( attributes = {}, &block )
+                struct = build( attributes, &block )
+                struct.validate!
+                struct
+              end
+            end
+
+            def initialize( attributes = nil )
+              @attributes = attributes&.dup || {}
+              @converted_attributes = {}
+            end
+
+            __compiled_schema.each do | property, criteria |
+
+              key = ( criteria[ :as ] || property ).to_sym
+              type = criteria[ :type ]
+              default = criteria[ :default ]
+              has_multiple_types = type.is_a?( ::Array ) && criteria[ :compiler ]
+
+              if has_multiple_types
+                define_method( property ) do
+                  @converted_attributes.fetch( key ) do
+                    value = @attributes[ key ]
+                    value = default if value.nil?
+                    schema = criteria[ :schema ] ||= ( criteria[ :compiler ]&.compiled )
+                    klass = criteria[ :class ] ||= ( schema ? ::DynamicSchema::Struct.new( schema ) : nil )
+                    @converted_attributes[ key ] =
+                      if criteria[ :array ]
+                        __convert_types_array( Array( value ), klass, criteria )
+                      else
+                        __convert_types( value, klass, criteria )
+                      end
+                  end
+                end
+              elsif type == ::Object
+                define_method( property ) do
+                  @converted_attributes.fetch( key ) do
+                    value = @attributes[ key ]
+                    schema = criteria[ :schema ] ||= ( criteria[ :compiler ]&.compiled )
+                    return value unless schema
+                    klass = criteria[ :class ] ||= ::DynamicSchema::Struct.new( schema )
+                    @converted_attributes[ key ] =
+                      if criteria[ :array ]
+                        Array( value || default ).map { | v | klass.build( v || {} ) }
+                      else
+                        klass.build( value || default )
+                      end
+                  end
+                end
+              elsif type
+                define_method( property ) do
+                  @converted_attributes.fetch( key ) do
+                    value = @attributes[ key ]
+                    @converted_attributes[ key ] = criteria[ :array ] ?
+                      Array( value || default ).map { | v | __convert( v, to: type ) } :
+                      __convert( value || default, to: type )
+                  end
+                end
+              else
+                define_method( property ) do
+                  @attributes[ key ] || default
+                end
+              end
+
+              define_method( :"#{ property }=" ) do | value |
+                @converted_attributes.delete( key )
+                @attributes[ key ] = value
+              end
+
+            end
+          
+            [ :validate!, :validate, :valid? ].each do | method |
+              define_method( method ) { super( @attributes ) }
+            end
+
+            def to_h
+              result = {}
+              self.compiled_schema.each do | property, criteria |
+                key = criteria[ :as ] || property
+                value = __object_to_h( self.send( property ) ) 
+                result[ key ] = value unless value.nil?
+              end
+              result
+            end
+
+          private
+
+            def compiled_schema
+              self.class.compiled_schema
+            end
+
+            def __object_to_h( object )
+              case object
+              when nil
+                nil
+              when ::Hash
+                object.transform_values { | v | __object_to_h( v ) } unless object.empty?
+              when ::Array
+                object.map { | e | __object_to_h( e ) } unless object.empty?
+              else
+                if object.respond_to?( :to_h )
+                  __object_to_h( object.to_h )
+                else
+                  object
+                end
+              end
+            end
+
+            def __convert( value, to: )
+              self.class.converter.convert( value, to: to ) { | v | to.new( v ) rescue nil }
+            end
+
+            def __convert_types( value, klass, criteria )
+              return nil if value.nil?
+              if value.is_a?( ::Hash )
+                klass ? klass.build( value ) : value
+              else
+                scalar_types = __non_object_types( criteria[ :type ] )
+                __convert( value, to: scalar_types )
+              end
+            end
+
+            def __convert_types_array( values, klass, criteria )
+              values.map { | v | __convert_types( v, klass, criteria ) }
+            end
+
+            def __non_object_types( types )
+              types_array = types.is_a?( ::Array ) ? types : [ types ]
+              result = types_array.reject { | type | type == ::Object }
+              result.length == 1 ? result.first : result
+            end
+
+          end
+          __klass.instance_variable_set( :@__compiled_schema, __compiled_schema.dup )
+          __klass.instance_variable_set( :@__converter, __converter )
+          __klass.class_eval( &block ) if block
+          __klass
+        end
+      end
+
+      def compiled_schema
+        @__compiled_schema || 
+          ( superclass.respond_to?( :compiled_schema ) && superclass.compiled_schema )
+      end
+
+      def converter
+        @__converter || ( superclass.respond_to?( :converter ) && superclass.converter )
+      end
+
+    private 
+
+      def __compile_schema( schema )
+        case schema
+        when ::Proc
+          compiler = ::DynamicSchema::Compiler.new
+          compiler.compile( &schema )
+          compiler.compiled
+        when ::Hash
+          ::Kernel.raise ::ArgumentError,
+                         "A Struct requires a schema but an empty Hash was given." \
+            if schema.empty?
+          schema
+        else
+          if schema.respond_to?( :compiled_schema, true )
+            schema.send( :compiled_schema )
+          else
+            ::Kernel.raise ::ArgumentError,
+                           "A Struct requires a schema. I must be a Builder, Proc, or Hash."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_schema/validator.rb

@@ -0,0 +1,139 @@
+module DynamicSchema
+  module Validator
+    extend self
+
+    def validate!( values, schema: compiled_schema )
+      traverse_and_validate_values( values, schema: schema ) { | error |
+        raise error
+      }
+    end
+
+    def validate( values, schema: compiled_schema )
+      errors = []
+      traverse_and_validate_values( values, schema: schema ) { | error |
+        errors << error
+      }
+      errors
+    end
+
+    def valid?( values, schema: compiled_schema )
+      traverse_and_validate_values( values, schema: schema ) do
+        return false
+      end
+      true
+    end
+
+  protected 
+
+    def compiled_schema
+      raise ::NotImplementedError, 
+            "The DynamicSchema::Validator requires an includind class to implement the " +
+            "`compiled_schema` method."
+    end
+
+    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 __validate_types( value, criteria, path, key, &block )
+      if value.is_a?( ::Hash )
+        traverse_and_validate_values(
+          value,
+          schema: criteria[ :schema ] ||= criteria[ :compiler ].compiled,
+          path: "#{ ( path || '' ) + ( path ? '/' : '' ) + key.to_s }",
+          &block
+        )
+      else
+        scalar_types = __non_object_types( criteria[ :type ] )
+        unless value_matches_types?( value, scalar_types )
+          block.call( IncompatibleTypeError.new( path: path, key: key, type: criteria[ :type ], value: value ) )
+        end
+      end
+    end
+
+    def __validate_types_array( values, criteria, path, key, &block )
+      values.each do | value |
+        __validate_types( value, criteria, path, key, &block )
+      end
+    end
+
+    def __non_object_types( types )
+      types_array = types.is_a?( ::Array ) ? types : [ types ]
+      types_array.reject { | type | type == ::Object }
+    end
+
+    def traverse_and_validate_values( values, schema:, path: nil, options: nil, &block )
+      path.chomp( '/' ) if path
+      unless values.respond_to?( :[] )
+        raise ArgumentError, "The values must respond_to `[]`."
+      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?
+          type = criteria[ :type ]
+          has_multiple_types = type.is_a?( ::Array ) && criteria[ :compiler ]
+
+          unless criteria[ :array ]
+            if has_multiple_types
+              __validate_types( value, criteria, path, key, &block )
+            elsif type == Object
+              traverse_and_validate_values(
+                values[ name ],
+                schema: criteria[ :schema ] ||= criteria[ :compiler ].compiled,
+                path: "#{ ( path || '' ) + ( path ? '/' : '' ) + key.to_s }",
+                &block
+              )
+            else
+              if type && value && !criteria[ :default_assigned ]
+                unless value_matches_types?( value, type )
+                  block.call( IncompatibleTypeError.new( path: path, key: key, type: type, value: value ) )
+                end
+              end
+            end
+          else
+            if has_multiple_types
+              __validate_types_array( Array( value ), criteria, path, key, &block )
+            elsif type == Object
+              groups = Array( value )
+              groups.each do | group |
+                traverse_and_validate_values(
+                  group,
+                  schema: criteria[ :schema ] ||= criteria[ :compiler ].compiled,
+                  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

data/lib/dynamic_schema.rb

@@ -1,11 +1,16 @@
 require_relative 'dynamic_schema/errors'
+
+require_relative 'dynamic_schema/validator'
+require_relative 'dynamic_schema/converter'
 require_relative 'dynamic_schema/builder'
 
 require_relative 'dynamic_schema/definable'
 require_relative 'dynamic_schema/buildable'
 
+require_relative 'dynamic_schema/struct'
+
 module DynamicSchema  
-  def self.define( schema = {}, &block )
-    Builder.new( schema ).define( &block )
+  def self.define( inherit: nil, &block )
+    Builder.new.define( inherit: inherit, &block )
   end
 end