dynamicschema 1.0.1 → 2.0.0

data/lib/dynamic_schema/{builder_methods/conversion.rb → converter.rb}

@@ -4,11 +4,47 @@ require 'date'
 require 'uri'
 
 module DynamicSchema 
-  module BuilderMethods
-    module Conversion 
+  module Converter 
+    extend self
 
-      DEFAULT_CONVERTERS = {
+    def register_converter( klass, &block )
+      self.converters[ klass ] = block 
+    end
+
+    def convert( value, to:, &block )
+      return value if value.nil? || to.nil?
+
+      to = Array( to )
+      result = nil 
+
+      if value.respond_to?( :is_a? )
+        to.each do | type |
+          result = value.is_a?( type ) ? value : nil  
+          break unless result.nil?
+        end
+      end
+
+      if result.nil?
+        to.each do | type |
+          converter = converters[ type ]
+          if converter
+            result = converter.call( value ) rescue nil 
+            break unless result.nil?
+          end
+        end
+      end
+
+      result.nil? && block ? block.call( value ) : result
+    end
 
+  private
+
+    def converters 
+      @converters ||= default_converters.dup
+    end
+  
+    def default_converters
+      {  
         Array       => ->( v ) { Array( v ) },
         Date        => ->( v ) { v.respond_to?( :to_date ) ? v.to_date : Date.parse( v.to_s ) },
         Time        => ->( v ) { v.respond_to?( :to_time ) ? v.to_time : Time.parse( v.to_s ) },
@@ -34,21 +70,8 @@ module DynamicSchema
             v.to_s.match(  /\A\s*(false|no)\s*\z/i ) ? false : nil 
           end
         }
-
-      }
-
-      def initialize
-        self.converters = DEFAULT_CONVERTERS.dup
-      end
-
-      def convertor( klass, &block )
-        self.converters[ klass ] = block 
-      end
-
-    private
-
-      attr_accessor :converters
-    
+      }.freeze
     end
+
   end
 end

data/lib/dynamic_schema/receiver/base.rb

@@ -0,0 +1,60 @@
+# Intentionally no requires here to avoid circular dependencies.
+
+module DynamicSchema 
+  module Receiver
+    class Base < BasicObject
+
+      def self.const_missing( name )
+        ::Object.const_get( name )
+      end
+
+      if defined?( ::PP )
+        include ::PP::ObjectMixin
+        def pretty_print( pp )
+          pp.pp( { values: @values, schema: @schema } )
+        end
+      end
+
+
+      def evaluate( &block )
+        self.instance_eval( &block )
+        self
+      end
+
+      def nil?
+        false  
+      end
+
+      def to_s
+        inspect
+      end
+
+      def inspect
+        { values: @values, schema: @schema }.inspect 
+      end
+
+    private
+
+      if defined?( ::PP )
+        def pp( *args )
+          ::PP.pp( *args )
+        end
+      end
+
+      %i[ String Integer Float Array Hash Symbol Rational Complex
+          raise require puts warn p ].each do | method |
+        define_method( method ) { | *args, &block | ::Kernel.public_send( method, *args, &block ) }
+      end      
+
+      def fail( *args ) = ::Kernel.raise( *args )
+
+      def require_relative( path )
+        location = ::Kernel.caller_locations( 1, 1 ).first
+        base_dir = location&.absolute_path ? ::File.dirname( location.absolute_path ) : ::File.dirname( location.path )
+        absolute = ::File.expand_path( path, base_dir )
+        ::Kernel.require( absolute )
+      end
+
+    end
+  end
+end    

data/lib/dynamic_schema/{receiver.rb → receiver/object.rb}

@@ -1,14 +1,11 @@
-module DynamicSchema 
-  class Receiver < BasicObject
+require_relative 'base'
+require_relative 'value'
 
-    if defined?( ::PP )
-      include ::PP::ObjectMixin 
-      def pretty_print( pp )
-        pp.pp( { values: @values, schema: @schema } )
-      end
-    end
+module DynamicSchema 
+  module Receiver
+    class Object < Base
 
-    def initialize( values = nil, schema:, converters: )
+    def initialize( values = nil, schema:, converter: )
       raise ArgumentError, 'The Receiver values must be a nil or a Hash.'\
         unless values.nil? || ( values.respond_to?( :[] ) && values.respond_to?( :key? ) )
       
@@ -16,7 +13,7 @@ module DynamicSchema
       @schema = schema
       @defaults_assigned = {}
 
-      @converters = converters&.dup 
+      @converter = converter
       
       @schema.each do | key, criteria |
         name = criteria[ :as ] || key 
@@ -29,15 +26,6 @@ module DynamicSchema
 
     end
 
-    def evaluate( &block )
-      self.instance_eval( &block )
-      self
-    end
-
-    def nil?
-      false  
-    end
-
     def empty?
       @values.empty?
     end
@@ -47,7 +35,7 @@ module DynamicSchema
         case object
         when ::NilClass
           nil
-        when ::DynamicSchema::Receiver
+        when ::DynamicSchema::Receiver::Object
           recursive_to_h.call( object.to_h )
         when ::Hash
           object.transform_values { | value | recursive_to_h.call( value ) }
@@ -61,20 +49,14 @@ module DynamicSchema
       recursive_to_h.call( @values )
     end
 
-    def to_s
-      inspect
-    end
-
-    def inspect
-      { values: @values, schema: @schema }.inspect 
-    end
-
     def class
-      ::DynamicSchema::Receiver
+      ::DynamicSchema::Receiver::Object
     end
 
     def is_a?( klass )
-      klass == ::DynamicSchema::Receiver || klass == ::BasicObject
+      klass == ::DynamicSchema::Receiver::Object || 
+      klass == ::DynamicSchema::Receiver::Base || 
+      klass == ::BasicObject
     end
 
     alias :kind_of? :is_a?
@@ -89,14 +71,14 @@ module DynamicSchema
           if criteria[ :type ] == ::Object 
             value = __object( method, args, value: value, criteria: criteria, &block )
           else 
-            value = __value( method, args, value: value, criteria: criteria )
+            value = __value( method, args, value: value, criteria: criteria, &block )
           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 )
+            value = __values_array( method, args, value: value, criteria: criteria, &block )
           end
         end
 
@@ -104,8 +86,8 @@ module DynamicSchema
         @values[ name ] = value 
       else
         ::Kernel.raise ::NoMethodError, 
-          "There is no schema value or object '#{method}' defined in this scope which includes: " \
-          "#{@schema.keys.join( ', ' )}." 
+          "There is no schema value or object '#{ method }' defined in this scope which includes: " \
+          "#{ @schema.keys.join( ', ' ) }." 
       end
     end
 
@@ -124,12 +106,12 @@ module DynamicSchema
       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." \
+          "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." \
+          "The attribute '#{ name }' should have at most #{ required_count + 1 } arguments but " \
+          "#{ count } was given." \
         if count > required_count + 1
 
       result = {}
@@ -165,7 +147,7 @@ module DynamicSchema
 
       if result.nil?
         types.each do | type |
-          result = @converters[ type ].call( value ) rescue nil
+          result = @converter.convert( value, to: type ) rescue nil
           break unless result.nil?
         end
       end
@@ -173,13 +155,16 @@ module DynamicSchema
       result
     end
 
-    def __value( method, arguments, value:, criteria: )
+    def __value( method, arguments, value:, criteria:, &block )
       value = arguments.first
       new_value = criteria[ :type ] ? __coerce_value( criteria[ :type ], value ) : value
-      new_value.nil? ? value : new_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: )
+    def __values_array( method, arguments, value:, criteria:, &block )
       values = [ arguments.first ].flatten
       if type = criteria[ :type ]
         values = values.map do | v | 
@@ -187,6 +172,11 @@ module DynamicSchema
           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 
 
@@ -197,10 +187,10 @@ module DynamicSchema
       )
       if value.nil? || attributes&.any?  
         value = 
-          Receiver.new( 
+          Receiver::Object.new( 
             attributes,
-            converters: @converters, 
-            schema: criteria[ :schema ] ||= criteria[ :resolver ]._schema 
+            converter: @converter, 
+            schema: criteria[ :schema ] ||= criteria[ :compiler ].compiled 
           )
       end
       value.instance_eval( &block ) if block
@@ -213,15 +203,50 @@ module DynamicSchema
         required_arguments: criteria[ :arguments ] 
       )
       value.concat( [ attributes ].flatten.map { | a |
-        receiver = Receiver.new( 
+        receiver = Receiver::Object.new( 
           a,
-          converters: @converters, 
-          schema: criteria[ :schema ] ||= criteria[ :resolver ]._schema 
+          converter: @converter, 
+          schema: criteria[ :schema ] ||= criteria[ :compiler ].compiled 
         )
         receiver.instance_eval( &block ) if block
         receiver
       } )
     end
 
+    def __value_block( method, value:, criteria:, &block )
+      if value.nil?
+        type = criteria[ :type ]
+        
+        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,167 @@
+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 ]
+
+              if 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
+
+          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,105 @@
+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 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?
+          unless criteria[ :array ]
+            if criteria[ :type ] == Object
+              traverse_and_validate_values(
+                values[ name ],
+                schema: criteria[ :schema ] ||= criteria[ :compiler ].compiled,
+                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[ :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