adaptiveconfiguration 1.0.0.beta06 → 1.0.0.beta08

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e6d7ffc7756d8ea2cb2d685ef00ca01561d232c99852516b38b7bf1ce72cb66
-  data.tar.gz: bb716f63caf1e4fec6a90da636a30a4bcfc7b546f610d548f275bb630780f2bc
+  metadata.gz: cca3cc7af7f052e713d6d1065610f79fe1857f4c677c9cf860098b6136aad366
+  data.tar.gz: 28a8496792f95133a62b7a3696d5dfff4b96fa5ed2d8214f50831b4a8c78996b
 SHA512:
-  metadata.gz: fbb8df8e89fab329b3ca8464a8088c0617b800ab981be36cae596debb7f29a26b2768520665926d2a30148074f981d59dbbade409932b5c02407efdcb600b5cc
-  data.tar.gz: ae9e3c1d6fde00f4136edf6e4cc9cb85e621170f78ba52c86211bb1121e3bfe20e9e76fb606bd009e218957c0a6260a127e03342c494cb733d4803d2ad8973ec
+  metadata.gz: 2e8df5aa99cdc79ce4aedac99a737f09c814df5e6287f30c4fb3595ce93fff7417d1311d150e9eddaca8fc6ea60dd82ff7d7ffed946f49463b30411356eeb147
+  data.tar.gz: ac67be155f79e5261c75bd805d0eaec9825cc2aa354b556227c4f9d8968b0cdd2ae634ed0377f024acdf2d4b518a5811a90a6006c42057dbe6911fb9d412c0a0

data/adaptiveconfiguration.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do | spec |
 
   spec.name          = 'adaptiveconfiguration'
-  spec.version       = '1.0.0.beta06'
+  spec.version       = '1.0.0.beta08'
   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'
@@ -49,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/configurable.rb

@@ -10,7 +10,13 @@ module AdaptiveConfiguration
     end
 
     def configure( attributes = nil, &block )
-      raise RuntimeError, "The adapter configuration has not been defined." \
+      raise RuntimeError, "The configuration has not been defined." \
+        if @configuration_builder.nil?
+      configuration = @configuration_builder.build( attributes, &block )
+    end
+    
+    def configure!( attributes = nil, &block )
+      raise RuntimeError, "The configuration has not been defined." \
         if @configuration_builder.nil?
       configuration = @configuration_builder.build!( attributes, &block )
     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/{context.rb → scaffold.rb}

@@ -1,5 +1,5 @@
 module AdaptiveConfiguration
-  class Context < BasicObject
+  class Scaffold < BasicObject
 
     include ::PP::ObjectMixin if defined?( ::PP )
 
@@ -35,40 +35,12 @@ module AdaptiveConfiguration
       @values.empty?
     end
 
-    def key?( key )
-      @values.key?( key )
-    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
+        when ::NilClass
+          nil
+        when ::AdaptiveConfiguration::Scaffold
           recursive_to_h.call( object.to_h )
         when ::Hash
           object.transform_values { | value | recursive_to_h.call( value ) }
@@ -86,10 +58,6 @@ module AdaptiveConfiguration
       inspect
     end
 
-    def to_yaml
-      self.to_h.to_yaml
-    end
-
     def inspect
       { values: @values, definitions: @definitions }.inspect 
     end
@@ -101,11 +69,11 @@ module AdaptiveConfiguration
     end
 
     def class
-      ::AdaptiveConfiguration::Context
+      ::AdaptiveConfiguration::Scaffold
     end
 
     def is_a?( klass )
-      klass == ::AdaptiveConfiguration::Context || klass == ::BasicObject
+      klass == ::AdaptiveConfiguration::Scaffold || klass == ::BasicObject
     end
 
     alias :kind_of? :is_a?
@@ -118,12 +86,12 @@ module AdaptiveConfiguration
 
         unless definition[ :array ] 
           if definition[ :type ] == :group
-            argument = args.first 
+            value = args.first 
             context = @values[ name ]
-            if context.nil? || argument  
+            if context.nil? || value  
               context = 
-                Context.new( 
-                  argument,
+                Scaffold.new( 
+                  value,
                   converters: @converters, 
                   definitions: definition[ :definitions ] 
                 )
@@ -142,7 +110,7 @@ module AdaptiveConfiguration
           if definition[ :type ] == :group
             values = [ args.first ].flatten
             values = values.map do | v |
-              context = Context.new( 
+              context = Scaffold.new( 
                 v,
                 converters: @converters, 
                 definitions: definition[ :definitions ] 
@@ -165,7 +133,6 @@ module AdaptiveConfiguration
 
         definition[ :default_assigned ] = false
         @values[ name ]
-
       else
         super
       end
@@ -206,78 +173,5 @@ module AdaptiveConfiguration
       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 = ::Kernel.method( :Array ).call( value )
-              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    

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adaptiveconfiguration
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta06
+  version: 1.0.0.beta08
 platform: ruby
 authors:
 - Kristoph Cichocki-Romanov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-09 00:00:00.000000000 Z
+date: 2024-10-13 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