dynamicschema 1.0.1 → 2.1.0

data/dynamicschema.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do | spec |
 
   spec.name           = 'dynamicschema'
-  spec.version        = '1.0.1'
+  spec.version        = '2.1.0'
   spec.authors        = [ 'Kristoph Cichocki-Romanov' ]
   spec.email          = [ 'rubygems.org@kristoph.net' ]
 
@@ -19,6 +19,11 @@ Gem::Specification.new do | spec |
     and validations. By allowing default values, type constraints, nested schemas, and 
     transformations, DynamicSchema ensures that your data structures are both robust and 
     flexible.  
+
+    New 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.
   TEXT
 
   spec.license        = 'MIT'
@@ -33,7 +38,7 @@ Gem::Specification.new do | spec |
   spec.files         = Dir[ "lib/**/*.rb", "LICENSE", "README.md", "dynamicschema.gemspec" ]
   spec.require_paths = [ "lib" ]
 
-  spec.add_development_dependency 'rspec', '~> 3.13'
+  spec.add_development_dependency 'minitest', '~> 6.0'
   spec.add_development_dependency 'debug', '~> 1.9'
 
 end

data/lib/dynamic_schema/buildable.rb

@@ -6,15 +6,15 @@ module DynamicSchema
     end
 
     module ClassMethods
+      [ :build, :build_from_bytes, :build_from_file ].each do | name |
+        define_method( name ) do | *args, **kwargs, &block |
+          new( builder.public_send( name, *args, **kwargs, &block ) )
+        end
 
-      def build( attributes = nil, &block )
-        new( builder.build( attributes, &block ) )
-      end 
-
-      def build!( attributes = nil, &block )
-        new( builder.build!( attributes, &block ) )
-      end 
-
+        define_method( :"#{name}!" ) do | *args, **kwargs, &block |
+          new( builder.public_send( :"#{name}!", *args, **kwargs, &block ) )
+        end
+      end
     end 
 
   end

data/lib/dynamic_schema/builder.rb

@@ -1,38 +1,69 @@
-require_relative 'builder_methods/conversion'
-require_relative 'builder_methods/validation'
-require_relative 'resolver'
-require_relative 'receiver'
+require_relative 'compiler'
+require_relative 'receiver/object'
 
 module DynamicSchema
   class Builder 
-
-    include BuilderMethods::Validation 
-    include BuilderMethods::Conversion 
+    include Validator
+    include Converter
   
-    def initialize( schema = nil )
-      self.schema = schema 
-      super()
+    def initialize
+      self.compiled_schema = nil 
+      @schema_blocks = []
     end
 
-    def define( &block )
-      self.schema = Resolver.new( self.schema ).resolve( &block )._schema 
+    def define( inherit: nil, &block )
+      @schema_blocks << inherit if inherit
+      @schema_blocks << block if block
+
+      compiler = Compiler.new( self.compiled_schema )
+      compiler.compile( &inherit ) if inherit
+      compiler.compile( &block ) if block
+      self.compiled_schema = compiler.compiled
       self
     end 
 
-    def build( values = nil, &block )
-      receiver = Receiver.new( values, schema: self.schema, converters: self.converters )
+    def schema
+      blocks = @schema_blocks.dup
+      proc do 
+        blocks.each { | block | instance_eval( &block ) }
+      end
+    end
+
+    def build( values = nil, defaults: true, &block )
+      receiver = Receiver::Object.new( values, 
+                                       schema: self.compiled_schema, 
+                                       converter: self, 
+                                       defaults: defaults )      
       receiver.instance_eval( &block ) if block
       receiver.to_h 
     end
 
-    def build!( values = nil, &block )
-      result = self.build( values, &block )
-      validate!( result )
-      result 
+    def build_from_bytes( bytes, filename: '(schema)', values: nil, defaults: true )
+      receiver = Receiver::Object.new( values, 
+                                       schema: compiled_schema, 
+                                       converter: self, 
+                                       defaults: defaults )
+      receiver.instance_eval( bytes, filename, 1 )
+      receiver.to_h
+    end
+
+    def build_from_file( path, values: nil, defaults: true )
+      self.build_from_bytes( 
+        File.read( path, encoding: 'UTF-8' ), 
+        filename: path, values: values, defaults: defaults
+      )
+    end
+
+    [ :build, :build_from_bytes, :build_from_file ].each do |name|
+      define_method( :"#{name}!" ) do |*args, **kwargs, &blk|
+        result = public_send(name, *args, **kwargs, &blk)
+        validate!(result)
+        result
+      end
     end
 
   private 
-    attr_accessor :schema
+    attr_accessor :compiled_schema
 
   end
 end

data/lib/dynamic_schema/{resolver.rb → compiler.rb}

@@ -1,57 +1,60 @@
-require_relative 'receiver'
+require_relative 'receiver/object'
 
 module DynamicSchema
-  class Resolver < BasicObject
+  class Compiler < BasicObject
     
-    def initialize( schema = nil, resolved_blocks: nil )
-      @schema = schema || {}
+    def initialize( compiled_schema = nil, compiled_blocks: nil )
+      @compiled_schema = compiled_schema || {}
       
       @block = nil 
-      @resolved = false 
-      @resolved_blocks = resolved_blocks || []
+      @compiled = false 
+      @compiled_blocks = compiled_blocks || []
     end
 
-    def resolve( &block )
+    def compile( &block )
       @block = block 
-      @resolved = false 
-      unless @resolved_blocks.include?( @block )
-        @resolved_blocks << @block
+      @compiled = false 
+      unless @compiled_blocks.include?( @block )
+        @compiled_blocks << @block
         self.instance_eval( &@block )
-        @resolved = true 
+        @compiled = true 
       end
       self
     end
         
-    def _schema 
-
-      if !@resolved && @block 
-        @resolved_blocks << @block unless @resolved_blocks.include?( @block )
+    def compiled 
+      if !@compiled && @block 
+        @compiled_blocks << @block unless @compiled_blocks.include?( @block )
         self.instance_eval( &@block ) 
-        @resolved = true
+        @compiled = true
       end
-      @schema 
+      @compiled_schema 
     end
 
     def _value( name, options )
       name = name.to_sym
+      receiver = ::DynamicSchema::Receiver::Object
       ::Kernel.raise ::NameError, "The name '#{name}' is reserved and cannot be used for parameters." \
-        if ::DynamicSchema::Receiver.instance_methods.include?( name )
+        if receiver.method_defined?( name ) || receiver.private_method_defined?( name )
   
       _validate_in!( name, options[ :type ], options[ :in ] ) if options[ :in ] 
       
-      @schema[ name ] = options
+      @compiled_schema[ name ] = options
       self
     end
 
     def _object( name, options = {}, &block )
       name = name.to_sym
+      receiver = ::DynamicSchema::Receiver::Object
       ::Kernel.raise ::NameError, "The name '#{name}' is reserved and cannot be used for parameters." \
-        if ::DynamicSchema::Receiver.instance_methods.include?( name )
+        if receiver.method_defined?( name ) || receiver.private_method_defined?( name )
+
+      type = options[ :type ]
+      options[ :type ] = ::Object unless type.is_a?( ::Array )
 
-      @schema[ name ] = options.merge( {
-        type: ::Object,
-        resolver: Resolver.new( resolved_blocks: @resolved_blocks ).resolve( &block )
-      } )    
+      @compiled_schema[ name ] = options.merge( {
+        compiler: Compiler.new( compiled_blocks: @compiled_blocks ).compile( &block )
+      } )
       self
     end
 
@@ -60,33 +63,32 @@ module DynamicSchema
       options = nil
       if args.empty?
         options = {}
-      # when called with just options:              name as: :streams
       elsif first.is_a?( ::Hash )
-        options = first 
-      # when called with just type:                 name String 
-      #                                             name [ TrueClass, FalseClass ] 
-      elsif args.length == 1 && 
+        options = first
+      elsif args.length == 1 &&
             ( first.is_a?( ::Class ) || first.is_a?( ::Module ) || first.is_a?( ::Array ) )
         options = { type: first }
-      # when called with just type and options:     name String, default: 'the default'
-      elsif args.length == 2 && 
-            ( first.is_a?( ::Class ) || first.is_a?( ::Module ) || first.is_a?( ::Array ) ) && 
+      elsif args.length == 2 &&
+            ( first.is_a?( ::Class ) || first.is_a?( ::Module ) || first.is_a?( ::Array ) ) &&
             args[ 1 ].is_a?( ::Hash )
         options = args[ 1 ]
         options[ :type ] = args[ 0 ]
       else
         ::Kernel.raise \
-          ::ArgumentError, 
+          ::ArgumentError,
           "A schema definition may only include the type (Class or Module) followed by options (Hash). "
       end
 
       type = options[ :type ]
-      if type == ::Object || type.nil? && block 
+
+      if type.is_a?( ::Array ) && block
+        _object( method, options, &block )
+      elsif type == ::Object || ( type.nil? && block )
         _object( method, options, &block )
-      else 
+      else
         _value( method, options )
       end
-    
+
     end
 
     def to_s
@@ -94,15 +96,15 @@ module DynamicSchema
     end
 
     def inspect
-      { schema: @schema }.inspect 
+      { schema: @compiled_schema }.inspect 
     end
 
     def class
-      ::DynamicSchema::Resolver
+      ::DynamicSchema::Compiler
     end
 
     def is_a?( klass )
-      klass == ::DynamicSchema::Resolver || klass == ::BasicObject
+      klass == ::DynamicSchema::Compiler || klass == ::BasicObject
     end
 
     alias :kind_of? :is_a?
@@ -110,7 +112,7 @@ module DynamicSchema
     if defined?( ::PP )
       include ::PP::ObjectMixin 
       def pretty_print( pp )
-        pp.pp( { schema: @schema } )
+        pp.pp( { schema: @compiled_schema } )
       end
     end      
   
@@ -124,6 +126,3 @@ module DynamicSchema
 
   end
 end
-
-
-

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