adaptiveconfiguration 1.0.0.beta04 → 1.0.0.beta07

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a11fad3ccce7d331a27190c743c44688ad95900a7cc8f168a4fdcb824b625bce
-  data.tar.gz: aa7ed25488d182dcaf59ec3f2f0a6442c9004660d9c22b8b1ba73b0e730b190c
+  metadata.gz: 1bddcf16845596d56add432ccd7aefe97a9764b1e99a644b9947427ef49819a2
+  data.tar.gz: bf5c024845348795609942aace53b06da90b5f0cfa8e531bf26569554e57c2cb
 SHA512:
-  metadata.gz: 82df20c8476433d0cec6cb10df0242b5b2b9acfe426741727871f67bde4b46b1bff4e3ab56c1bd8553284d5336074f48abad92ba30f3cc4ef2f27ca41e5b2429
-  data.tar.gz: c83a76b55815d78ddc19cce6a118ce6ce26f4c3a4288837e40ee9b565db1d13c329d8dfed04ef1f42923d76b703d20742b73de652a4857fd2f9b0f158e64c850
+  metadata.gz: a4d2af44187899024e1c2a4edbb7e811a613b438ee87a63badc87a3574a8740b6217289463cdc286d0312f4e353958c00a89c69b4dab9e6f93221446dc7ed1f8
+  data.tar.gz: 7a247388fdad9d6c99e2c2f6dd78e8490a0cfe5ce8172fb0388c25e19f5e2e4ef579c5613b614c29ce8cb56bc231f605473a064594c110307adc282722f2f924

data/adaptiveconfiguration.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do | spec |
 
   spec.name          = 'adaptiveconfiguration'
-  spec.version       = '1.0.0.beta04'
+  spec.version       = '1.0.0.beta07'
   spec.authors       = [ 'Kristoph Cichocki-Romanov' ]
   spec.email         = [ 'rubygems.org@kristoph.net' ]
 

data/lib/adaptive_configuration/builder.rb

@@ -1,5 +1,5 @@
 require_relative 'group_builder'
-require_relative 'context'
+require_relative 'scaffold'
 
 # types must be included to support conversation
 require 'time'
@@ -16,6 +16,7 @@ module AdaptiveConfiguration
       Time        => ->( v ) { v.respond_to?( :to_time ) ? v.to_time : Time.parse( v.to_s ) },
       URI         => ->( v ) { URI.parse( v.to_s ) },
       String      => ->( v ) { String( v ) },
+      Symbol      => ->( v ) { v.respond_to?( :to_sym ) ? v.to_sym : nil },
       Rational    => ->( v ) { Rational( v ) },
       Float       => ->( v ) { Float( v ) },
       Integer     => ->( v ) { Integer( v ) },
@@ -48,19 +49,123 @@ module AdaptiveConfiguration
     end
 
     def build( values = nil, &block )
-      context = AdaptiveConfiguration::Context.new( 
+      scaffold = AdaptiveConfiguration::Scaffold.new( 
         values,
         converters: @converters, 
         definitions: @definitions 
       )
-      context.instance_eval( &block ) if block
-      context
+      scaffold.instance_eval( &block ) if block
+      scaffold.to_h
     end
 
     def build!( values = nil, &block )
-      context = self.build( values, &block )
-      context.validate!
-      context
+      scaffold = AdaptiveConfiguration::Scaffold.new( 
+        values,
+        converters: @converters, 
+        definitions: @definitions 
+      )
+      scaffold.instance_eval( &block ) if block
+      result = scaffold.to_h 
+      validate!( result )
+      result 
+    end
+
+    def validate!( values )
+      traverse_and_validate_values( values, definitions: @definitions ) { | error | 
+        raise error 
+      } 
+    end
+    
+    def validate( values )
+      errors = []
+      traverse_and_validate_values( values, definitions: @definitions ) { | error | 
+        errors << error 
+      }
+      errors
+    end
+
+    def valid?( values )
+      traverse_and_validate_values( values, definitions: @definitions ) { 
+        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, definitions:, path: nil, options: nil, &block )  
+
+      path.chomp( '/' ) if path
+      unless values.is_a?( Hash )
+        # TODO: raise error
+        return
+      end
+
+      definitions.each do | key, definition |
+
+        name = definition[ :as ] || key 
+        value = values[ name ]
+
+        if definition[ :required ] && 
+           ( !value || ( value.respond_to?( :empty ) && value.empty? ) )
+          block.call( RequirementUnmetError.new( path: path, key: key ) )
+        elsif !definition[ :default_assigned ] && !value.nil?
+          unless definition[ :array ]
+            if definition[ :type ] == :group
+              traverse_and_validate_values( 
+                values[ name ],
+                definitions: definition[ :definitions ],
+                path: "#{ ( path || '' ) + ( path ? '/' : '' ) + key.to_s }", 
+                &block 
+              )
+            else     
+              if definition[ :type ] && value && !definition[ :default_assigned ]
+                unless value_matches_types?( value, definition[ :type ] )
+                  block.call( IncompatibleTypeError.new( 
+                    path: path, key: key, type: definition[ :type ], value: value
+                  ) )
+                end          
+              end
+            end
+          else 
+            if definition[ :type ] == :group
+              groups = Array( value )
+              groups.each do | group |
+                traverse_and_validate_values(
+                  group, 
+                  definitions: definition[ :definitions ],
+                  path: "#{ ( path || '' ) + ( path ? '/' : '' ) + key.to_s }", 
+                  &block 
+                )
+              end
+            else
+              if definition[ :type ] && !definition[ :default_assigned ]
+                value_array = Array( value )
+                value_array.each do | v | 
+                  unless value_matches_types?( v, definition[ :type ] )
+                    block.call( IncompatibleTypeError.new( 
+                      path: path, key: key, type: definition[ :type ], value: v
+                    ) )
+                  end
+                end  
+              end
+            end
+          end
+        end
+
+      end
+      
+      nil
+
     end
 
   end

data/lib/adaptive_configuration/group_builder.rb

@@ -1,4 +1,4 @@
-require_relative 'context'
+require_relative 'scaffold'
 
 module AdaptiveConfiguration 
   class GroupBuilder
@@ -14,8 +14,8 @@ module AdaptiveConfiguration
       name = name.to_sym 
       options = nil
 
-      raise NameError, "The parameter #{name} cannot be used." \
-        if AdaptiveConfiguration::Context.instance_methods.include?( name )
+      raise NameError, "The name '#{name}' is reserved and cannot be used for parameters." \
+        if AdaptiveConfiguration::Scaffold.instance_methods.include?( name )
 
       if args.first.is_a?( ::Hash )
         # when called without type: parameter :stream, as: :streams
@@ -30,12 +30,17 @@ module AdaptiveConfiguration
     end
 
     def group( name, options = {}, &block )
+      
+      raise NameError, "The name '#{name}' is reserved and cannot be used for parameters." \
+        if AdaptiveConfiguration::Scaffold.instance_methods.include?( name )
+      
       builder = GroupBuilder.new
       builder.instance_eval( &block ) if block
       @definitions[ name ] = options.merge( { 
         type: :group, 
         definitions: builder.definitions 
       } )
+
     end
 
   end

data/lib/adaptive_configuration/scaffold.rb

@@ -0,0 +1,177 @@
+module AdaptiveConfiguration
+  class Scaffold < BasicObject
+
+    include ::PP::ObjectMixin if defined?( ::PP )
+
+    attr_reader :errors
+
+    def initialize( values = nil, definitions:, converters: )
+      raise ArgumentError, 'The Scaffold initialitization attributes must be a Hash pr Hash-like.'\
+        unless values.nil? || ( values.respond_to?( :[] ) && values.respond_to?( :key? ) )
+
+      @converters = converters&.dup 
+      @definitions = definitions&.dup 
+      @values = {}
+      @errors = []
+      
+      @definitions.each do | key, definition |
+        name = definition[ :as ] || key 
+        if definition.key?( :default )
+          self.__send__( key, definition[ :default ] )
+          # note: this is needed to know when an array parameter which was initially assigned
+          #       to a default should be replaced rather than appended
+          definition[ :default_assigned ] = true
+        end
+        self.__send__( key, values[ key ] ) if values && values.key?( key ) 
+      end
+
+    end
+
+    def nil?
+      false  
+    end
+
+    def empty?
+      @values.empty?
+    end
+
+    def to_h
+      recursive_to_h = ->( object ) do
+        case object
+        when ::NilClass
+          nil
+        when ::AdaptiveConfiguration::Scaffold
+          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, definitions: @definitions }.inspect 
+    end
+
+    if defined?( ::PP )
+      def pretty_print( pp )
+        pp.pp( { values: @values, definitions: @definitions } )
+      end
+    end
+
+    def class
+      ::AdaptiveConfiguration::Scaffold
+    end
+
+    def is_a?( klass )
+      klass == ::AdaptiveConfiguration::Scaffold || klass == ::BasicObject
+    end
+
+    alias :kind_of? :is_a?
+
+    def method_missing( method, *args, &block )
+    
+      if @definitions.key?( method )
+        definition = @definitions[ method ]
+        name = definition[ :as ] || method
+
+        unless definition[ :array ] 
+          if definition[ :type ] == :group
+            value = args.first 
+            context = @values[ name ]
+            if context.nil? || value  
+              context = 
+                Scaffold.new( 
+                  value,
+                  converters: @converters, 
+                  definitions: definition[ :definitions ] 
+                )
+            end
+            context.instance_eval( &block ) if block
+            @values[ name ] = context 
+          else 
+            value = args.first
+            new_value = definition[ :type ] ? __coerce_value( definition[ :type ], value ) : value
+            @values[ name ] = new_value.nil? ? value : new_value
+          end
+        else
+          @values[ name ] = definition[ :default_assigned ] ? 
+            ::Array.new : 
+            @values[ name ] || ::Array.new
+          if definition[ :type ] == :group
+            values = [ args.first ].flatten
+            values = values.map do | v |
+              context = Scaffold.new( 
+                v,
+                converters: @converters, 
+                definitions: definition[ :definitions ] 
+              )
+              context.instance_eval( &block ) if block
+              context
+            end
+            @values[ name ].concat( values ) 
+          else
+            values = ::Kernel.method( :Array ).call( args.first )
+            if type = definition[ :type ]
+              values = values.map do | v | 
+                new_value = __coerce_value( type, v )
+                new_value.nil? ? v : new_value
+              end 
+            end
+            @values[ name ].concat( values )
+          end
+        end
+
+        definition[ :default_assigned ] = false
+        @values[ name ]
+      else
+        super
+      end
+
+    end
+
+    def respond_to?( method, include_private = false )
+      @definitions.key?( method ) || self.class.instance_methods.include?( method ) 
+    end
+
+    def respond_to_missing?( method, include_private = false )
+      @definitions.key?( method ) || self.class.instance_methods.include?( method ) 
+    end
+
+  protected 
+    
+    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
+
+  end
+end    

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adaptiveconfiguration
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta04
+  version: 1.0.0.beta07
 platform: ruby
 authors:
 - Kristoph Cichocki-Romanov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-08 00:00:00.000000000 Z
+date: 2024-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -57,9 +57,9 @@ files:
 - lib/adaptive_configuration.rb
 - lib/adaptive_configuration/builder.rb
 - lib/adaptive_configuration/configurable.rb
-- lib/adaptive_configuration/context.rb
 - lib/adaptive_configuration/errors.rb
 - lib/adaptive_configuration/group_builder.rb
+- lib/adaptive_configuration/scaffold.rb
 homepage: https://github.com/EndlessInternational/adaptive_configuration
 licenses:
 - MIT

data/lib/adaptive_configuration/context.rb

@@ -1,271 +0,0 @@
-module AdaptiveConfiguration
-  class Context < BasicObject
-
-    attr_reader :errors
-
-    def initialize( values = nil, definitions:, converters: )
-
-      values = values ? values.transform_keys( &:to_sym ) : {}
-      
-      @converters = converters&.dup 
-      @definitions = definitions&.dup 
-      @values = {}
-      @errors = []
-      
-      @definitions.each do | key, definition |
-        name = definition[ :as ] || key 
-        if definition[ :type ] == :group
-          context = Context.new( 
-            values[ key ] || {},
-            converters: @converters, definitions: definition[ :definitions ], 
-          )
-          @values[ name ] = context unless context.empty?
-        elsif definition.key?( :default )
-          @values[ name ] = definition[ :array ] ? 
-            ::Kernel.method( :Array ).call( definition[ :default ] ) : 
-            definition[ :default ]
-          # note: this is needed to know when an array paramter which was initially assigned
-          #       to a default should be replaced rather than appended
-          definition[ :default_assigned ] = true
-        end
-        self.__send__( key, values[ key ] ) if values[ key ]
-      end
-
-    end
-
-    def nil?
-      false  
-    end
-
-    def empty?
-      @values.empty?
-    end
-
-    def []( key )
-      @values[ key ]
-    end
-
-    def []=( key, value )
-      @values[ key ] = value
-    end
-
-    def each( &block )
-      @values.each( &block )
-    end
-
-
-    def merge( hash )
-      self.to_h.merge( hash )
-    end
-
-    def valid?
-      __validate_values
-      @errors.empty?
-    end 
-
-    def validate!
-      __validate_values { | error | ::Kernel.raise error }
-    end
-
-    def to_h
-      recursive_to_h = ->( object ) do
-        case object
-        when ::AdaptiveConfiguration::Context
-          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 to_yaml
-      self.to_h.to_yaml
-    end
-
-    def inspect
-      @values.inspect
-    end
-
-    def class
-      ::AdaptiveConfiguration::Context
-    end
-
-    def is_a?( klass )
-      klass == ::AdaptiveConfiguration::Context || klass == ::BasicObject
-    end
-
-    alias :kind_of? :is_a?
-
-    def method_missing( method, *args, &block )
-
-      if @definitions.key?( method )
-
-        definition = @definitions[ method ]
-        name = definition[ :as ] || method
-
-        unless definition[ :array ] 
-          if definition[ :type ] == :group
-            context = 
-              @values[ name ] || Context.new( 
-                args.first,
-                converters: @converters, 
-                definitions: definition[ :definitions ] 
-              )
-            context.instance_eval( &block ) if block
-            @values[ name ] = context 
-          else 
-            value = args.first
-            new_value = definition[ :type ] ? __coerce_value( definition[ :type ], value ) : value
-            @values[ name ] = new_value.nil? ? value : new_value
-          end
-        else
-          @values[ name ] = definition[ :default_assigned ] ? 
-            ::Array.new : 
-            @values[ name ] || ::Array.new
-          if definition[ :type ] == :group
-            context = Context.new( 
-              args.first,
-              converters: @converters, 
-              definitions: definition[ :definitions ] 
-            )
-            context.instance_eval( &block ) if block
-            @values[ name ] << context 
-          else
-            values = ::Kernel.method( :Array ).call( args.first )
-            if type = definition[ :type ]
-              values = values.map do | v | 
-                new_value = __coerce_value( type, v )
-                new_value.nil? ? v : new_value
-              end 
-            end
-            @values[ name ].concat( values )
-          end
-        end
-
-        definition[ :default_assigned ] = false
-        @values[ name ]
-
-      else
-        super
-      end
-
-    end
-
-    def respond_to?( method, include_private = false )
-      @definitions.key?( method ) || self.class.instance_methods.include?( method ) 
-    end
-
-    def respond_to_missing?( method, include_private = false )
-      @definitions.key?( method ) || self.class.instance_methods.include?( method ) 
-    end
-
-  protected 
-    
-    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 __validate_values( path = nil, &block )
-
-      path.chomp( '/' ) if path
-      @errors = []
-
-      is_of_matching_types = ::Proc.new do | value, types |
-        type_match = false  
-        ::Kernel.method( :Array ).call( types ).each do | type |
-          type_match = value.is_a?( type )
-          break if type_match
-        end
-        type_match
-      end 
-
-      @definitions.each do | key, definition |
-
-        name = definition[ :as ] || key 
-        value = @values[ name ]
-
-        if definition[ :required ] && 
-           ( !value || ( value.respond_to?( :empty ) && value.empty? ) )
-          
-          error = RequirementUnmetError.new( path: path, key: key )
-          block.call( error ) if block
-          @errors << error 
-        
-        elsif !definition[ :default_assigned ] && !value.nil?
-          
-          unless definition[ :array ]
-
-            if definition[ :type ] == :group
-              value.__validate_values( "#{ ( path || '' ) + ( path ? '/' : '' ) + key.to_s }", &block )
-              @errors.concat( value.errors )
-            else     
-              if definition[ :type ] && value && !definition[ :default_assigned ]
-                unless is_of_matching_types.call( value, definition[ :type ] )
-                  error = IncompatibleTypeError.new( 
-                    path: path, key: key, type: definition[ :type ], value: value
-                  )
-                  block.call( error ) if block
-                  @errors << error 
-                end          
-              end
-            end
-
-          else 
-
-            if definition[ :type ] == :group
-              groups.each do | group |
-                group.__validate_values( "#{ ( path || '' ) + ( path ? '/' : '' ) + key.to_s }", &block )
-                @errors.concat( group.errors )
-              end
-            else
-              if definition[ :type ] && !definition[ :default_assigned ]
-                values = ::Kernel.method( :Array ).call( value )
-                values.each do | v | 
-                  unless is_of_matching_types.call( v, definition[ :type ] )
-                    error = IncompatibleTypeError.new( 
-                      path: path, key: key, type: definition[ :type ], value: v
-                    )
-                    block.call( error ) if block
-                    @errors << error 
-                  end
-                end  
-              end
-            end
-
-          end
-        end
-      end
-    end
-
-  end
-end